recker 1.0.79 → 1.0.80-next.70ea84d

package/dist/testing/mock-whois-server.js

@@ -1,234 +0,0 @@
-import { EventEmitter } from 'node:events';
-import * as net from 'node:net';
-export class MockWhoisServer extends EventEmitter {
-    options;
-    server = null;
-    domains = new Map();
-    started = false;
-    stats = {
-        queriesReceived: 0,
-        responseSent: 0,
-        queryLog: [],
-    };
-    constructor(options = {}) {
-        super();
-        this.options = {
-            port: 4343,
-            host: '127.0.0.1',
-            delay: 0,
-            ...options,
-        };
-        this.addDefaultDomains();
-    }
-    get isRunning() {
-        return this.started;
-    }
-    get port() {
-        return this.options.port;
-    }
-    get host() {
-        return this.options.host;
-    }
-    get url() {
-        return `${this.options.host}:${this.options.port}`;
-    }
-    get statistics() {
-        return { ...this.stats };
-    }
-    addDomain(domain, data) {
-        this.domains.set(domain.toLowerCase(), data);
-    }
-    removeDomain(domain) {
-        this.domains.delete(domain.toLowerCase());
-    }
-    getDomain(domain) {
-        return this.domains.get(domain.toLowerCase());
-    }
-    clearDomains() {
-        this.domains.clear();
-        this.addDefaultDomains();
-    }
-    addDefaultDomains() {
-        this.addDomain('example.com', {
-            registrar: 'RESERVED-Internet Assigned Numbers Authority',
-            registrarUrl: 'http://www.iana.org',
-            createdDate: '1995-08-14T04:00:00Z',
-            updatedDate: '2023-08-14T07:01:38Z',
-            expiryDate: '2024-08-13T04:00:00Z',
-            status: ['client delete prohibited', 'client transfer prohibited', 'client update prohibited'],
-            nameservers: ['a.iana-servers.net', 'b.iana-servers.net'],
-            dnssec: 'signedDelegation',
-        });
-        this.addDomain('google.com', {
-            registrar: 'MarkMonitor Inc.',
-            registrarUrl: 'http://www.markmonitor.com',
-            createdDate: '1997-09-15T04:00:00Z',
-            updatedDate: '2019-09-09T15:39:04Z',
-            expiryDate: '2028-09-14T04:00:00Z',
-            status: ['client delete prohibited', 'client transfer prohibited', 'client update prohibited', 'server delete prohibited', 'server transfer prohibited', 'server update prohibited'],
-            nameservers: ['ns1.google.com', 'ns2.google.com', 'ns3.google.com', 'ns4.google.com'],
-            registrantOrg: 'Google LLC',
-            registrantEmail: 'Select Request Email Form at https://domains.markmonitor.com/whois/google.com',
-            dnssec: 'unsigned',
-        });
-        this.addDomain('test.local', {
-            registrar: 'Mock Registrar',
-            registrarUrl: 'http://localhost',
-            createdDate: '2020-01-01T00:00:00Z',
-            updatedDate: '2024-01-01T00:00:00Z',
-            expiryDate: '2030-01-01T00:00:00Z',
-            status: ['ok'],
-            nameservers: ['ns1.test.local', 'ns2.test.local'],
-            registrantName: 'Test User',
-            registrantOrg: 'Test Organization',
-            registrantEmail: 'admin@test.local',
-        });
-    }
-    async start() {
-        if (this.started) {
-            throw new Error('Server already started');
-        }
-        return new Promise((resolve, reject) => {
-            this.server = net.createServer((socket) => {
-                this.handleConnection(socket);
-            });
-            this.server.on('error', (err) => {
-                this.emit('error', err);
-                if (!this.started) {
-                    reject(err);
-                }
-            });
-            this.server.listen(this.options.port, this.options.host, () => {
-                this.started = true;
-                this.emit('start');
-                resolve();
-            });
-        });
-    }
-    async stop() {
-        if (!this.started || !this.server)
-            return;
-        return new Promise((resolve) => {
-            this.server.close(() => {
-                this.server = null;
-                this.started = false;
-                this.emit('stop');
-                resolve();
-            });
-        });
-    }
-    reset() {
-        this.stats = {
-            queriesReceived: 0,
-            responseSent: 0,
-            queryLog: [],
-        };
-        this.clearDomains();
-        this.emit('reset');
-    }
-    handleConnection(socket) {
-        let data = '';
-        socket.on('data', (chunk) => {
-            data += chunk.toString();
-            if (data.includes('\n') || data.includes('\r')) {
-                this.handleQuery(data.trim(), socket);
-            }
-        });
-        socket.on('error', (err) => {
-            this.emit('error', err);
-        });
-    }
-    async handleQuery(query, socket) {
-        this.stats.queriesReceived++;
-        this.stats.queryLog.push({ query, timestamp: Date.now() });
-        this.emit('query', query);
-        if (this.options.delay > 0) {
-            await new Promise((resolve) => setTimeout(resolve, this.options.delay));
-        }
-        const response = this.buildResponse(query);
-        socket.write(response, () => {
-            this.stats.responseSent++;
-            this.emit('response', query);
-            socket.end();
-        });
-    }
-    buildResponse(query) {
-        const domain = query.toLowerCase().trim();
-        const data = this.domains.get(domain);
-        if (!data) {
-            return this.buildNotFoundResponse(domain);
-        }
-        return this.buildDomainResponse(domain, data);
-    }
-    buildNotFoundResponse(domain) {
-        return `
-% WHOIS Mock Server
-
-No match for domain "${domain}".
-
->>> Last update of WHOIS database: ${new Date().toISOString()} <<<
-
-NOTICE: This is a mock WHOIS server for testing purposes.
-`.trim() + '\n';
-    }
-    buildDomainResponse(domain, data) {
-        const lines = [
-            '% WHOIS Mock Server',
-            '',
-            `Domain Name: ${domain.toUpperCase()}`,
-        ];
-        if (data.registrar) {
-            lines.push(`Registrar: ${data.registrar}`);
-        }
-        if (data.registrarUrl) {
-            lines.push(`Registrar URL: ${data.registrarUrl}`);
-        }
-        if (data.createdDate) {
-            lines.push(`Creation Date: ${data.createdDate}`);
-        }
-        if (data.updatedDate) {
-            lines.push(`Updated Date: ${data.updatedDate}`);
-        }
-        if (data.expiryDate) {
-            lines.push(`Registry Expiry Date: ${data.expiryDate}`);
-        }
-        if (data.status && data.status.length > 0) {
-            for (const status of data.status) {
-                lines.push(`Domain Status: ${status}`);
-            }
-        }
-        if (data.nameservers && data.nameservers.length > 0) {
-            for (const ns of data.nameservers) {
-                lines.push(`Name Server: ${ns}`);
-            }
-        }
-        if (data.registrantName) {
-            lines.push(`Registrant Name: ${data.registrantName}`);
-        }
-        if (data.registrantOrg) {
-            lines.push(`Registrant Organization: ${data.registrantOrg}`);
-        }
-        if (data.registrantEmail) {
-            lines.push(`Registrant Email: ${data.registrantEmail}`);
-        }
-        if (data.adminEmail) {
-            lines.push(`Admin Email: ${data.adminEmail}`);
-        }
-        if (data.techEmail) {
-            lines.push(`Tech Email: ${data.techEmail}`);
-        }
-        if (data.dnssec) {
-            lines.push(`DNSSEC: ${data.dnssec}`);
-        }
-        lines.push('');
-        lines.push(`>>> Last update of WHOIS database: ${new Date().toISOString()} <<<`);
-        lines.push('');
-        lines.push('NOTICE: This is a mock WHOIS server for testing purposes.');
-        return lines.join('\n') + '\n';
-    }
-    static async create(options = {}) {
-        const server = new MockWhoisServer(options);
-        await server.start();
-        return server;
-    }
-}

package/dist/testing/proxy-certs.d.ts

@@ -1,19 +0,0 @@
-export interface CertificateInfo {
-    key: string;
-    cert: string;
-    ca?: string;
-}
-export interface CertificateOptions {
-    caCert?: string;
-    caKey?: string;
-    validityDays?: number;
-}
-export declare function generateCA(): {
-    key: string;
-    cert: string;
-};
-export declare function generateCertificate(host: string, options?: CertificateOptions): Promise<CertificateInfo>;
-export declare function getDefaultCA(): {
-    key: string;
-    cert: string;
-};

package/dist/testing/proxy-certs.js

@@ -1,208 +0,0 @@
-import { generateKeyPairSync, createSign, randomBytes } from 'node:crypto';
-let defaultCA = null;
-export function generateCA() {
-    const { publicKey, privateKey } = generateKeyPairSync('rsa', {
-        modulusLength: 2048,
-    });
-    const privateKeyPem = privateKey.export({ type: 'pkcs8', format: 'pem' });
-    const publicKeyPem = publicKey.export({ type: 'spki', format: 'pem' });
-    const cert = createSelfSignedCert({
-        commonName: 'Recker Proxy CA',
-        isCA: true,
-        privateKey: privateKeyPem,
-        publicKey: publicKeyPem,
-        validityDays: 3650,
-    });
-    return {
-        key: privateKeyPem,
-        cert,
-    };
-}
-export async function generateCertificate(host, options = {}) {
-    let caKey = options.caKey;
-    let caCert = options.caCert;
-    if (!caKey || !caCert) {
-        if (!defaultCA) {
-            defaultCA = generateCA();
-        }
-        caKey = defaultCA.key;
-        caCert = defaultCA.cert;
-    }
-    const { publicKey, privateKey } = generateKeyPairSync('rsa', {
-        modulusLength: 2048,
-    });
-    const privateKeyPem = privateKey.export({ type: 'pkcs8', format: 'pem' });
-    const publicKeyPem = publicKey.export({ type: 'spki', format: 'pem' });
-    const cert = createSignedCert({
-        commonName: host,
-        sans: [host],
-        privateKey: privateKeyPem,
-        publicKey: publicKeyPem,
-        caKey,
-        caCert,
-        validityDays: options.validityDays ?? 365,
-    });
-    return {
-        key: privateKeyPem,
-        cert,
-        ca: caCert,
-    };
-}
-function createSelfSignedCert(options) {
-    const now = new Date();
-    const notBefore = formatDate(now);
-    const notAfter = formatDate(new Date(now.getTime() + options.validityDays * 24 * 60 * 60 * 1000));
-    const serialNumber = randomBytes(8).toString('hex').toUpperCase();
-    const tbsCertificate = buildTBSCertificate({
-        serialNumber,
-        issuer: { CN: options.commonName },
-        subject: { CN: options.commonName },
-        notBefore,
-        notAfter,
-        publicKey: options.publicKey,
-        isCA: options.isCA,
-        sans: [],
-    });
-    const signature = signData(tbsCertificate, options.privateKey);
-    return buildCertificate(tbsCertificate, signature);
-}
-function createSignedCert(options) {
-    const now = new Date();
-    const notBefore = formatDate(now);
-    const notAfter = formatDate(new Date(now.getTime() + options.validityDays * 24 * 60 * 60 * 1000));
-    const serialNumber = randomBytes(8).toString('hex').toUpperCase();
-    const issuerCN = extractCN(options.caCert);
-    const tbsCertificate = buildTBSCertificate({
-        serialNumber,
-        issuer: { CN: issuerCN },
-        subject: { CN: options.commonName },
-        notBefore,
-        notAfter,
-        publicKey: options.publicKey,
-        isCA: false,
-        sans: options.sans,
-    });
-    const signature = signData(tbsCertificate, options.caKey);
-    return buildCertificate(tbsCertificate, signature);
-}
-function buildTBSCertificate(options) {
-    const parts = [];
-    parts.push(wrapTag(0xa0, wrapTag(0x02, Buffer.from([0x02]))));
-    const serialBytes = Buffer.from(options.serialNumber, 'hex');
-    parts.push(wrapTag(0x02, serialBytes));
-    parts.push(buildAlgorithmIdentifier());
-    parts.push(buildName(options.issuer.CN));
-    parts.push(buildValidity(options.notBefore, options.notAfter));
-    parts.push(buildName(options.subject.CN));
-    parts.push(extractPublicKeyInfo(options.publicKey));
-    const extensions = [];
-    if (options.isCA) {
-        extensions.push(buildBasicConstraintsCA());
-    }
-    if (options.sans.length > 0) {
-        extensions.push(buildSANExtension(options.sans));
-    }
-    if (extensions.length > 0) {
-        const extsSeq = wrapTag(0x30, Buffer.concat(extensions));
-        parts.push(wrapTag(0xa3, extsSeq));
-    }
-    return wrapTag(0x30, Buffer.concat(parts));
-}
-function buildCertificate(tbsCertificate, signature) {
-    const parts = [];
-    parts.push(tbsCertificate);
-    parts.push(buildAlgorithmIdentifier());
-    const sigBitString = Buffer.concat([Buffer.from([0x00]), signature]);
-    parts.push(wrapTag(0x03, sigBitString));
-    const certDer = wrapTag(0x30, Buffer.concat(parts));
-    const certBase64 = certDer.toString('base64');
-    const lines = ['-----BEGIN CERTIFICATE-----'];
-    for (let i = 0; i < certBase64.length; i += 64) {
-        lines.push(certBase64.slice(i, i + 64));
-    }
-    lines.push('-----END CERTIFICATE-----');
-    return lines.join('\n');
-}
-function buildAlgorithmIdentifier() {
-    const oid = Buffer.from([
-        0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
-    ]);
-    const nullParam = Buffer.from([0x05, 0x00]);
-    return wrapTag(0x30, Buffer.concat([oid, nullParam]));
-}
-function buildName(cn) {
-    const cnOid = Buffer.from([0x06, 0x03, 0x55, 0x04, 0x03]);
-    const cnValue = wrapTag(0x0c, Buffer.from(cn, 'utf8'));
-    const atv = wrapTag(0x30, Buffer.concat([cnOid, cnValue]));
-    const rdn = wrapTag(0x31, atv);
-    return wrapTag(0x30, rdn);
-}
-function buildValidity(notBefore, notAfter) {
-    const notBeforeUtc = wrapTag(0x17, Buffer.from(notBefore, 'ascii'));
-    const notAfterUtc = wrapTag(0x17, Buffer.from(notAfter, 'ascii'));
-    return wrapTag(0x30, Buffer.concat([notBeforeUtc, notAfterUtc]));
-}
-function buildBasicConstraintsCA() {
-    const oid = Buffer.from([0x06, 0x03, 0x55, 0x1d, 0x13]);
-    const critical = Buffer.from([0x01, 0x01, 0xff]);
-    const caTrue = wrapTag(0x01, Buffer.from([0xff]));
-    const bcValue = wrapTag(0x30, caTrue);
-    const bcOctet = wrapTag(0x04, bcValue);
-    return wrapTag(0x30, Buffer.concat([oid, critical, bcOctet]));
-}
-function buildSANExtension(sans) {
-    const oid = Buffer.from([0x06, 0x03, 0x55, 0x1d, 0x11]);
-    const names = sans.map((name) => {
-        return wrapTag(0x82, Buffer.from(name, 'ascii'));
-    });
-    const sanSeq = wrapTag(0x30, Buffer.concat(names));
-    const sanOctet = wrapTag(0x04, sanSeq);
-    return wrapTag(0x30, Buffer.concat([oid, sanOctet]));
-}
-function extractPublicKeyInfo(publicKeyPem) {
-    const base64 = publicKeyPem
-        .replace(/-----BEGIN PUBLIC KEY-----/, '')
-        .replace(/-----END PUBLIC KEY-----/, '')
-        .replace(/\s/g, '');
-    return Buffer.from(base64, 'base64');
-}
-function extractCN(certPem) {
-    const match = certPem.match(/CN=([^,\/\n]+)/i);
-    return match ? match[1] : 'Unknown';
-}
-function signData(data, privateKeyPem) {
-    const sign = createSign('SHA256');
-    sign.update(data);
-    return sign.sign(privateKeyPem);
-}
-function wrapTag(tag, content) {
-    const length = encodeLength(content.length);
-    return Buffer.concat([Buffer.from([tag]), length, content]);
-}
-function encodeLength(len) {
-    if (len < 128) {
-        return Buffer.from([len]);
-    }
-    const bytes = [];
-    let temp = len;
-    while (temp > 0) {
-        bytes.unshift(temp & 0xff);
-        temp >>= 8;
-    }
-    return Buffer.from([0x80 | bytes.length, ...bytes]);
-}
-function formatDate(date) {
-    const y = date.getUTCFullYear().toString().slice(-2);
-    const m = (date.getUTCMonth() + 1).toString().padStart(2, '0');
-    const d = date.getUTCDate().toString().padStart(2, '0');
-    const h = date.getUTCHours().toString().padStart(2, '0');
-    const min = date.getUTCMinutes().toString().padStart(2, '0');
-    const s = date.getUTCSeconds().toString().padStart(2, '0');
-    return `${y}${m}${d}${h}${min}${s}Z`;
-}
-export function getDefaultCA() {
-    if (!defaultCA) {
-        defaultCA = generateCA();
-    }
-    return defaultCA;
-}