@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.
404 lines • 37 kB
JavaScript
import * as plugins from './plugins.js';
import { RustDnsBridge } from './classes.rustdnsbridge.js';
export class DnsServer extends plugins.events.EventEmitter {
constructor(options) {
super();
this.options = options;
this.handlers = [];
// Track initialization state
this.bridgeSpawned = false;
// Legacy server references (kept for backward-compatible test access)
this.httpsServer = null;
this.udpServer = null;
this.tcpServer = null;
this.bridge = new RustDnsBridge();
// Wire up the dnsQuery event to run TypeScript handlers
this.bridge.on('dnsQuery', async (event) => {
try {
const startTime = Date.now();
const answers = this.resolveQuery(event);
const responseTimeMs = Date.now() - startTime;
this.emit('query', {
questions: event.questions,
answered: answers.answered,
responseTimeMs,
timestamp: startTime,
});
await this.bridge.sendQueryResult(event.correlationId, answers.answers, answers.answered);
}
catch (err) {
console.error('Error handling DNS query:', err);
try {
await this.bridge.sendQueryResult(event.correlationId, [], false);
}
catch (sendErr) {
console.error('Error sending empty query result:', sendErr);
}
}
});
}
/**
* Register a DNS handler for a domain pattern and record types.
*/
registerHandler(domainPattern, recordTypes, handler) {
this.handlers.push({ domainPattern, recordTypes, handler });
}
/**
* Unregister a specific handler.
*/
unregisterHandler(domainPattern, recordTypes) {
const initialLength = this.handlers.length;
const normalizedDomainPattern = domainPattern.toLowerCase();
const normalizedRecordTypes = recordTypes.map(type => type.toUpperCase());
this.handlers = this.handlers.filter(handler => !(handler.domainPattern.toLowerCase() === normalizedDomainPattern &&
normalizedRecordTypes.every(type => handler.recordTypes.map(recordType => recordType.toUpperCase()).includes(type))));
return this.handlers.length < initialLength;
}
/**
* Start the DNS server.
*/
async start() {
// Validate interface addresses if provided
const udpInterface = this.options.udpBindInterface || '0.0.0.0';
const tcpInterface = this.options.tcpBindInterface || udpInterface;
const httpsInterface = this.options.httpsBindInterface || '0.0.0.0';
const tcpPort = this.options.tcpPort || this.options.udpPort;
if (this.options.udpBindInterface && !this.isValidIpAddress(this.options.udpBindInterface)) {
throw new Error(`Invalid UDP bind interface: ${this.options.udpBindInterface}`);
}
if (this.options.tcpBindInterface && !this.isValidIpAddress(this.options.tcpBindInterface)) {
throw new Error(`Invalid TCP bind interface: ${this.options.tcpBindInterface}`);
}
if (this.options.httpsBindInterface && !this.isValidIpAddress(this.options.httpsBindInterface)) {
throw new Error(`Invalid HTTPS bind interface: ${this.options.httpsBindInterface}`);
}
// Spawn the Rust binary
if (!this.bridgeSpawned) {
const spawned = await this.bridge.spawn();
if (!spawned) {
throw new Error('Failed to spawn rustdns binary');
}
this.bridgeSpawned = true;
}
// Build config for Rust
const config = {
udpPort: this.options.udpPort,
tcpPort,
httpsPort: this.options.httpsPort,
udpBindInterface: udpInterface,
tcpBindInterface: tcpInterface,
httpsBindInterface: httpsInterface,
httpsKey: this.options.httpsKey || '',
httpsCert: this.options.httpsCert || '',
dnssecZone: this.options.dnssecZone,
dnssecAlgorithm: 'ECDSA',
primaryNameserver: this.options.primaryNameserver || `ns1.${this.options.dnssecZone}`,
enableLocalhostHandling: this.options.enableLocalhostHandling !== false,
manualUdpMode: this.options.manualUdpMode || false,
manualTcpMode: this.options.manualTcpMode || false,
manualHttpsMode: this.options.manualHttpsMode || false,
};
try {
await this.bridge.startServer(config);
}
catch (error) {
this.bridge.kill();
this.bridgeSpawned = false;
throw error;
}
// Set legacy markers for backward-compatible test checks
this.httpsServer = { _rustBridgeManaged: true };
this.udpServer = { _rustBridgeManaged: true };
this.tcpServer = { _rustBridgeManaged: true };
const udpManual = this.options.manualUdpMode || false;
const tcpManual = this.options.manualTcpMode || false;
const httpsManual = this.options.manualHttpsMode || false;
if (udpManual && tcpManual && httpsManual) {
console.log('DNS server started in full manual mode - ready to accept connections');
}
else if (udpManual || tcpManual || httpsManual) {
const activeTransports = [];
const manualTransports = [];
udpManual ? manualTransports.push('UDP') : activeTransports.push(`UDP ${udpInterface}:${this.options.udpPort}`);
tcpManual ? manualTransports.push('TCP') : activeTransports.push(`TCP ${tcpInterface}:${tcpPort}`);
httpsManual ? manualTransports.push('HTTPS') : activeTransports.push(`HTTPS ${httpsInterface}:${this.options.httpsPort}`);
console.log(`DNS server started (${activeTransports.join(', ')}${manualTransports.length ? `; manual: ${manualTransports.join(', ')}` : ''})`);
}
else {
console.log(`DNS server started (UDP: ${udpInterface}:${this.options.udpPort}, TCP: ${tcpInterface}:${tcpPort}, HTTPS: ${httpsInterface}:${this.options.httpsPort})`);
}
}
/**
* Stop the DNS server.
*/
async stop() {
if (this.bridgeSpawned) {
try {
await this.bridge.stopServer();
}
catch (err) {
// Ignore errors during stop (process may have already exited)
}
this.bridge.kill();
this.bridgeSpawned = false;
}
this.httpsServer = null;
this.udpServer = null;
this.tcpServer = null;
}
/**
* Initialize servers (no-op with Rust bridge, kept for API compatibility).
*/
initializeServers() {
// No-op — Rust bridge handles server initialization via start()
}
/**
* Initialize UDP server (no-op with Rust bridge).
*/
initializeUdpServer() {
// No-op
}
/**
* Initialize HTTPS server (no-op with Rust bridge).
*/
initializeHttpsServer() {
// No-op
}
/**
* Handle a raw TCP socket for HTTPS/DoH.
* In Rust mode, this is not directly supported — use processRawDnsPacket instead.
*/
handleHttpsSocket(socket) {
console.warn('handleHttpsSocket: direct socket handling not available with Rust bridge. Use processRawDnsPacket instead.');
socket.end();
}
/**
* Handle a UDP message manually.
*/
handleUdpMessage(msg, rinfo, responseCallback) {
// Async processing via Rust bridge
this.processRawDnsPacketAsync(msg)
.then((responseData) => {
if (responseCallback) {
responseCallback(responseData, rinfo);
}
})
.catch((err) => {
console.error('Error processing UDP DNS request:', err);
});
}
/**
* Process a raw DNS packet asynchronously via Rust bridge.
*/
async processRawDnsPacketAsync(packet) {
if (!this.bridgeSpawned) {
throw new Error('DNS server not started — call start() first');
}
return this.bridge.processPacket(packet);
}
/**
* Retrieve SSL certificate for specified domains using Let's Encrypt
*/
async retrieveSslCertificate(domainNames, options = {}) {
const opts = {
email: options.email || 'admin@example.com',
staging: options.staging !== undefined ? options.staging : false,
certDir: options.certDir || './certs'
};
if (!plugins.fs.existsSync(opts.certDir)) {
plugins.fs.mkdirSync(opts.certDir, { recursive: true });
}
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 {
// @ts-ignore - acmeClientOverride is added for testing purposes
const acmeClient = this.acmeClientOverride || await import('acme-client');
const accountKeyPath = plugins.path.join(opts.certDir, 'account.key');
let accountKey;
if (plugins.fs.existsSync(accountKeyPath)) {
accountKey = plugins.fs.readFileSync(accountKeyPath);
}
else {
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);
}
const client = new acmeClient.Client({
directoryUrl: opts.staging
? acmeClient.directory.letsencrypt.staging
: acmeClient.directory.letsencrypt.production,
accountKey: accountKey
});
await client.createAccount({
termsOfServiceAgreed: true,
contact: [`mailto:${opts.email}`]
});
const order = await client.createOrder({
identifiers: authorizedDomains.map(domain => ({
type: 'dns',
value: domain
}))
});
const authorizations = await client.getAuthorizations(order);
const challengeHandlers = [];
for (const auth of authorizations) {
const domain = auth.identifier.value;
const challenge = auth.challenges.find((c) => c.type === 'dns-01');
if (!challenge) {
throw new Error(`No DNS-01 challenge found for ${domain}`);
}
const keyAuthorization = await client.getChallengeKeyAuthorization(challenge);
const recordValue = this.getDnsRecordValueForChallenge(keyAuthorization);
const challengeDomain = `_acme-challenge.${domain}`;
console.log(`Setting up TXT record for ${challengeDomain}: ${recordValue}`);
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;
});
challengeHandlers.push({ domain, pattern: challengeDomain });
await new Promise(resolve => setTimeout(resolve, 2000));
await client.completeChallenge(challenge);
await client.waitForValidStatus(challenge);
console.log(`Challenge for ${domain} validated successfully!`);
}
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);
const csrResult = await acmeClient.forge.createCsr({
commonName: authorizedDomains[0],
altNames: authorizedDomains
});
await client.finalizeOrder(order, csrResult.csr);
const certificate = await client.getCertificate(order);
const certPath = plugins.path.join(opts.certDir, `${authorizedDomains[0]}.cert`);
plugins.fs.writeFileSync(certPath, certificate);
this.options.httpsCert = certificate;
this.options.httpsKey = privateKey;
// Update certs on Rust bridge if running
if (this.bridgeSpawned) {
try {
await this.bridge.updateCerts(privateKey, certificate);
}
catch (err) {
console.error('Error updating certs on Rust bridge:', err);
}
}
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 };
}
}
/**
* Filter domains to include only those the server is authoritative for.
*/
filterAuthorizedDomains(domainNames) {
const authorizedDomains = [];
for (const domain of domainNames) {
if (domain.startsWith('*.')) {
const baseDomain = domain.substring(2);
if (this.isAuthorizedForDomain(baseDomain)) {
authorizedDomains.push(domain);
}
}
else if (this.isAuthorizedForDomain(domain)) {
authorizedDomains.push(domain);
}
}
return authorizedDomains;
}
// ── Private helpers ───────────────────────────────────────────────
/**
* Resolve a DNS query event from Rust using TypeScript handlers.
*/
resolveQuery(event) {
const answers = [];
let answered = false;
for (const q of event.questions) {
const normalizedQuestionName = q.name.toLowerCase();
const normalizedQuestionType = q.type.toUpperCase();
const question = {
name: normalizedQuestionName,
type: normalizedQuestionType,
class: q.class,
};
for (const handlerEntry of this.handlers) {
const normalizedDomainPattern = handlerEntry.domainPattern.toLowerCase();
const normalizedRecordTypes = handlerEntry.recordTypes.map(recordType => recordType.toUpperCase());
if (plugins.minimatch.minimatch(normalizedQuestionName, normalizedDomainPattern) &&
normalizedRecordTypes.includes(normalizedQuestionType)) {
const answer = handlerEntry.handler(question);
if (answer) {
answers.push({
name: answer.name,
type: answer.type,
class: typeof answer.class === 'number' ? 'IN' : (answer.class || 'IN'),
ttl: answer.ttl || 300,
data: answer.data,
});
answered = true;
}
}
}
}
return { answers, answered };
}
getDnsRecordValueForChallenge(keyAuthorization) {
const digest = plugins.crypto
.createHash('sha256')
.update(keyAuthorization)
.digest('base64')
.replace(/\+/g, '-')
.replace(/\//g, '_')
.replace(/=/g, '');
return digest;
}
isValidIpAddress(ip) {
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]?)$/;
const ipv6Pattern = /^(::1|::)$|^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
return ipv4Pattern.test(ip) || ipv6Pattern.test(ip);
}
isAuthorizedForDomain(domain) {
const normalizedDomain = domain.toLowerCase();
for (const handler of this.handlers) {
if (plugins.minimatch.minimatch(normalizedDomain, handler.domainPattern.toLowerCase())) {
return true;
}
}
const normalizedZone = this.options.dnssecZone.toLowerCase();
if (normalizedDomain === normalizedZone || normalizedDomain.endsWith(`.${normalizedZone}`)) {
return true;
}
return false;
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dnsserver.js","sourceRoot":"","sources":["../ts_server/classes.dnsserver.ts"],"names":[],"mappings":"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"}