@push.rocks/smartdns
Version:
A robust TypeScript library providing advanced DNS management and resolution capabilities including support for DNSSEC, custom DNS servers, and integration with various DNS providers.
834 lines • 72.9 kB
JavaScript
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 = [];
// Track if servers are initialized
this.udpServerInitialized = false;
this.httpsServerInitialized = false;
// 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 { dnskeyRecord } = this.dnsSec.getDsAndKeyPair();
// Parse DNSKEY record into dns-packet format
this.dnskeyRecord = this.parseDNSKEYRecord(dnskeyRecord);
this.keyTag = this.computeKeyTag(this.dnskeyRecord);
}
/**
* Initialize servers without binding to ports
* This is called automatically by start() or can be called manually
*/
initializeServers() {
this.initializeUdpServer();
this.initializeHttpsServer();
}
/**
* Initialize UDP server without binding
*/
initializeUdpServer() {
if (this.udpServerInitialized) {
return;
}
// Create UDP socket without binding
const udpInterface = this.options.udpBindInterface || '0.0.0.0';
const socketType = this.isIPv6(udpInterface) ? 'udp6' : 'udp4';
this.udpServer = plugins.dgram.createSocket(socketType);
// Set up UDP message handler
this.udpServer.on('message', (msg, rinfo) => {
this.handleUdpMessage(msg, rinfo);
});
this.udpServer.on('error', (err) => {
console.error(`UDP Server error:\n${err.stack}`);
this.udpServer.close();
});
this.udpServerInitialized = true;
}
/**
* Initialize HTTPS server without binding
*/
initializeHttpsServer() {
if (this.httpsServerInitialized) {
return;
}
// Create HTTPS server without listening
this.httpsServer = plugins.https.createServer({
key: this.options.httpsKey,
cert: this.options.httpsCert,
}, this.handleHttpsRequest.bind(this));
this.httpsServerInitialized = true;
}
/**
* Handle a raw TCP socket for HTTPS/DoH
* @param socket The TCP socket to handle
*/
handleHttpsSocket(socket) {
if (!this.httpsServer) {
this.initializeHttpsServer();
}
// Emit connection event on the HTTPS server
this.httpsServer.emit('connection', socket);
}
/**
* Handle a UDP message manually
* @param msg The DNS message buffer
* @param rinfo Remote address information
* @param responseCallback Optional callback to handle the response
*/
handleUdpMessage(msg, rinfo, responseCallback) {
try {
const request = dnsPacket.decode(msg);
const response = this.processDnsRequest(request);
const responseData = dnsPacket.encode(response);
if (responseCallback) {
// Use custom callback if provided
responseCallback(responseData, rinfo);
}
else if (this.udpServer && !this.options.manualUdpMode) {
// Use the internal UDP server to send response
this.udpServer.send(responseData, rinfo.port, rinfo.address);
}
// In manual mode without callback, caller is responsible for sending response
}
catch (err) {
console.error('Error processing UDP DNS request:', err);
}
}
/**
* Process a raw DNS packet and return the response
* This is useful for custom transport implementations
*/
processRawDnsPacket(packet) {
try {
const request = dnsPacket.decode(packet);
const response = this.processDnsRequest(request);
return dnsPacket.encode(response);
}
catch (err) {
console.error('Error processing raw DNS packet:', err);
throw err;
}
}
registerHandler(domainPattern, recordTypes, handler) {
this.handlers.push({ domainPattern, recordTypes, handler });
}
// Unregister a specific handler
unregisterHandler(domainPattern, recordTypes) {
const initialLength = this.handlers.length;
this.handlers = this.handlers.filter(handler => !(handler.domainPattern === domainPattern &&
recordTypes.every(type => handler.recordTypes.includes(type))));
return this.handlers.length < initialLength;
}
/**
* Retrieve SSL certificate for specified domains using Let's Encrypt
* @param domainNames Array of domain names to include in the certificate
* @param options Configuration options for Let's Encrypt
* @returns Object containing certificate, private key, and success status
*/
async retrieveSslCertificate(domainNames, options = {}) {
// Default options
const opts = {
email: options.email || 'admin@example.com',
staging: options.staging !== undefined ? options.staging : false,
certDir: options.certDir || './certs'
};
// Create certificate directory if it doesn't exist
if (!plugins.fs.existsSync(opts.certDir)) {
plugins.fs.mkdirSync(opts.certDir, { recursive: true });
}
// Filter domains this server is authoritative for
const authorizedDomains = this.filterAuthorizedDomains(domainNames);
if (authorizedDomains.length === 0) {
console.error('None of the provided domains are authorized for this DNS server');
return { cert: '', key: '', success: false };
}
console.log(`Retrieving SSL certificate for domains: ${authorizedDomains.join(', ')}`);
try {
// Allow for override in tests
// @ts-ignore - acmeClientOverride is added for testing purposes
const acmeClient = this.acmeClientOverride || await import('acme-client');
// Generate or load account key
const accountKeyPath = plugins.path.join(opts.certDir, 'account.key');
let accountKey;
if (plugins.fs.existsSync(accountKeyPath)) {
accountKey = plugins.fs.readFileSync(accountKeyPath);
}
else {
// Generate new account key
const { privateKey } = plugins.crypto.generateKeyPairSync('rsa', {
modulusLength: 2048,
publicKeyEncoding: { type: 'spki', format: 'pem' },
privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
});
accountKey = Buffer.from(privateKey);
plugins.fs.writeFileSync(accountKeyPath, accountKey);
}
// Initialize ACME client
const client = new acmeClient.Client({
directoryUrl: opts.staging
? acmeClient.directory.letsencrypt.staging
: acmeClient.directory.letsencrypt.production,
accountKey: accountKey
});
// Create or update account
await client.createAccount({
termsOfServiceAgreed: true,
contact: [`mailto:${opts.email}`]
});
// Create order for certificate
const order = await client.createOrder({
identifiers: authorizedDomains.map(domain => ({
type: 'dns',
value: domain
}))
});
// Get authorizations
const authorizations = await client.getAuthorizations(order);
// Track handlers to clean up later
const challengeHandlers = [];
// Process each authorization
for (const auth of authorizations) {
const domain = auth.identifier.value;
// Get DNS challenge
const challenge = auth.challenges.find((c) => c.type === 'dns-01');
if (!challenge) {
throw new Error(`No DNS-01 challenge found for ${domain}`);
}
// Get key authorization and DNS record value
const keyAuthorization = await client.getChallengeKeyAuthorization(challenge);
const recordValue = this.getDnsRecordValueForChallenge(keyAuthorization);
// Create challenge domain (where TXT record should be placed)
const challengeDomain = `_acme-challenge.${domain}`;
console.log(`Setting up TXT record for ${challengeDomain}: ${recordValue}`);
// Register handler for the TXT record
this.registerHandler(challengeDomain, ['TXT'], (question) => {
if (question.name === challengeDomain && question.type === 'TXT') {
return {
name: question.name,
type: 'TXT',
class: 'IN',
ttl: 300,
data: [recordValue]
};
}
return null;
});
// Track the handler for cleanup
challengeHandlers.push({ domain, pattern: challengeDomain });
// Wait briefly for DNS propagation
await new Promise(resolve => setTimeout(resolve, 2000));
// Complete the challenge
await client.completeChallenge(challenge);
// Wait for verification
await client.waitForValidStatus(challenge);
console.log(`Challenge for ${domain} validated successfully!`);
}
// Generate certificate key
const domainKeyPath = plugins.path.join(opts.certDir, `${authorizedDomains[0]}.key`);
const { privateKey } = plugins.crypto.generateKeyPairSync('rsa', {
modulusLength: 2048,
publicKeyEncoding: { type: 'spki', format: 'pem' },
privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
});
plugins.fs.writeFileSync(domainKeyPath, privateKey);
// Use the forge.createCsr method and handle typing with a more direct approach
const csrResult = await acmeClient.forge.createCsr({
commonName: authorizedDomains[0],
altNames: authorizedDomains
});
// Finalize the order with the CSR
await client.finalizeOrder(order, csrResult.csr);
// Get certificate
const certificate = await client.getCertificate(order);
// Save certificate
const certPath = plugins.path.join(opts.certDir, `${authorizedDomains[0]}.cert`);
plugins.fs.writeFileSync(certPath, certificate);
// Update HTTPS server with new certificate
this.options.httpsCert = certificate;
this.options.httpsKey = privateKey;
// Restart HTTPS server with new certificate (only if not in manual HTTPS mode)
if (!this.options.manualHttpsMode) {
await this.restartHttpsServer();
}
// Clean up challenge handlers
for (const handler of challengeHandlers) {
this.unregisterHandler(handler.pattern, ['TXT']);
console.log(`Cleaned up challenge handler for ${handler.domain}`);
}
return {
cert: certificate,
key: privateKey,
success: true
};
}
catch (error) {
console.error('Error retrieving SSL certificate:', error);
return { cert: '', key: '', success: false };
}
}
/**
* Create DNS record value for the ACME challenge
*/
getDnsRecordValueForChallenge(keyAuthorization) {
// Create SHA-256 digest of the key authorization
const digest = plugins.crypto
.createHash('sha256')
.update(keyAuthorization)
.digest('base64')
.replace(/\+/g, '-')
.replace(/\//g, '_')
.replace(/=/g, '');
return digest;
}
/**
* Restart the HTTPS server with the new certificate
*/
async restartHttpsServer() {
return new Promise((resolve, reject) => {
// First check if the server exists
if (!this.httpsServer) {
console.log('No HTTPS server to restart');
resolve();
return;
}
this.httpsServer.close(() => {
try {
// Validate certificate and key before trying to create the server
if (!this.options.httpsCert || !this.options.httpsKey) {
throw new Error('Missing certificate or key for HTTPS server');
}
// For testing, check if we have a mock certificate
if (this.options.httpsCert.includes('MOCK_CERTIFICATE')) {
console.log('Using mock certificate in test mode');
// In test mode with mock cert, we can use the original cert
// @ts-ignore - accessing acmeClientOverride for testing
if (this.acmeClientOverride) {
this.httpsServer = plugins.https.createServer({
key: this.options.httpsKey,
cert: this.options.httpsCert,
}, this.handleHttpsRequest.bind(this));
if (!this.options.manualHttpsMode) {
const httpsInterface = this.options.httpsBindInterface || '0.0.0.0';
this.httpsServer.listen(this.options.httpsPort, httpsInterface, () => {
console.log(`HTTPS DNS server restarted on ${httpsInterface}:${this.options.httpsPort} with test certificate`);
resolve();
});
}
else {
resolve();
}
return;
}
}
// Create the new server with the updated certificate
this.httpsServer = plugins.https.createServer({
key: this.options.httpsKey,
cert: this.options.httpsCert,
}, this.handleHttpsRequest.bind(this));
if (!this.options.manualHttpsMode) {
const httpsInterface = this.options.httpsBindInterface || '0.0.0.0';
this.httpsServer.listen(this.options.httpsPort, httpsInterface, () => {
console.log(`HTTPS DNS server restarted on ${httpsInterface}:${this.options.httpsPort} with new certificate`);
resolve();
});
}
else {
resolve();
}
}
catch (err) {
console.error('Error creating HTTPS server with new certificate:', err);
reject(err);
}
});
});
}
/**
* Filter domains to include only those the server is authoritative for
*/
filterAuthorizedDomains(domainNames) {
const authorizedDomains = [];
for (const domain of domainNames) {
// Handle wildcards (*.example.com)
if (domain.startsWith('*.')) {
const baseDomain = domain.substring(2);
if (this.isAuthorizedForDomain(baseDomain)) {
authorizedDomains.push(domain);
}
}
// Regular domains
else if (this.isAuthorizedForDomain(domain)) {
authorizedDomains.push(domain);
}
}
return authorizedDomains;
}
/**
* Validate if a string is a valid IP address (IPv4 or IPv6)
*/
isValidIpAddress(ip) {
// IPv4 pattern
const ipv4Pattern = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
// IPv6 pattern (simplified but more comprehensive)
const ipv6Pattern = /^(::1|::)$|^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
return ipv4Pattern.test(ip) || ipv6Pattern.test(ip);
}
/**
* Determine if an IP address is IPv6
*/
isIPv6(ip) {
return ip.includes(':');
}
/**
* Check if the server is authoritative for a domain
*/
isAuthorizedForDomain(domain) {
// Check if any handler matches this domain
for (const handler of this.handlers) {
if (plugins.minimatch.minimatch(domain, handler.domainPattern)) {
return true;
}
}
// Also check if the domain is the DNSSEC zone itself
if (domain === this.options.dnssecZone || domain.endsWith(`.${this.options.dnssecZone}`)) {
return true;
}
return false;
}
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);
// Map to group records by type for proper DNSSEC RRset signing
const rrsetMap = new Map();
for (const question of request.questions) {
console.log(`Query for ${question.name} of type ${question.type}`);
let answered = false;
const recordsForQuestion = [];
// 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,
};
recordsForQuestion.push(dnskeyAnswer);
answered = true;
}
else {
// Collect all matching records from handlers
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',
};
recordsForQuestion.push(dnsAnswer);
answered = true;
// Continue processing other handlers to allow multiple records
}
}
}
}
// Add records to response and group by type for DNSSEC
if (recordsForQuestion.length > 0) {
for (const record of recordsForQuestion) {
response.answers.push(record);
}
// Group records by type for DNSSEC signing
if (dnssecRequested) {
const rrsetKey = `${question.name}:${question.type}`;
rrsetMap.set(rrsetKey, recordsForQuestion);
}
}
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: this.options.primaryNameserver || `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);
// Add SOA record to DNSSEC signing map if DNSSEC is requested
if (dnssecRequested) {
const soaKey = `${question.name}:SOA`;
rrsetMap.set(soaKey, [soaAnswer]);
}
}
}
// Sign RRsets if DNSSEC is requested
if (dnssecRequested) {
for (const [key, rrset] of rrsetMap) {
const [name, type] = key.split(':');
// Sign the entire RRset together
const rrsig = this.generateRRSIG(type, rrset, name);
response.answers.push(rrsig);
}
}
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);
// Ensure all fields are defined
if (!signerName || !signature) {
console.error('RRSIG generation error - missing fields:', {
signerName,
signature: signature ? 'present' : 'missing',
algorithm,
keyTag,
type
});
}
// Construct the RRSIG record
const rrsig = {
name,
type: 'RRSIG',
class: 'IN',
ttl,
data: {
typeCovered: type, // dns-packet expects the string type
algorithm,
labels: name.split('.').filter(l => l.length > 0).length, // Fix label count
originalTTL: ttl,
expiration,
inception,
keyTag,
signersName: signerName || this.options.dnssecZone, // Note: signersName with 's'
signature: signature || Buffer.alloc(0), // Fallback to empty buffer
},
};
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 'TXT':
// Handle TXT records for ACME challenges
if (Array.isArray(data)) {
// Combine all strings and encode as lengths and values
const buffers = data.map(str => {
const strBuf = Buffer.from(str);
const lenBuf = Buffer.alloc(1);
lenBuf.writeUInt8(strBuf.length, 0);
return Buffer.concat([lenBuf, strBuf]);
});
return Buffer.concat(buffers);
}
return Buffer.alloc(0);
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 'NS':
// NS records contain domain names
return this.nameToBuffer(data);
case 'SOA':
// Implement SOA record serialization according to RFC 1035
const mname = this.nameToBuffer(data.mname);
const rname = this.nameToBuffer(data.rname);
const serial = Buffer.alloc(4);
serial.writeUInt32BE(data.serial, 0);
const refresh = Buffer.alloc(4);
refresh.writeUInt32BE(data.refresh, 0);
const retry = Buffer.alloc(4);
retry.writeUInt32BE(data.retry, 0);
const expire = Buffer.alloc(4);
expire.writeUInt32BE(data.expire, 0);
const minimum = Buffer.alloc(4);
minimum.writeUInt32BE(data.minimum, 0);
return Buffer.concat([mname, rname, serial, refresh, retry, expire, minimum]);
case 'MX':
// MX records contain preference (16-bit) and exchange (domain name)
const preference = Buffer.alloc(2);
preference.writeUInt16BE(data.preference, 0);
const exchange = this.nameToBuffer(data.exchange);
return Buffer.concat([preference, exchange]);
// 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() {
// Initialize servers based on what's needed
if (!this.options.manualUdpMode) {
this.initializeUdpServer();
}
if (!this.options.manualHttpsMode) {
this.initializeHttpsServer();
}
// Handle different mode combinations
const udpManual = this.options.manualUdpMode || false;
const httpsManual = this.options.manualHttpsMode || false;
if (udpManual && httpsManual) {
console.log('DNS server started in full manual mode - ready to accept connections');
return;
}
else if (udpManual && !httpsManual) {
console.log('DNS server started with manual UDP mode and automatic HTTPS binding');
}
else if (!udpManual && httpsManual) {
console.log('DNS server started with automatic UDP binding and manual HTTPS mode');
}
// Validate interface addresses if provided
const udpInterface = this.options.udpBindInterface || '0.0.0.0';
const httpsInterface = this.options.httpsBindInterface || '0.0.0.0';
if (this.options.udpBindInterface && !this.isValidIpAddress(this.options.udpBindInterface)) {
throw new Error(`Invalid UDP bind interface: ${this.options.udpBindInterface}`);
}
if (this.options.httpsBindInterface && !this.isValidIpAddress(this.options.httpsBindInterface)) {
throw new Error(`Invalid HTTPS bind interface: ${this.options.httpsBindInterface}`);
}
const promises = [];
// Bind UDP if not in manual UDP mode
if (!udpManual) {
const udpListeningDeferred = plugins.smartpromise.defer();
promises.push(udpListeningDeferred.promise);
try {
this.udpServer.bind(this.options.udpPort, udpInterface, () => {
console.log(`UDP DNS server running on ${udpInterface}:${this.options.udpPort}`);
udpListeningDeferred.resolve();
});
}
catch (err) {
console.error('Error starting UDP DNS server:', err);
udpListeningDeferred.reject(err);
}
}
// Bind HTTPS if not in manual HTTPS mode
if (!httpsManual) {
const httpsListeningDeferred = plugins.smartpromise.defer();
promises.push(httpsListeningDeferred.promise);
try {
this.httpsServer.listen(this.options.httpsPort, httpsInterface, () => {
console.log(`HTTPS DNS server running on ${httpsInterface}:${this.options.httpsPort}`);
httpsListeningDeferred.resolve();
});
}
catch (err) {
console.error('Error starting HTTPS DNS server:', err);
httpsListeningDeferred.reject(err);
}
}
if (promises.length > 0) {
await Promise.all(promises);
}
}
async stop() {
const doneUdp = plugins.smartpromise.defer();
const doneHttps = plugins.smartpromise.defer();
if (this.udpServer) {
this.udpServer.close(() => {
console.log('UDP DNS server stopped');
if (this.udpServer) {
this.udpServer.unref();
this.udpServer = null;
}
doneUdp.resolve();
});
}
else {
doneUdp.resolve();
}
if (this.httpsServer) {
this.httpsServer.close(() => {
console.log('HTTPS DNS server stopped');
if (this.httpsServer) {
this.httpsServer.unref();
this.httpsServer = null;
}
doneHttps.resolve();
});
}
else {
doneHttps.resolve();
}
await Promise.all([doneUdp.promise, doneHttps.promise]);
this.udpServerInitialized = false;
this.httpsServerInitialized = false;
}
// 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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