Compare commits
52 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 46e51cd846 | |||
| dd12641fb0 | |||
| df209ffa71 | |||
| b281fef624 | |||
| 455e9aa6a7 | |||
| 5bc376c8ba | |||
| 34cc8dd073 | |||
| f9aa961e01 | |||
| 1e6d59b5b2 | |||
| 24ed3bd238 | |||
| 34276f71ef | |||
| 7997e9dc94 | |||
| 9bc8278464 | |||
| 58f02cc0c0 | |||
| 566a78cee4 | |||
| 74ac0c1287 | |||
| 5278c2ce78 | |||
| 439d08b023 | |||
| 1536475306 | |||
| 5c06ae1edb | |||
| 2cfecab96f | |||
| 7eb8a46c7c | |||
| c56e732d6d | |||
| aff5f2e7d9 | |||
| 6c38ff36d7 | |||
| b45cda5084 | |||
| dedd3a3f82 | |||
| f2dffb6e88 | |||
| 2a1fbeb183 | |||
| a6a47d2e96 | |||
| 84ad6bbcd6 | |||
| 4102c3a692 | |||
| 6281ab0c80 | |||
| 622c65291e | |||
| dd8c97b99a | |||
| 9c56dc51e3 | |||
| 45cbd3a953 | |||
| d3e2655212 | |||
| e02b2253f5 | |||
| 862577745d | |||
| ca72206ab4 | |||
| 0221c3207e | |||
| f2b8fa57af | |||
| e5b072d99b | |||
| 97c57b2865 | |||
| e04485231d | |||
| 228bc88d60 | |||
| 811041b036 | |||
| a1203366d7 | |||
| 0deb77cda8 | |||
| ed8b7ec65a | |||
| 6cfc12f83f |
125
.gitlab-ci.yml
125
.gitlab-ci.yml
@ -1,125 +0,0 @@
|
||||
# gitzone ci_default
|
||||
image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
|
||||
|
||||
cache:
|
||||
paths:
|
||||
- .npmci_cache/
|
||||
key: '$CI_BUILD_STAGE'
|
||||
|
||||
stages:
|
||||
- security
|
||||
- test
|
||||
- release
|
||||
- metadata
|
||||
|
||||
# ====================
|
||||
# security stage
|
||||
# ====================
|
||||
mirror:
|
||||
stage: security
|
||||
script:
|
||||
- npmci git mirror
|
||||
only:
|
||||
- tags
|
||||
tags:
|
||||
- lossless
|
||||
- docker
|
||||
- notpriv
|
||||
|
||||
audit:
|
||||
image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
|
||||
stage: security
|
||||
script:
|
||||
- npmci npm prepare
|
||||
- npmci command npm install --ignore-scripts
|
||||
- npmci command npm config set registry https://registry.npmjs.org
|
||||
- npmci command npm audit --audit-level=high
|
||||
tags:
|
||||
- docker
|
||||
|
||||
# ====================
|
||||
# test stage
|
||||
# ====================
|
||||
|
||||
testStable:
|
||||
stage: test
|
||||
script:
|
||||
- npmci npm prepare
|
||||
- npmci node install stable
|
||||
- npmci npm install
|
||||
- npmci npm test
|
||||
coverage: /\d+.?\d+?\%\s*coverage/
|
||||
tags:
|
||||
- docker
|
||||
|
||||
testBuild:
|
||||
stage: test
|
||||
script:
|
||||
- npmci npm prepare
|
||||
- npmci node install stable
|
||||
- npmci npm install
|
||||
- npmci command npm run build
|
||||
coverage: /\d+.?\d+?\%\s*coverage/
|
||||
tags:
|
||||
- docker
|
||||
|
||||
release:
|
||||
stage: release
|
||||
script:
|
||||
- npmci node install stable
|
||||
- npmci npm publish
|
||||
only:
|
||||
- tags
|
||||
tags:
|
||||
- lossless
|
||||
- docker
|
||||
- notpriv
|
||||
|
||||
# ====================
|
||||
# metadata stage
|
||||
# ====================
|
||||
codequality:
|
||||
stage: metadata
|
||||
allow_failure: true
|
||||
only:
|
||||
- tags
|
||||
script:
|
||||
- npmci command npm install -g tslint typescript
|
||||
- npmci npm prepare
|
||||
- npmci npm install
|
||||
- npmci command "tslint -c tslint.json ./ts/**/*.ts"
|
||||
tags:
|
||||
- lossless
|
||||
- docker
|
||||
- priv
|
||||
|
||||
trigger:
|
||||
stage: metadata
|
||||
script:
|
||||
- npmci trigger
|
||||
only:
|
||||
- tags
|
||||
tags:
|
||||
- lossless
|
||||
- docker
|
||||
- notpriv
|
||||
|
||||
pages:
|
||||
stage: metadata
|
||||
script:
|
||||
- npmci node install lts
|
||||
- npmci command npm install -g @gitzone/tsdoc
|
||||
- npmci npm prepare
|
||||
- npmci npm install
|
||||
- npmci command tsdoc
|
||||
tags:
|
||||
- lossless
|
||||
- docker
|
||||
- notpriv
|
||||
only:
|
||||
- tags
|
||||
artifacts:
|
||||
expire_in: 1 week
|
||||
paths:
|
||||
- public
|
||||
allow_failure: true
|
||||
24
.vscode/launch.json
vendored
24
.vscode/launch.json
vendored
@ -2,28 +2,10 @@
|
||||
"version": "0.2.0",
|
||||
"configurations": [
|
||||
{
|
||||
"name": "current file",
|
||||
"type": "node",
|
||||
"command": "npm test",
|
||||
"name": "Run npm test",
|
||||
"request": "launch",
|
||||
"args": [
|
||||
"${relativeFile}"
|
||||
],
|
||||
"runtimeArgs": ["-r", "@gitzone/tsrun"],
|
||||
"cwd": "${workspaceRoot}",
|
||||
"protocol": "inspector",
|
||||
"internalConsoleOptions": "openOnSessionStart"
|
||||
},
|
||||
{
|
||||
"name": "test.ts",
|
||||
"type": "node",
|
||||
"request": "launch",
|
||||
"args": [
|
||||
"test/test.ts"
|
||||
],
|
||||
"runtimeArgs": ["-r", "@gitzone/tsrun"],
|
||||
"cwd": "${workspaceRoot}",
|
||||
"protocol": "inspector",
|
||||
"internalConsoleOptions": "openOnSessionStart"
|
||||
"type": "node-terminal"
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
181
changelog.md
Normal file
181
changelog.md
Normal file
@ -0,0 +1,181 @@
|
||||
# Changelog
|
||||
|
||||
## 2025-05-28 - 7.2.0 - feat(dns-server)
|
||||
Improve DNS server interface binding by adding explicit IP validation, configurable UDP/HTTPS binding, and enhanced logging.
|
||||
|
||||
- Added udpBindInterface and httpsBindInterface options to IDnsServerOptions
|
||||
- Implemented IP address validation for both IPv4 and IPv6 in the start() method
|
||||
- Configured UDP and HTTPS servers to bind to specified interfaces with detailed logging
|
||||
- Updated documentation to include interface binding examples (localhost and specific interfaces)
|
||||
- Enhanced tests to cover valid and invalid interface binding scenarios
|
||||
|
||||
## 2025-05-27 - 7.1.0 - feat(docs)
|
||||
Improve documentation for advanced DNS features and update usage examples for both DNS client and server.
|
||||
|
||||
- Revamped readme.hints with expanded architecture overview and detailed explanations of DNSSEC, Let's Encrypt integration, and advanced handler patterns.
|
||||
- Updated readme.md with clearer instructions and code examples for A, AAAA, TXT, MX record queries, DNS propagation checks, and usage of UDP and DNS-over-HTTPS.
|
||||
- Enhanced TAP tests documentation demonstrating both client and server flows.
|
||||
- Bumped version from 7.0.2 to 7.1.0 in preparation for the next release.
|
||||
|
||||
## 2025-05-27 - 7.1.0 - feat(docs)
|
||||
Improve documentation for advanced DNS features by updating usage examples for DNS client and server, and enhancing instructions for DNSSEC and Let's Encrypt integration.
|
||||
|
||||
- Revamped readme.hints with an expanded architecture overview and detailed client/server feature explanations.
|
||||
- Updated readme.md to include clearer instructions and code examples for A, AAAA, TXT, MX record queries and DNS propagation checks.
|
||||
- Enhanced examples for using DNSSEC, including detailed examples for DNSKEY, DS, and RRSIG records.
|
||||
- Added new instructions for setting up DNS-over-HTTPS (DoH), UDP-based resolution, and pattern-based routing for handlers.
|
||||
- Improved testing documentation with updated TAP tests demonstrating both DNS client and server flows.
|
||||
|
||||
## 2025-05-27 - 7.0.2 - fix(dns-client)
|
||||
Improve test assertions for DNS record queries and correct counter increment logic in DNS client
|
||||
|
||||
- Updated test cases in test/test.client.ts to use dynamic assertions with 'google.com' instead of fixed values
|
||||
- Adjusted checkUntilAvailable tests to verify proper behavior when DNS TXT record is missing
|
||||
- Fixed counter increment in ts_client/classes.dnsclient.ts to avoid post-increment issues, ensuring proper retry delays
|
||||
|
||||
## 2025-05-27 - 7.0.1 - fix(test & plugins)
|
||||
Rename test client variable and export smartrequest in client plugins
|
||||
|
||||
- Renamed variable 'testDnsly' to 'testDnsClient' in test/test.client.ts for better clarity.
|
||||
- Added @push.rocks/smartrequest dependency in package.json and updated ts_client/plugins.ts to export it.
|
||||
|
||||
## 2025-05-27 - 7.0.0 - BREAKING CHANGE(core)
|
||||
Refactor module entry point and update plugin imports; remove deprecated dnsly.plugins, update dependency versions, and adjust test imports
|
||||
|
||||
- Changed module export in package.json from './dist_ts_server/index.js' to './dist_ts/index.js'
|
||||
- Updated dependency versions, notably upgrading '@tsclass/tsclass' from 5.0.0 to 9.2.0 and updating tap bundles to '@git.zone/tstest' packages
|
||||
- Removed the redundant ts_client/dnsly.plugins.ts file and replaced its usage with the updated ts_client/plugins.ts
|
||||
- Adjusted test files to use export default tap.start() and updated import paths for tap bundles
|
||||
- Added tspublish.json files in ts, ts_client, and ts_server directories to control publish order
|
||||
|
||||
## 2025-03-21 - 6.3.0 - feat(dns-server)
|
||||
Enhance DNS server functionality with advanced DNSSEC signing (supporting both ECDSA and ED25519), improved SSL certificate retrieval using Let's Encrypt, and refined handler management for cleaner shutdowns.
|
||||
|
||||
- Updated package metadata with expanded keywords and revised dependency versions
|
||||
- Improved DNSSEC signing logic to support both ECDSA and ED25519 algorithms
|
||||
- Added unregisterHandler method for cleaner handler lifecycle management
|
||||
- Enhanced SSL certificate retrieval workflow with better DNS challenge handling
|
||||
- Refined test utilities for more robust DNS operations
|
||||
|
||||
## 2025-03-21 - 6.3.0 - feat(dns-server)
|
||||
Enhance DNS server functionality with advanced DNSSEC signing (including ED25519 support), improved certificate retrieval using Let's Encrypt, updated package metadata, and refined test utilities for more robust DNS operations.
|
||||
|
||||
- Updated package.json and npmextra.json with expanded keywords and revised dependency versions
|
||||
- Improved DNSSEC signing logic to support both ECDSA and ED25519 algorithms
|
||||
- Added unregisterHandler method and enhanced server stop logic for cleaner shutdowns
|
||||
- Enhanced SSL certificate retrieval workflow with better challenge handling and test support
|
||||
|
||||
## 2024-09-21 - 6.2.1 - fix(core)
|
||||
Fixing issues with keywords and readme formatting.
|
||||
|
||||
- Synchronized keywords field between npmextra.json and package.json.
|
||||
- Updated readme.md to fix formatting issues and added new sections.
|
||||
|
||||
## 2024-09-19 - 6.2.0 - feat(dnssec)
|
||||
Introduced DNSSEC support with ECDSA algorithm
|
||||
|
||||
- Added `DnsSec` class for handling DNSSEC operations.
|
||||
- Updated `DnsServer` to support DNSSEC with ECDSA.
|
||||
- Shifted DNS-related helper functions to `DnsServer` class.
|
||||
- Integrated parsing and handling of DNSKEY and RRSIG records in `DnsServer`.
|
||||
|
||||
## 2024-09-19 - 6.1.1 - fix(ts_server)
|
||||
Update DnsSec class to fully implement key generation and DNSKEY record creation.
|
||||
|
||||
- Added complete support for ECDSA and ED25519 algorithms in the DnsSec class.
|
||||
- Implemented DNSKEY generation and KeyTag computation methods.
|
||||
- Improved error handling and initialized the appropriate cryptographic instances based on the algorithm.
|
||||
|
||||
## 2024-09-18 - 6.1.0 - feat(smartdns)
|
||||
Add DNS Server and DNSSEC tools with comprehensive unit tests
|
||||
|
||||
- Updated package dependencies to the latest versions
|
||||
- Introduced DnsServer class for handling DNS requests over both HTTPS and UDP with support for custom handlers
|
||||
- Added DnsSec class for generating and managing DNSSEC keys and DS records
|
||||
- Implemented unit tests for DnsServer and Smartdns classes
|
||||
|
||||
## 2024-06-02 - 6.0.0 - server/client
|
||||
Main description here
|
||||
|
||||
- **Breaking Change:** Move from client only to server + client exports.
|
||||
|
||||
## 2024-03-30 - 5.0.4 - maintenance
|
||||
Range contains relevant changes
|
||||
|
||||
- Switch to new org scheme
|
||||
|
||||
## 2023-04-08 - 5.0.4 - core
|
||||
Main description here
|
||||
|
||||
- Core update
|
||||
- Fixes applied to the system
|
||||
|
||||
## 2022-07-27 - 5.0.0 - core
|
||||
Update contains relevant changes
|
||||
|
||||
- **Breaking Change:** Major update and core changes
|
||||
- Fixes and updates applied
|
||||
|
||||
## 2022-07-27 - 4.0.11 - core
|
||||
Range contains relevant changes
|
||||
|
||||
- **Breaking Change:** Core update and changes applied
|
||||
|
||||
## 2021-08-24 - 4.0.10 - core
|
||||
Range contains relevant changes
|
||||
|
||||
- Fixes applied to the core functionalities
|
||||
|
||||
## 2021-01-23 - 4.0.8 - core
|
||||
Range contains relevant changes
|
||||
|
||||
- Updates and fixes to the core components
|
||||
|
||||
## 2020-08-05 - 4.0.4 - core
|
||||
Range contains relevant changes
|
||||
|
||||
- Multiple core fixes applied
|
||||
|
||||
## 2020-02-15 - 4.0.0 - core
|
||||
Main description here
|
||||
|
||||
- Core updates
|
||||
- Fixes applied across the system
|
||||
|
||||
## 2020-02-15 - 3.0.8 - core
|
||||
Core updates with major changes
|
||||
|
||||
- **Breaking Change:** Now uses Google DNS HTTPS API and handles DNSSEC validation
|
||||
|
||||
## 2019-01-07 - 3.0.6 - core
|
||||
Range contains relevant changes
|
||||
|
||||
- Fixes and updates applied to the core
|
||||
|
||||
## 2018-05-13 - 3.0.4 - core
|
||||
Range contains relevant changes
|
||||
|
||||
- Fixes applied, including `fix .checkUntilAvailable` error
|
||||
|
||||
## 2018-05-13 - 3.0.0 - ci
|
||||
Main description here
|
||||
|
||||
- CI changes and updates to the access level and global packages
|
||||
|
||||
## 2017-07-31 - 2.0.10 - package
|
||||
Update to new package name and improved record retrieval
|
||||
|
||||
- **Breaking Change:** Package name update and record retrieval improvements
|
||||
|
||||
## 2017-01-27 - 2.0.1 - maintenance
|
||||
Multiple fixes and merges
|
||||
|
||||
## 2017-01-27 - 2.0.0 - core
|
||||
Fix typings and update to better API
|
||||
|
||||
## 2016-11-15 - 1.0.7 - initial
|
||||
Initial setup and improvements
|
||||
|
||||
- Initial deployment
|
||||
- README improvements
|
||||
|
||||
@ -2,17 +2,39 @@
|
||||
"gitzone": {
|
||||
"projectType": "npm",
|
||||
"module": {
|
||||
"githost": "gitlab.com",
|
||||
"gitscope": "pushrocks",
|
||||
"githost": "code.foss.global",
|
||||
"gitscope": "push.rocks",
|
||||
"gitrepo": "smartdns",
|
||||
"shortDescription": "smart dns methods written in TypeScript",
|
||||
"npmPackagename": "@pushrocks/smartdns",
|
||||
"license": "MIT"
|
||||
"description": "A robust TypeScript library providing advanced DNS management and resolution capabilities including support for DNSSEC, custom DNS servers, and integration with various DNS providers.",
|
||||
"npmPackagename": "@push.rocks/smartdns",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"TypeScript",
|
||||
"DNS",
|
||||
"DNS records",
|
||||
"DNS resolution",
|
||||
"DNS management",
|
||||
"DNSSEC",
|
||||
"Node.js",
|
||||
"Google DNS",
|
||||
"Cloudflare",
|
||||
"UDP DNS",
|
||||
"HTTPS DNS",
|
||||
"ACME",
|
||||
"Let's Encrypt",
|
||||
"SSL Certificates",
|
||||
"Feature Flagging",
|
||||
"Domain Propagation",
|
||||
"DNS Server"
|
||||
]
|
||||
}
|
||||
},
|
||||
"npmci": {
|
||||
"npmGlobalTools": [],
|
||||
"npmAccessLevel": "public",
|
||||
"npmRegistryUrl": "registry.npmjs.org"
|
||||
},
|
||||
"tsdoc": {
|
||||
"legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
|
||||
}
|
||||
}
|
||||
11001
package-lock.json
generated
11001
package-lock.json
generated
File diff suppressed because it is too large
Load Diff
71
package.json
71
package.json
@ -1,42 +1,65 @@
|
||||
{
|
||||
"name": "@pushrocks/smartdns",
|
||||
"version": "4.0.4",
|
||||
"name": "@push.rocks/smartdns",
|
||||
"version": "7.2.0",
|
||||
"private": false,
|
||||
"description": "smart dns methods written in TypeScript",
|
||||
"main": "dist_ts/index.js",
|
||||
"typings": "dist_ts/index.d.ts",
|
||||
"description": "A robust TypeScript library providing advanced DNS management and resolution capabilities including support for DNSSEC, custom DNS servers, and integration with various DNS providers.",
|
||||
"exports": {
|
||||
".": "./dist_ts/index.js",
|
||||
"./server": "./dist_ts_server/index.js",
|
||||
"./client": "./dist_ts_client/index.js"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "(tstest test/)",
|
||||
"build": "(tsbuild --web)"
|
||||
"test": "(tstest test/ --verbose --timeout 60)",
|
||||
"build": "(tsbuild tsfolders --web --allowimplicitany)",
|
||||
"buildDocs": "tsdoc"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+ssh://git@gitlab.com/pushrocks/dnsly.git"
|
||||
"url": "https://code.foss.global/push.rocks/smartdns.git"
|
||||
},
|
||||
"keywords": [
|
||||
"dns",
|
||||
"google dns",
|
||||
"dns record"
|
||||
"TypeScript",
|
||||
"DNS",
|
||||
"DNS records",
|
||||
"DNS resolution",
|
||||
"DNS management",
|
||||
"DNSSEC",
|
||||
"Node.js",
|
||||
"Google DNS",
|
||||
"Cloudflare",
|
||||
"UDP DNS",
|
||||
"HTTPS DNS",
|
||||
"ACME",
|
||||
"Let's Encrypt",
|
||||
"SSL Certificates",
|
||||
"Feature Flagging",
|
||||
"Domain Propagation",
|
||||
"DNS Server"
|
||||
],
|
||||
"author": "Lossless GmbH",
|
||||
"license": "MIT",
|
||||
"bugs": {
|
||||
"url": "https://gitlab.com/pushrocks/dnsly/issues"
|
||||
},
|
||||
"homepage": "https://gitlab.com/pushrocks/dnsly#README",
|
||||
"homepage": "https://code.foss.global/push.rocks/smartdns",
|
||||
"dependencies": {
|
||||
"@pushrocks/smartdelay": "^2.0.10",
|
||||
"@pushrocks/smartpromise": "^3.0.6",
|
||||
"@pushrocks/smartrequest": "^1.1.47",
|
||||
"@tsclass/tsclass": "^3.0.21"
|
||||
"@push.rocks/smartdelay": "^3.0.1",
|
||||
"@push.rocks/smartenv": "^5.0.5",
|
||||
"@push.rocks/smartpromise": "^4.2.3",
|
||||
"@push.rocks/smartrequest": "^2.1.0",
|
||||
"@tsclass/tsclass": "^9.2.0",
|
||||
"@types/dns-packet": "^5.6.5",
|
||||
"@types/elliptic": "^6.4.18",
|
||||
"acme-client": "^5.4.0",
|
||||
"dns-packet": "^5.6.1",
|
||||
"elliptic": "^6.6.1",
|
||||
"minimatch": "^10.0.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@gitzone/tsbuild": "^2.1.24",
|
||||
"@gitzone/tstest": "^1.0.43",
|
||||
"@pushrocks/tapbundle": "^3.2.9",
|
||||
"@types/node": "^14.0.27",
|
||||
"tslint": "^6.1.3",
|
||||
"tslint-config-prettier": "^1.18.0"
|
||||
"@git.zone/tsbuild": "^2.6.4",
|
||||
"@git.zone/tsrun": "^1.3.3",
|
||||
"@git.zone/tstest": "^2.3.1",
|
||||
"@types/node": "^22.15.21"
|
||||
},
|
||||
"files": [
|
||||
"ts/**/*",
|
||||
@ -52,5 +75,7 @@
|
||||
],
|
||||
"browserslist": [
|
||||
"last 1 chrome versions"
|
||||
]
|
||||
],
|
||||
"type": "module",
|
||||
"packageManager": "pnpm@10.10.0+sha512.d615db246fe70f25dcfea6d8d73dee782ce23e2245e3c4f6f888249fb568149318637dca73c2c5c8ef2a4ca0d5657fb9567188bfab47f566d1ee6ce987815c39"
|
||||
}
|
||||
|
||||
9140
pnpm-lock.yaml
generated
Normal file
9140
pnpm-lock.yaml
generated
Normal file
File diff suppressed because it is too large
Load Diff
97
readme.hints.md
Normal file
97
readme.hints.md
Normal file
@ -0,0 +1,97 @@
|
||||
# smartdns - Implementation Hints
|
||||
|
||||
## Architecture Overview
|
||||
|
||||
The smartdns library is structured into three main modules:
|
||||
|
||||
1. **Client Module** (`ts_client/`) - DNS client functionality
|
||||
2. **Server Module** (`ts_server/`) - DNS server implementation
|
||||
3. **Main Module** (`ts/`) - Re-exports both client and server
|
||||
|
||||
## Client Module (Smartdns class)
|
||||
|
||||
### Key Features:
|
||||
- DNS record queries (A, AAAA, TXT, MX, etc.)
|
||||
- Support for multiple DNS providers (Google DNS, Cloudflare)
|
||||
- DNS propagation checking with retry logic
|
||||
- DNSSEC verification support
|
||||
- Both HTTP-based (DoH) and Node.js DNS resolver fallback
|
||||
|
||||
### Implementation Details:
|
||||
- Uses Cloudflare's DNS-over-HTTPS API as primary resolver
|
||||
- Falls back to Node.js DNS module for local resolution
|
||||
- Implements automatic retry logic with configurable intervals
|
||||
- Properly handles quoted TXT records and trailing dots in domain names
|
||||
|
||||
### Key Methods:
|
||||
- `getRecordsA()`, `getRecordsAAAA()`, `getRecordsTxt()` - Type-specific queries
|
||||
- `getRecords()` - Generic record query with retry support
|
||||
- `checkUntilAvailable()` - DNS propagation verification
|
||||
- `getNameServers()` - NS record lookup
|
||||
- `makeNodeProcessUseDnsProvider()` - Configure system DNS resolver
|
||||
|
||||
## Server Module (DnsServer class)
|
||||
|
||||
### Key Features:
|
||||
- Full DNS server supporting UDP and HTTPS (DoH) protocols
|
||||
- DNSSEC implementation with multiple algorithms
|
||||
- Dynamic handler registration for custom responses
|
||||
- Let's Encrypt integration for automatic SSL certificates
|
||||
- Wildcard domain support with pattern matching
|
||||
|
||||
### DNSSEC Implementation:
|
||||
- Supports ECDSA (algorithm 13), ED25519 (algorithm 15), and RSA (algorithm 8)
|
||||
- Automatic DNSKEY and DS record generation
|
||||
- RRSIG signature generation for authenticated responses
|
||||
- Key tag computation following RFC 4034
|
||||
|
||||
### Let's Encrypt Integration:
|
||||
- Automatic SSL certificate retrieval using DNS-01 challenges
|
||||
- Dynamic TXT record handler registration for ACME validation
|
||||
- Certificate renewal and HTTPS server restart capability
|
||||
- Domain authorization filtering for security
|
||||
|
||||
### Handler System:
|
||||
- Pattern-based domain matching using minimatch
|
||||
- Support for all common record types
|
||||
- Handler chaining for complex scenarios
|
||||
- Automatic SOA response for unhandled queries
|
||||
|
||||
## Key Dependencies
|
||||
|
||||
- `dns-packet`: DNS packet encoding/decoding (wire format)
|
||||
- `elliptic`: Cryptographic operations for DNSSEC
|
||||
- `acme-client`: Let's Encrypt certificate automation
|
||||
- `minimatch`: Glob pattern matching for domains
|
||||
- `@push.rocks/smartrequest`: HTTP client for DoH queries
|
||||
- `@tsclass/tsclass`: Type definitions for DNS records
|
||||
|
||||
## Testing Insights
|
||||
|
||||
The test suite demonstrates:
|
||||
- Mock ACME client for testing Let's Encrypt integration
|
||||
- Self-signed certificate generation for HTTPS testing
|
||||
- Unique port allocation to avoid conflicts
|
||||
- Proper server cleanup between tests
|
||||
- Both UDP and HTTPS query validation
|
||||
|
||||
## Common Patterns
|
||||
|
||||
1. **DNS Record Types**: Internally mapped to numeric values (A=1, AAAA=28, etc.)
|
||||
2. **Error Handling**: Graceful fallback and retry mechanisms
|
||||
3. **DNSSEC Workflow**: Zone → Key Generation → Signing → Verification
|
||||
4. **Certificate Flow**: Domain validation → Challenge setup → Verification → Certificate retrieval
|
||||
|
||||
## Performance Considerations
|
||||
|
||||
- Client implements caching via DNS-over-HTTPS responses
|
||||
- Server can handle concurrent UDP and HTTPS requests
|
||||
- DNSSEC signing is performed on-demand for efficiency
|
||||
- Handler registration is O(n) lookup but uses pattern caching
|
||||
|
||||
## Security Notes
|
||||
|
||||
- DNSSEC provides authentication but not encryption
|
||||
- DoH (DNS-over-HTTPS) provides both privacy and integrity
|
||||
- Let's Encrypt integration requires proper domain authorization
|
||||
- Handler patterns should be carefully designed to avoid open resolvers
|
||||
637
readme.md
637
readme.md
@ -1,53 +1,612 @@
|
||||
# @pushrocks/smartdns
|
||||
smart dns methods written in TypeScript
|
||||
# @push.rocks/smartdns
|
||||
|
||||
## Availabililty and Links
|
||||
* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartdns)
|
||||
* [gitlab.com (source)](https://gitlab.com/pushrocks/smartdns)
|
||||
* [github.com (source mirror)](https://github.com/pushrocks/smartdns)
|
||||
* [docs (typedoc)](https://pushrocks.gitlab.io/smartdns/)
|
||||
A robust TypeScript library providing advanced DNS management and resolution capabilities including support for DNSSEC, custom DNS servers, and integration with various DNS providers.
|
||||
|
||||
## Status for master
|
||||
## Install
|
||||
|
||||
Status Category | Status Badge
|
||||
-- | --
|
||||
GitLab Pipelines | [](https://lossless.cloud)
|
||||
GitLab Pipline Test Coverage | [](https://lossless.cloud)
|
||||
npm | [](https://lossless.cloud)
|
||||
Snyk | [](https://lossless.cloud)
|
||||
TypeScript Support | [](https://lossless.cloud)
|
||||
node Support | [](https://nodejs.org/dist/latest-v10.x/docs/api/)
|
||||
Code Style | [](https://lossless.cloud)
|
||||
PackagePhobia (total standalone install weight) | [](https://lossless.cloud)
|
||||
PackagePhobia (package size on registry) | [](https://lossless.cloud)
|
||||
BundlePhobia (total size when bundled) | [](https://lossless.cloud)
|
||||
Platform support | [](https://lossless.cloud) [](https://lossless.cloud)
|
||||
To install `@push.rocks/smartdns`, use the following command with pnpm:
|
||||
|
||||
```bash
|
||||
pnpm install @push.rocks/smartdns --save
|
||||
```
|
||||
|
||||
Or with npm:
|
||||
|
||||
```bash
|
||||
npm install @push.rocks/smartdns --save
|
||||
```
|
||||
|
||||
Make sure you have a TypeScript environment set up to utilize the library effectively.
|
||||
|
||||
## Usage
|
||||
|
||||
Use TypeScript for best in class instellisense.
|
||||
`@push.rocks/smartdns` is a comprehensive library that provides both DNS client and server capabilities, leveraging TypeScript for enhanced development experience. The library is organized into three modules:
|
||||
|
||||
- **Client Module** (`@push.rocks/smartdns/client`): DNS resolution and record queries
|
||||
- **Server Module** (`@push.rocks/smartdns/server`): Full DNS server implementation with DNSSEC
|
||||
- **Main Module** (`@push.rocks/smartdns`): Convenience exports for both client and server
|
||||
|
||||
### Getting Started
|
||||
|
||||
You can import the modules based on your needs:
|
||||
|
||||
```typescript
|
||||
const mySmartDns = new smartdns.SmartDns(); // uses Google DNS Https API
|
||||
const demoRecord = await mySmartDns.getRecord('example.com', 'AAAA'); // returns promise
|
||||
/*
|
||||
demoRecord looks like this:
|
||||
{
|
||||
name: 'example.com',
|
||||
type: 'A',
|
||||
dnsSecEnabled: true,
|
||||
value: '104.24.103.243'
|
||||
}
|
||||
*/
|
||||
// For DNS client operations
|
||||
import { Smartdns } from '@push.rocks/smartdns/client';
|
||||
|
||||
// For DNS server operations
|
||||
import { DnsServer } from '@push.rocks/smartdns/server';
|
||||
|
||||
// Or import from the main module (note the different syntax)
|
||||
import { dnsClientMod, dnsServerMod } from '@push.rocks/smartdns';
|
||||
const dnsClient = new dnsClientMod.Smartdns({});
|
||||
const dnsServer = new dnsServerMod.DnsServer({ /* options */ });
|
||||
```
|
||||
|
||||
## Contribution
|
||||
### DNS Client Operations
|
||||
|
||||
We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
|
||||
The DNS client (`Smartdns` class) provides methods to query various DNS record types using DNS-over-HTTPS (DoH) with Cloudflare as the primary provider, with fallback to Node.js DNS resolver.
|
||||
|
||||
For further information read the linked docs at the top of this readme.
|
||||
#### Fetching A Records
|
||||
|
||||
> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
|
||||
| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
|
||||
To fetch "A" records (IPv4 addresses) for a domain:
|
||||
|
||||
[](https://maintainedby.lossless.com)
|
||||
```typescript
|
||||
import { Smartdns } from '@push.rocks/smartdns/client';
|
||||
|
||||
const dnsClient = new Smartdns({});
|
||||
const aRecords = await dnsClient.getRecordsA('example.com');
|
||||
console.log(aRecords);
|
||||
// Output: [{ name: 'example.com', type: 'A', dnsSecEnabled: false, value: '93.184.215.14' }]
|
||||
```
|
||||
|
||||
#### Fetching AAAA Records
|
||||
|
||||
For resolving a domain to IPv6 addresses:
|
||||
|
||||
```typescript
|
||||
const aaaaRecords = await dnsClient.getRecordsAAAA('example.com');
|
||||
console.log(aaaaRecords);
|
||||
// Output: [{ name: 'example.com', type: 'AAAA', dnsSecEnabled: false, value: '2606:2800:21f:cb07:6820:80da:af6b:8b2c' }]
|
||||
```
|
||||
|
||||
#### Fetching TXT Records
|
||||
|
||||
TXT records store text data, commonly used for domain verification, SPF records, and other metadata:
|
||||
|
||||
```typescript
|
||||
const txtRecords = await dnsClient.getRecordsTxt('example.com');
|
||||
console.log(txtRecords);
|
||||
// Output: [{ name: 'example.com', type: 'TXT', dnsSecEnabled: false, value: 'v=spf1 -all' }]
|
||||
```
|
||||
|
||||
#### Other Record Types
|
||||
|
||||
The client supports various other DNS record types:
|
||||
|
||||
```typescript
|
||||
// MX records for mail servers
|
||||
const mxRecords = await dnsClient.getRecords('example.com', 'MX');
|
||||
|
||||
// NS records for nameservers
|
||||
const nsRecords = await dnsClient.getNameServers('example.com');
|
||||
|
||||
// Generic query method with retry support
|
||||
const records = await dnsClient.getRecords('example.com', 'CNAME', { retryCount: 3 });
|
||||
```
|
||||
|
||||
### Advanced DNS Features
|
||||
|
||||
#### Checking DNS Propagation
|
||||
|
||||
The client provides a powerful method to verify DNS propagation globally, essential when making DNS changes:
|
||||
|
||||
```typescript
|
||||
// Check if a specific DNS record has propagated
|
||||
const recordType = 'TXT';
|
||||
const expectedValue = 'verification=abc123';
|
||||
|
||||
const isAvailable = await dnsClient.checkUntilAvailable(
|
||||
'example.com',
|
||||
recordType,
|
||||
expectedValue,
|
||||
50, // Number of check cycles (default: 50)
|
||||
500 // Interval between checks in ms (default: 500)
|
||||
);
|
||||
|
||||
if (isAvailable) {
|
||||
console.log('DNS record has propagated successfully!');
|
||||
} else {
|
||||
console.log('DNS propagation timeout - record not found.');
|
||||
}
|
||||
```
|
||||
|
||||
#### Configuring System DNS Provider
|
||||
|
||||
You can configure Node.js to use a specific DNS provider for all DNS queries:
|
||||
|
||||
```typescript
|
||||
// Import the standalone function
|
||||
import { makeNodeProcessUseDnsProvider } from '@push.rocks/smartdns/client';
|
||||
|
||||
// Use Cloudflare DNS for all Node.js DNS operations
|
||||
makeNodeProcessUseDnsProvider('cloudflare');
|
||||
|
||||
// Or use Google DNS
|
||||
makeNodeProcessUseDnsProvider('google');
|
||||
```
|
||||
|
||||
### Real-World Use Cases
|
||||
|
||||
#### DNS-Based Feature Flagging
|
||||
|
||||
Use TXT records for dynamic feature toggles without redeployment:
|
||||
|
||||
```typescript
|
||||
const txtRecords = await dnsClient.getRecordsTxt('features.example.com');
|
||||
const featureFlags = {};
|
||||
|
||||
txtRecords.forEach(record => {
|
||||
// Parse TXT records like "feature-dark-mode=true"
|
||||
const [feature, enabled] = record.value.split('=');
|
||||
featureFlags[feature] = enabled === 'true';
|
||||
});
|
||||
|
||||
if (featureFlags['feature-dark-mode']) {
|
||||
console.log('Dark mode is enabled!');
|
||||
}
|
||||
```
|
||||
|
||||
#### Service Discovery
|
||||
|
||||
Use DNS for service endpoint discovery:
|
||||
|
||||
```typescript
|
||||
// Discover API endpoints via TXT records
|
||||
const serviceRecords = await dnsClient.getRecordsTxt('_services.example.com');
|
||||
|
||||
// Discover mail servers
|
||||
const mxRecords = await dnsClient.getRecords('example.com', 'MX');
|
||||
const primaryMailServer = mxRecords
|
||||
.sort((a, b) => a.priority - b.priority)[0]?.exchange;
|
||||
```
|
||||
|
||||
### DNS Server Implementation
|
||||
|
||||
The `DnsServer` class provides a full-featured DNS server with support for UDP, DNS-over-HTTPS (DoH), DNSSEC, and automatic SSL certificate management via Let's Encrypt.
|
||||
|
||||
#### Basic DNS Server Setup
|
||||
|
||||
Create a simple DNS server that responds to queries:
|
||||
|
||||
```typescript
|
||||
import { DnsServer } from '@push.rocks/smartdns/server';
|
||||
|
||||
const dnsServer = new DnsServer({
|
||||
udpPort: 5333, // UDP port for DNS queries
|
||||
httpsPort: 8443, // HTTPS port for DNS-over-HTTPS
|
||||
httpsKey: 'path/to/key.pem', // Required for HTTPS
|
||||
httpsCert: 'path/to/cert.pem', // Required for HTTPS
|
||||
dnssecZone: 'example.com' // Optional: enable DNSSEC for this zone
|
||||
});
|
||||
|
||||
// For enhanced security, bind to specific interfaces
|
||||
const secureServer = new DnsServer({
|
||||
udpPort: 53,
|
||||
httpsPort: 443,
|
||||
httpsKey: 'path/to/key.pem',
|
||||
httpsCert: 'path/to/cert.pem',
|
||||
dnssecZone: 'example.com',
|
||||
udpBindInterface: '127.0.0.1', // Bind UDP to localhost only
|
||||
httpsBindInterface: '127.0.0.1' // Bind HTTPS to localhost only
|
||||
});
|
||||
|
||||
// Register a handler for all subdomains of example.com
|
||||
dnsServer.registerHandler('*.example.com', ['A'], (question) => ({
|
||||
name: question.name,
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: '192.168.1.100',
|
||||
}));
|
||||
|
||||
// Register a handler for TXT records
|
||||
dnsServer.registerHandler('example.com', ['TXT'], (question) => ({
|
||||
name: question.name,
|
||||
type: 'TXT',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: 'v=spf1 include:_spf.example.com ~all',
|
||||
}));
|
||||
|
||||
// Start the server
|
||||
await dnsServer.start();
|
||||
console.log('DNS Server started!');
|
||||
```
|
||||
|
||||
### DNSSEC Support
|
||||
|
||||
The DNS server includes comprehensive DNSSEC support with automatic key generation and record signing:
|
||||
|
||||
```typescript
|
||||
import { DnsServer } from '@push.rocks/smartdns/server';
|
||||
|
||||
const dnsServer = new DnsServer({
|
||||
udpPort: 53,
|
||||
httpsPort: 443,
|
||||
dnssecZone: 'secure.example.com', // Enable DNSSEC for this zone
|
||||
});
|
||||
|
||||
// The server automatically:
|
||||
// 1. Generates DNSKEY records with ECDSA (algorithm 13)
|
||||
// 2. Creates DS records for parent zone delegation
|
||||
// 3. Signs all responses with RRSIG records
|
||||
// 4. Provides NSEC records for authenticated denial of existence
|
||||
|
||||
// Register your handlers as normal - DNSSEC signing is automatic
|
||||
dnsServer.registerHandler('secure.example.com', ['A'], (question) => ({
|
||||
name: question.name,
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: '192.168.1.1',
|
||||
}));
|
||||
|
||||
await dnsServer.start();
|
||||
|
||||
// Query for DNSSEC records
|
||||
import { Smartdns } from '@push.rocks/smartdns/client';
|
||||
const client = new Smartdns({});
|
||||
const dnskeyRecords = await client.getRecords('secure.example.com', 'DNSKEY');
|
||||
const dsRecords = await client.getRecords('secure.example.com', 'DS');
|
||||
```
|
||||
|
||||
#### Supported DNSSEC Algorithms
|
||||
|
||||
The server supports multiple DNSSEC algorithms:
|
||||
- **ECDSAP256SHA256** (Algorithm 13) - Default, using P-256 curve
|
||||
- **ED25519** (Algorithm 15) - Modern elliptic curve algorithm
|
||||
- **RSASHA256** (Algorithm 8) - RSA-based signatures
|
||||
|
||||
### Let's Encrypt Integration
|
||||
|
||||
The DNS server includes built-in Let's Encrypt support for automatic SSL certificate management:
|
||||
|
||||
```typescript
|
||||
import { DnsServer } from '@push.rocks/smartdns/server';
|
||||
|
||||
const dnsServer = new DnsServer({
|
||||
udpPort: 53,
|
||||
httpsPort: 443,
|
||||
httpsKey: '/path/to/letsencrypt/key.pem', // Will be auto-generated
|
||||
httpsCert: '/path/to/letsencrypt/cert.pem', // Will be auto-generated
|
||||
});
|
||||
|
||||
// Retrieve Let's Encrypt certificate for your domain
|
||||
const result = await dnsServer.retrieveSslCertificate(
|
||||
['secure.example.com', 'www.secure.example.com'],
|
||||
{
|
||||
email: 'admin@example.com',
|
||||
staging: false, // Use production Let's Encrypt
|
||||
certDir: './certs'
|
||||
}
|
||||
);
|
||||
|
||||
if (result.success) {
|
||||
console.log('Certificate retrieved successfully!');
|
||||
}
|
||||
|
||||
// The server automatically:
|
||||
// 1. Handles ACME DNS-01 challenges
|
||||
// 2. Creates temporary TXT records for domain validation
|
||||
// 3. Retrieves and installs the certificate
|
||||
// 4. Restarts the HTTPS server with the new certificate
|
||||
|
||||
await dnsServer.start();
|
||||
console.log('DNS Server with Let\'s Encrypt SSL started!');
|
||||
```
|
||||
|
||||
### Handling Different Protocols
|
||||
|
||||
#### UDP DNS Server
|
||||
|
||||
Traditional DNS queries over UDP (port 53):
|
||||
|
||||
```typescript
|
||||
import { DnsServer } from '@push.rocks/smartdns/server';
|
||||
import * as plugins from '@push.rocks/smartdns/server/plugins';
|
||||
|
||||
const dnsServer = new DnsServer({
|
||||
udpPort: 5353, // Using alternate port for testing
|
||||
httpsPort: 8443,
|
||||
httpsKey: fs.readFileSync('/path/to/key.pem', 'utf8'),
|
||||
httpsCert: fs.readFileSync('/path/to/cert.pem', 'utf8'),
|
||||
dnssecZone: 'test.local' // Optional
|
||||
});
|
||||
|
||||
// The UDP server automatically handles DNS packet parsing and encoding
|
||||
dnsServer.registerHandler('test.local', ['A'], (question) => ({
|
||||
name: question.name,
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 60,
|
||||
data: '127.0.0.1',
|
||||
}));
|
||||
|
||||
await dnsServer.start();
|
||||
|
||||
// Test with dig or nslookup:
|
||||
// dig @localhost -p 5353 test.local
|
||||
```
|
||||
|
||||
#### DNS-over-HTTPS (DoH) Server
|
||||
|
||||
Provide encrypted DNS queries over HTTPS:
|
||||
|
||||
```typescript
|
||||
import { DnsServer } from '@push.rocks/smartdns/server';
|
||||
import * as fs from 'fs';
|
||||
|
||||
const dnsServer = new DnsServer({
|
||||
httpsPort: 8443,
|
||||
httpsKey: fs.readFileSync('/path/to/key.pem', 'utf8'),
|
||||
httpsCert: fs.readFileSync('/path/to/cert.pem', 'utf8'),
|
||||
});
|
||||
|
||||
// The HTTPS server automatically handles:
|
||||
// - DNS wire format in POST body
|
||||
// - Proper Content-Type headers (application/dns-message)
|
||||
// - Base64url encoding for GET requests
|
||||
|
||||
dnsServer.registerHandler('secure.local', ['A'], (question) => ({
|
||||
name: question.name,
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: '10.0.0.1',
|
||||
}));
|
||||
|
||||
await dnsServer.start();
|
||||
|
||||
// Test with curl:
|
||||
// curl -H "Content-Type: application/dns-message" \
|
||||
// --data-binary @query.bin \
|
||||
// https://localhost:8443/dns-query
|
||||
```
|
||||
|
||||
### Interface Binding
|
||||
|
||||
For enhanced security and network isolation, you can bind the DNS server to specific network interfaces instead of all available interfaces.
|
||||
|
||||
#### Localhost-Only Binding
|
||||
|
||||
Bind to localhost for development or local-only DNS services:
|
||||
|
||||
```typescript
|
||||
const localServer = new DnsServer({
|
||||
udpPort: 5353,
|
||||
httpsPort: 8443,
|
||||
httpsKey: cert.key,
|
||||
httpsCert: cert.cert,
|
||||
dnssecZone: 'local.test',
|
||||
udpBindInterface: '127.0.0.1', // IPv4 localhost
|
||||
httpsBindInterface: '127.0.0.1'
|
||||
});
|
||||
|
||||
// Or use IPv6 localhost
|
||||
const ipv6LocalServer = new DnsServer({
|
||||
// ... other options
|
||||
udpBindInterface: '::1', // IPv6 localhost
|
||||
httpsBindInterface: '::1'
|
||||
});
|
||||
```
|
||||
|
||||
#### Specific Interface Binding
|
||||
|
||||
Bind to a specific network interface in multi-homed servers:
|
||||
|
||||
```typescript
|
||||
const interfaceServer = new DnsServer({
|
||||
udpPort: 53,
|
||||
httpsPort: 443,
|
||||
httpsKey: cert.key,
|
||||
httpsCert: cert.cert,
|
||||
dnssecZone: 'example.com',
|
||||
udpBindInterface: '192.168.1.100', // Specific internal interface
|
||||
httpsBindInterface: '10.0.0.50' // Different interface for HTTPS
|
||||
});
|
||||
```
|
||||
|
||||
#### Security Considerations
|
||||
|
||||
- **Default Behavior**: If not specified, servers bind to all interfaces (`0.0.0.0`)
|
||||
- **Localhost Binding**: Use `127.0.0.1` or `::1` for development and testing
|
||||
- **Production**: Consider binding to specific internal interfaces for security
|
||||
- **Validation**: Invalid IP addresses will throw an error during server startup
|
||||
|
||||
### Advanced Handler Patterns
|
||||
|
||||
#### Pattern-Based Routing
|
||||
|
||||
Use glob patterns for flexible domain matching:
|
||||
|
||||
```typescript
|
||||
// Match all subdomains
|
||||
dnsServer.registerHandler('*.example.com', ['A'], (question) => {
|
||||
// Extract subdomain
|
||||
const subdomain = question.name.replace('.example.com', '');
|
||||
|
||||
// Dynamic response based on subdomain
|
||||
return {
|
||||
name: question.name,
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: subdomain === 'api' ? '10.0.0.10' : '10.0.0.1',
|
||||
};
|
||||
});
|
||||
|
||||
// Match specific patterns
|
||||
dnsServer.registerHandler('db-*.service.local', ['A'], (question) => {
|
||||
const instanceId = question.name.match(/db-(\d+)/)?.[1];
|
||||
return {
|
||||
name: question.name,
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 60,
|
||||
data: `10.0.1.${instanceId}`,
|
||||
};
|
||||
});
|
||||
|
||||
// Catch-all handler
|
||||
dnsServer.registerHandler('*', ['A'], (question) => ({
|
||||
name: question.name,
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: '127.0.0.1',
|
||||
}));
|
||||
```
|
||||
|
||||
### Testing
|
||||
|
||||
The library uses `@git.zone/tstest` for testing. Here's an example of comprehensive tests:
|
||||
|
||||
```typescript
|
||||
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
||||
import { Smartdns } from '@push.rocks/smartdns/client';
|
||||
import { DnsServer } from '@push.rocks/smartdns/server';
|
||||
|
||||
// Test DNS Client
|
||||
tap.test('DNS Client - Query Records', async () => {
|
||||
const dnsClient = new Smartdns({});
|
||||
|
||||
// Test A record query
|
||||
const aRecords = await dnsClient.getRecordsA('google.com');
|
||||
expect(aRecords).toBeArray();
|
||||
expect(aRecords[0]).toHaveProperty('type', 'A');
|
||||
expect(aRecords[0].data).toMatch(/^\d+\.\d+\.\d+\.\d+$/);
|
||||
|
||||
// Test TXT record query
|
||||
const txtRecords = await dnsClient.getRecordsTxt('google.com');
|
||||
expect(txtRecords).toBeArray();
|
||||
expect(txtRecords[0]).toHaveProperty('type', 'TXT');
|
||||
});
|
||||
|
||||
// Test DNS Server
|
||||
let dnsServer: DnsServer;
|
||||
|
||||
tap.test('DNS Server - Setup and Start', async () => {
|
||||
dnsServer = new DnsServer({
|
||||
udpPort: 5353,
|
||||
httpsPort: 8443,
|
||||
httpsKey: 'test-key', // Use test certificates
|
||||
httpsCert: 'test-cert',
|
||||
dnssecZone: 'test.local'
|
||||
});
|
||||
|
||||
expect(dnsServer).toBeInstanceOf(DnsServer);
|
||||
await dnsServer.start();
|
||||
});
|
||||
|
||||
tap.test('DNS Server - Register Handlers', async () => {
|
||||
// Register multiple handlers
|
||||
dnsServer.registerHandler('test.local', ['A'], () => ({
|
||||
name: 'test.local',
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: '127.0.0.1',
|
||||
}));
|
||||
|
||||
dnsServer.registerHandler('*.test.local', ['A'], (question) => ({
|
||||
name: question.name,
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 60,
|
||||
data: '127.0.0.2',
|
||||
}));
|
||||
});
|
||||
|
||||
tap.test('DNS Server - Query via UDP', async (tools) => {
|
||||
const dnsPacket = (await import('dns-packet')).default;
|
||||
const dgram = await import('dgram');
|
||||
|
||||
const query = dnsPacket.encode({
|
||||
type: 'query',
|
||||
id: 1234,
|
||||
questions: [{
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
name: 'test.local',
|
||||
}],
|
||||
});
|
||||
|
||||
const client = dgram.createSocket('udp4');
|
||||
const done = tools.defer();
|
||||
|
||||
client.on('message', (msg) => {
|
||||
const response = dnsPacket.decode(msg);
|
||||
expect(response.answers[0].data).toEqual('127.0.0.1');
|
||||
client.close();
|
||||
done.resolve();
|
||||
});
|
||||
|
||||
client.send(query, 5353, 'localhost'); // Use the port specified during server creation
|
||||
await done.promise;
|
||||
});
|
||||
|
||||
tap.test('DNS Server - Cleanup', async () => {
|
||||
await dnsServer.stop();
|
||||
});
|
||||
|
||||
// Run tests
|
||||
await tap.start();
|
||||
```
|
||||
|
||||
### Best Practices
|
||||
|
||||
1. **Port Selection**: Use non-privileged ports (>1024) during development
|
||||
2. **Handler Organization**: Group related handlers together
|
||||
3. **Error Handling**: Always handle DNS query errors gracefully
|
||||
4. **DNSSEC**: Enable DNSSEC for production deployments
|
||||
5. **Monitoring**: Log DNS queries for debugging and analytics
|
||||
6. **Rate Limiting**: Implement rate limiting for public DNS servers
|
||||
7. **Caching**: Respect TTL values and implement proper caching
|
||||
|
||||
### Performance Considerations
|
||||
|
||||
- The DNS client uses HTTP keep-alive for connection reuse
|
||||
- The DNS server handles concurrent UDP and HTTPS requests efficiently
|
||||
- DNSSEC signatures are generated on-demand to reduce memory usage
|
||||
- Pattern matching uses caching for improved performance
|
||||
|
||||
### Security Considerations
|
||||
|
||||
- Always use DNSSEC for authenticated responses
|
||||
- Enable DoH for encrypted DNS queries
|
||||
- Validate and sanitize all DNS inputs
|
||||
- Implement access controls for DNS server handlers
|
||||
- Use Let's Encrypt for automatic SSL certificate management
|
||||
- Never expose internal network information through DNS
|
||||
|
||||
This comprehensive library provides everything needed for both DNS client operations and running production-grade DNS servers with modern security features in TypeScript.
|
||||
|
||||
## License and Legal Information
|
||||
|
||||
This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license.md) file within this repository.
|
||||
|
||||
**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
|
||||
|
||||
### Trademarks
|
||||
|
||||
This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
|
||||
|
||||
### Company Information
|
||||
|
||||
Task Venture Capital GmbH
|
||||
Registered at District court Bremen HRB 35230 HB, Germany
|
||||
|
||||
For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
|
||||
|
||||
By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
|
||||
103
readme.plan.md
Normal file
103
readme.plan.md
Normal file
@ -0,0 +1,103 @@
|
||||
# DNS Server Interface Binding Implementation Plan
|
||||
|
||||
Command to reread CLAUDE.md: `cat /home/philkunz/.claude/CLAUDE.md`
|
||||
|
||||
## Overview ✅ COMPLETED
|
||||
Enable specific interface binding for the DNSServer class to allow binding to specific network interfaces instead of all interfaces (0.0.0.0).
|
||||
|
||||
## Implementation Status: COMPLETED ✅
|
||||
|
||||
### What was implemented:
|
||||
|
||||
✅ **1. Updated IDnsServerOptions Interface**
|
||||
- Added optional `udpBindInterface?: string` property (defaults to '0.0.0.0')
|
||||
- Added optional `httpsBindInterface?: string` property (defaults to '0.0.0.0')
|
||||
- Located in `ts_server/classes.dnsserver.ts:5-11`
|
||||
|
||||
✅ **2. Modified DnsServer.start() Method**
|
||||
- Updated UDP server binding to use `this.options.udpBindInterface || '0.0.0.0'`
|
||||
- Updated HTTPS server listening to use `this.options.httpsBindInterface || '0.0.0.0'`
|
||||
- Added IP address validation before binding
|
||||
- Updated console logging to show specific interface being bound
|
||||
- Located in `ts_server/classes.dnsserver.ts:699-752`
|
||||
|
||||
✅ **3. Added IP Address Validation**
|
||||
- Created `isValidIpAddress()` method supporting IPv4 and IPv6
|
||||
- Validates interface addresses before binding
|
||||
- Throws meaningful error messages for invalid addresses
|
||||
- Located in `ts_server/classes.dnsserver.ts:392-398`
|
||||
|
||||
✅ **4. Updated Documentation**
|
||||
- Added dedicated "Interface Binding" section to readme.md
|
||||
- Included examples for localhost-only binding (`127.0.0.1`, `::1`)
|
||||
- Documented security considerations and use cases
|
||||
- Added examples for specific interface binding
|
||||
|
||||
✅ **5. Added Comprehensive Tests**
|
||||
- **localhost binding test**: Verifies binding to `127.0.0.1` instead of `0.0.0.0`
|
||||
- **Invalid IP validation test**: Ensures invalid IP addresses are rejected
|
||||
- **IPv6 support test**: Tests `::1` binding (with graceful fallback if IPv6 unavailable)
|
||||
- **Backwards compatibility**: Existing tests continue to work with default behavior
|
||||
- Located in `test/test.server.ts`
|
||||
|
||||
✅ **6. Updated restartHttpsServer Method**
|
||||
- Modified to respect interface binding options during certificate updates
|
||||
- Ensures Let's Encrypt certificate renewal maintains interface binding
|
||||
|
||||
## ✅ Implementation Results
|
||||
|
||||
### Test Results
|
||||
All interface binding functionality has been successfully tested:
|
||||
|
||||
```bash
|
||||
✅ should bind to localhost interface only (318ms)
|
||||
- UDP DNS server running on 127.0.0.1:8085
|
||||
- HTTPS DNS server running on 127.0.0.1:8084
|
||||
|
||||
✅ should reject invalid IP addresses (151ms)
|
||||
- Validates IP address format correctly
|
||||
- Throws meaningful error messages
|
||||
|
||||
✅ should work with IPv6 localhost if available
|
||||
- Gracefully handles IPv6 unavailability in containerized environments
|
||||
```
|
||||
|
||||
### Benefits Achieved
|
||||
- ✅ Enhanced security by allowing localhost-only binding
|
||||
- ✅ Support for multi-homed servers with specific interface requirements
|
||||
- ✅ Better isolation in containerized environments
|
||||
- ✅ Backwards compatible (defaults to current behavior)
|
||||
- ✅ IP address validation with clear error messages
|
||||
- ✅ IPv4 and IPv6 support
|
||||
|
||||
## Example Usage (Now Available)
|
||||
```typescript
|
||||
// Bind to localhost only
|
||||
const dnsServer = new DnsServer({
|
||||
httpsKey: cert.key,
|
||||
httpsCert: cert.cert,
|
||||
httpsPort: 443,
|
||||
udpPort: 53,
|
||||
dnssecZone: 'example.com',
|
||||
udpBindInterface: '127.0.0.1',
|
||||
httpsBindInterface: '127.0.0.1'
|
||||
});
|
||||
|
||||
// Bind to specific interface
|
||||
const dnsServer = new DnsServer({
|
||||
// ... other options
|
||||
udpBindInterface: '192.168.1.100',
|
||||
httpsBindInterface: '192.168.1.100'
|
||||
});
|
||||
```
|
||||
|
||||
## Files to Modify
|
||||
1. `ts_server/classes.dnsserver.ts` - Interface and implementation
|
||||
2. `readme.md` - Documentation updates
|
||||
3. `test/test.server.ts` - Add interface binding tests
|
||||
|
||||
## Testing Strategy
|
||||
- Unit tests for interface validation
|
||||
- Integration tests for binding behavior
|
||||
- Error handling tests for invalid interfaces
|
||||
- Backwards compatibility tests
|
||||
211
readme.plan2.md
Normal file
211
readme.plan2.md
Normal file
@ -0,0 +1,211 @@
|
||||
# DNS Server Manual Socket Handling Implementation Plan
|
||||
|
||||
Command to reread CLAUDE.md: `cat /home/philkunz/.claude/CLAUDE.md`
|
||||
|
||||
## Overview
|
||||
Enable manual socket handling for the DNSServer class to allow external socket management instead of internal socket creation and binding. This enables advanced use cases like socket pooling, custom networking layers, and integration with existing socket infrastructures.
|
||||
|
||||
## Current Implementation Analysis
|
||||
- DNSServer currently creates and manages its own UDP (`dgram.Socket`) and HTTPS (`https.Server`) sockets
|
||||
- Socket creation happens in `start()` method at lines ~728-752 in `ts_server/classes.dnsserver.ts`
|
||||
- No mechanism exists to inject pre-created sockets
|
||||
- Socket lifecycle is tightly coupled with server lifecycle
|
||||
|
||||
## Implementation Plan
|
||||
|
||||
### 1. Update IDnsServerOptions Interface
|
||||
- Add optional `udpSocket?: dgram.Socket` property
|
||||
- Add optional `httpsServer?: https.Server` property
|
||||
- Add optional `manualMode?: boolean` flag to indicate manual socket handling
|
||||
- Maintain backwards compatibility with existing automatic socket creation
|
||||
|
||||
### 2. Modify DnsServer Constructor
|
||||
- Accept pre-created sockets in options
|
||||
- Store references to manual sockets
|
||||
- Set internal flags to track manual vs automatic mode
|
||||
|
||||
### 3. Update start() Method Logic
|
||||
- Skip socket creation if manual sockets provided
|
||||
- Validate manual sockets are in correct state
|
||||
- Attach event listeners to provided sockets
|
||||
- Support hybrid mode (UDP manual, HTTPS automatic, or vice versa)
|
||||
|
||||
### 4. Update stop() Method Logic
|
||||
- For manual sockets: only remove event listeners, don't close sockets
|
||||
- For automatic sockets: close sockets as current behavior
|
||||
- Provide clear separation of lifecycle management
|
||||
|
||||
### 5. Add Socket Validation
|
||||
- Verify provided UDP socket is correct type (udp4/udp6)
|
||||
- Ensure HTTPS server is properly configured
|
||||
- Validate socket state (not already listening, etc.)
|
||||
|
||||
### 6. Error Handling & Events
|
||||
- Emit events for socket errors without stopping server
|
||||
- Allow graceful handling of external socket failures
|
||||
- Provide clear error messages for socket state issues
|
||||
|
||||
## Benefits
|
||||
- **Socket Pooling**: Share sockets across multiple DNS server instances
|
||||
- **Custom Networking**: Integration with custom network stacks
|
||||
- **Performance**: Reuse existing socket infrastructure
|
||||
- **Advanced Configuration**: Fine-grained control over socket options
|
||||
- **Testing**: Easier mocking and testing with provided sockets
|
||||
- **Container Integration**: Better integration with orchestration platforms
|
||||
|
||||
## Example Usage After Implementation
|
||||
|
||||
### Manual UDP Socket with Automatic HTTPS
|
||||
```typescript
|
||||
import * as dgram from 'dgram';
|
||||
import { DnsServer } from '@push.rocks/smartdns/server';
|
||||
|
||||
// Create and configure UDP socket externally
|
||||
const udpSocket = dgram.createSocket('udp4');
|
||||
udpSocket.bind(53, '0.0.0.0');
|
||||
|
||||
const dnsServer = new DnsServer({
|
||||
// Manual UDP socket
|
||||
udpSocket: udpSocket,
|
||||
manualMode: true,
|
||||
|
||||
// Automatic HTTPS server
|
||||
httpsPort: 443,
|
||||
httpsKey: cert.key,
|
||||
httpsCert: cert.cert,
|
||||
dnssecZone: 'example.com'
|
||||
});
|
||||
|
||||
await dnsServer.start(); // Won't create new UDP socket
|
||||
```
|
||||
|
||||
### Fully Manual Mode
|
||||
```typescript
|
||||
import * as https from 'https';
|
||||
import * as dgram from 'dgram';
|
||||
|
||||
// Create both sockets externally
|
||||
const udpSocket = dgram.createSocket('udp4');
|
||||
const httpsServer = https.createServer({ key: cert.key, cert: cert.cert });
|
||||
|
||||
udpSocket.bind(53, '0.0.0.0');
|
||||
httpsServer.listen(443, '0.0.0.0');
|
||||
|
||||
const dnsServer = new DnsServer({
|
||||
udpSocket: udpSocket,
|
||||
httpsServer: httpsServer,
|
||||
manualMode: true,
|
||||
dnssecZone: 'example.com'
|
||||
});
|
||||
|
||||
await dnsServer.start(); // Only attaches handlers, no socket creation
|
||||
```
|
||||
|
||||
### Socket Pooling Example
|
||||
```typescript
|
||||
// Shared socket pool
|
||||
const socketPool = {
|
||||
udp: dgram.createSocket('udp4'),
|
||||
https: https.createServer(sslOptions)
|
||||
};
|
||||
|
||||
// Multiple DNS servers sharing sockets
|
||||
const server1 = new DnsServer({
|
||||
udpSocket: socketPool.udp,
|
||||
httpsServer: socketPool.https,
|
||||
manualMode: true,
|
||||
dnssecZone: 'zone1.com'
|
||||
});
|
||||
|
||||
const server2 = new DnsServer({
|
||||
udpSocket: socketPool.udp,
|
||||
httpsServer: socketPool.https,
|
||||
manualMode: true,
|
||||
dnssecZone: 'zone2.com'
|
||||
});
|
||||
```
|
||||
|
||||
## Implementation Details
|
||||
|
||||
### New Interface Properties
|
||||
```typescript
|
||||
export interface IDnsServerOptions {
|
||||
// Existing properties...
|
||||
httpsKey: string;
|
||||
httpsCert: string;
|
||||
httpsPort: number;
|
||||
udpPort: number;
|
||||
dnssecZone: string;
|
||||
udpBindInterface?: string;
|
||||
httpsBindInterface?: string;
|
||||
|
||||
// New manual socket properties
|
||||
udpSocket?: plugins.dgram.Socket;
|
||||
httpsServer?: plugins.https.Server;
|
||||
manualMode?: boolean;
|
||||
}
|
||||
```
|
||||
|
||||
### Modified Constructor Logic
|
||||
```typescript
|
||||
constructor(private options: IDnsServerOptions) {
|
||||
// Existing DNSSEC initialization...
|
||||
|
||||
// Handle manual sockets
|
||||
if (options.manualMode) {
|
||||
if (options.udpSocket) {
|
||||
this.udpServer = options.udpSocket;
|
||||
}
|
||||
if (options.httpsServer) {
|
||||
this.httpsServer = options.httpsServer;
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Updated start() Method
|
||||
```typescript
|
||||
public async start(): Promise<void> {
|
||||
// Manual socket mode handling
|
||||
if (this.options.manualMode) {
|
||||
await this.startManualMode();
|
||||
} else {
|
||||
await this.startAutomaticMode();
|
||||
}
|
||||
}
|
||||
|
||||
private async startManualMode(): Promise<void> {
|
||||
if (this.udpServer) {
|
||||
this.attachUdpHandlers();
|
||||
}
|
||||
if (this.httpsServer) {
|
||||
this.attachHttpsHandlers();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Files to Modify
|
||||
1. `ts_server/classes.dnsserver.ts` - Core implementation
|
||||
2. `test/test.server.ts` - Add manual socket tests
|
||||
3. `readme.md` - Documentation updates with examples
|
||||
|
||||
## Testing Strategy
|
||||
- Unit tests for manual socket validation
|
||||
- Integration tests for mixed manual/automatic mode
|
||||
- Socket lifecycle tests (start/stop behavior)
|
||||
- Error handling tests for invalid socket states
|
||||
- Performance tests comparing manual vs automatic modes
|
||||
|
||||
## Migration Path
|
||||
- Feature is completely backwards compatible
|
||||
- Existing code continues to work unchanged
|
||||
- New `manualMode` flag clearly indicates intent
|
||||
- Gradual adoption possible (UDP manual, HTTPS automatic, etc.)
|
||||
|
||||
## Security Considerations
|
||||
- Validate provided sockets are properly configured
|
||||
- Ensure manual sockets have appropriate permissions
|
||||
- Document security implications of socket sharing
|
||||
- Provide guidance on proper socket isolation
|
||||
|
||||
This enhancement enables advanced DNS server deployments while maintaining full backwards compatibility with existing implementations.
|
||||
78
test/test.client.ts
Normal file
78
test/test.client.ts
Normal file
@ -0,0 +1,78 @@
|
||||
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
||||
|
||||
import * as smartdns from '../ts_client/index.js';
|
||||
|
||||
let testDnsClient: smartdns.Smartdns;
|
||||
|
||||
tap.test('should create an instance of Dnsly', async () => {
|
||||
testDnsClient = new smartdns.Smartdns({});
|
||||
expect(testDnsClient).toBeInstanceOf(smartdns.Smartdns);
|
||||
});
|
||||
|
||||
tap.test('should get an A DNS Record', async () => {
|
||||
const records = await testDnsClient.getRecordsA('google.com');
|
||||
expect(records).toBeInstanceOf(Array);
|
||||
expect(records.length).toBeGreaterThan(0);
|
||||
expect(records[0]).toHaveProperty('name', 'google.com');
|
||||
expect(records[0]).toHaveProperty('type', 'A');
|
||||
expect(records[0]).toHaveProperty('value');
|
||||
expect(records[0]).toHaveProperty('dnsSecEnabled');
|
||||
});
|
||||
|
||||
tap.test('should get an AAAA Record', async () => {
|
||||
const records = await testDnsClient.getRecordsAAAA('google.com');
|
||||
expect(records).toBeInstanceOf(Array);
|
||||
expect(records.length).toBeGreaterThan(0);
|
||||
expect(records[0]).toHaveProperty('name', 'google.com');
|
||||
expect(records[0]).toHaveProperty('type', 'AAAA');
|
||||
expect(records[0]).toHaveProperty('value');
|
||||
expect(records[0]).toHaveProperty('dnsSecEnabled');
|
||||
});
|
||||
|
||||
tap.test('should get a txt record', async () => {
|
||||
const records = await testDnsClient.getRecordsTxt('google.com');
|
||||
expect(records).toBeInstanceOf(Array);
|
||||
expect(records.length).toBeGreaterThan(0);
|
||||
expect(records[0]).toHaveProperty('name', 'google.com');
|
||||
expect(records[0]).toHaveProperty('type', 'TXT');
|
||||
expect(records[0]).toHaveProperty('value');
|
||||
expect(records[0]).toHaveProperty('dnsSecEnabled');
|
||||
});
|
||||
|
||||
tap.test('should, get a mx record for a domain', async () => {
|
||||
const res = await testDnsClient.getRecords('bleu.de', 'MX');
|
||||
console.log(res);
|
||||
});
|
||||
|
||||
tap.test('should check until DNS is available', async () => {
|
||||
const records = await testDnsClient.getRecordsTxt('google.com');
|
||||
if (records.length > 0) {
|
||||
const result = await testDnsClient.checkUntilAvailable('google.com', 'TXT', records[0].value);
|
||||
expect(result).toBeTrue();
|
||||
}
|
||||
});
|
||||
|
||||
tap.test('should check until DNS is available an return false if it fails', async () => {
|
||||
return expect(
|
||||
await testDnsClient.checkUntilAvailable('google.com', 'TXT', 'this-txt-record-does-not-exist')
|
||||
).toBeFalse();
|
||||
});
|
||||
|
||||
tap.test('should check until DNS is available an return false if it fails', async () => {
|
||||
return expect(
|
||||
await testDnsClient.checkUntilAvailable('nonexistent.example.com', 'TXT', 'sometext_txt2')
|
||||
).toBeFalse();
|
||||
});
|
||||
|
||||
tap.test('should get name server for hostname', async () => {
|
||||
let result = await testDnsClient.getNameServers('bleu.de');
|
||||
console.log(result);
|
||||
});
|
||||
|
||||
tap.test('should detect dns sec', async () => {
|
||||
const result = await testDnsClient.getRecordsA('lossless.com');
|
||||
console.log(result[0]);
|
||||
expect(result[0].dnsSecEnabled).toBeTrue();
|
||||
});
|
||||
|
||||
export default tap.start();
|
||||
778
test/test.server.ts
Normal file
778
test/test.server.ts
Normal file
@ -0,0 +1,778 @@
|
||||
import * as plugins from '../ts_server/plugins.js';
|
||||
import { expect, tap } from '@git.zone/tstest/tapbundle';
|
||||
import { tapNodeTools } from '@git.zone/tstest/tapbundle_node';
|
||||
import { execSync } from 'child_process';
|
||||
|
||||
import * as dnsPacket from 'dns-packet';
|
||||
import * as https from 'https';
|
||||
import * as dgram from 'dgram';
|
||||
import * as fs from 'fs';
|
||||
import * as path from 'path';
|
||||
import * as os from 'os';
|
||||
|
||||
import * as smartdns from '../ts_server/index.js';
|
||||
|
||||
// Generate a real self-signed certificate using OpenSSL
|
||||
function generateSelfSignedCert() {
|
||||
const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cert-'));
|
||||
const keyPath = path.join(tmpDir, 'key.pem');
|
||||
const certPath = path.join(tmpDir, 'cert.pem');
|
||||
|
||||
try {
|
||||
// Generate private key
|
||||
execSync(`openssl genrsa -out "${keyPath}" 2048`);
|
||||
|
||||
// Generate self-signed certificate
|
||||
execSync(
|
||||
`openssl req -new -x509 -key "${keyPath}" -out "${certPath}" -days 365 -subj "/C=US/ST=State/L=City/O=Organization/CN=test.example.com"`
|
||||
);
|
||||
|
||||
// Read the files
|
||||
const privateKey = fs.readFileSync(keyPath, 'utf8');
|
||||
const cert = fs.readFileSync(certPath, 'utf8');
|
||||
|
||||
return { key: privateKey, cert };
|
||||
} catch (error) {
|
||||
console.error('Error generating certificate:', error);
|
||||
throw error;
|
||||
} finally {
|
||||
// Clean up temporary files
|
||||
try {
|
||||
if (fs.existsSync(keyPath)) fs.unlinkSync(keyPath);
|
||||
if (fs.existsSync(certPath)) fs.unlinkSync(certPath);
|
||||
if (fs.existsSync(tmpDir)) fs.rmdirSync(tmpDir);
|
||||
} catch (err) {
|
||||
console.error('Error cleaning up temporary files:', err);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Cache the generated certificate for performance
|
||||
let cachedCert = null;
|
||||
|
||||
// Helper function to get certificate
|
||||
function getTestCertificate() {
|
||||
if (!cachedCert) {
|
||||
cachedCert = generateSelfSignedCert();
|
||||
}
|
||||
return cachedCert;
|
||||
}
|
||||
|
||||
// Mock for acme-client directly imported as a module
|
||||
const acmeClientMock = {
|
||||
Client: class {
|
||||
constructor() {}
|
||||
|
||||
createAccount() {
|
||||
return Promise.resolve({});
|
||||
}
|
||||
|
||||
createOrder() {
|
||||
return Promise.resolve({
|
||||
authorizations: ['auth1', 'auth2']
|
||||
});
|
||||
}
|
||||
|
||||
getAuthorizations() {
|
||||
return Promise.resolve([
|
||||
{
|
||||
identifier: { value: 'test.bleu.de' },
|
||||
challenges: [
|
||||
{ type: 'dns-01', url: 'https://example.com/challenge' }
|
||||
]
|
||||
}
|
||||
]);
|
||||
}
|
||||
|
||||
getChallengeKeyAuthorization() {
|
||||
return Promise.resolve('test_key_authorization');
|
||||
}
|
||||
|
||||
completeChallenge() {
|
||||
return Promise.resolve({});
|
||||
}
|
||||
|
||||
waitForValidStatus() {
|
||||
return Promise.resolve({});
|
||||
}
|
||||
|
||||
finalizeOrder() {
|
||||
return Promise.resolve({});
|
||||
}
|
||||
|
||||
getCertificate() {
|
||||
// Use a real certificate
|
||||
const { cert } = getTestCertificate();
|
||||
return Promise.resolve(cert);
|
||||
}
|
||||
},
|
||||
|
||||
forge: {
|
||||
createCsr({commonName, altNames}) {
|
||||
return Promise.resolve({
|
||||
csr: Buffer.from('mock-csr-data')
|
||||
});
|
||||
}
|
||||
},
|
||||
|
||||
directory: {
|
||||
letsencrypt: {
|
||||
staging: 'https://acme-staging-v02.api.letsencrypt.org/directory',
|
||||
production: 'https://acme-v02.api.letsencrypt.org/directory'
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Override generateKeyPairSync to use our test key for certificate generation in tests
|
||||
const originalGenerateKeyPairSync = plugins.crypto.generateKeyPairSync;
|
||||
plugins.crypto.generateKeyPairSync = function(type, options) {
|
||||
if (type === 'rsa' &&
|
||||
options?.modulusLength === 2048 &&
|
||||
options?.privateKeyEncoding?.type === 'pkcs8') {
|
||||
|
||||
// Get the test certificate key if we're in the retrieveSslCertificate method
|
||||
try {
|
||||
const stack = new Error().stack || '';
|
||||
if (stack.includes('retrieveSslCertificate')) {
|
||||
const { key } = getTestCertificate();
|
||||
return { privateKey: key, publicKey: 'TEST_PUBLIC_KEY' };
|
||||
}
|
||||
} catch (e) {
|
||||
// Fall back to original function if error occurs
|
||||
}
|
||||
}
|
||||
|
||||
// Use the original function for other cases
|
||||
return originalGenerateKeyPairSync.apply(this, arguments);
|
||||
};
|
||||
|
||||
let dnsServer: smartdns.DnsServer;
|
||||
const testCertDir = path.join(process.cwd(), 'test-certs');
|
||||
|
||||
// Helper to clean up test certificate directory
|
||||
function cleanCertDir() {
|
||||
if (fs.existsSync(testCertDir)) {
|
||||
const files = fs.readdirSync(testCertDir);
|
||||
for (const file of files) {
|
||||
fs.unlinkSync(path.join(testCertDir, file));
|
||||
}
|
||||
fs.rmdirSync(testCertDir);
|
||||
}
|
||||
}
|
||||
|
||||
// Port management for tests
|
||||
let nextHttpsPort = 8080;
|
||||
let nextUdpPort = 8081;
|
||||
|
||||
function getUniqueHttpsPort() {
|
||||
return nextHttpsPort++;
|
||||
}
|
||||
|
||||
function getUniqueUdpPort() {
|
||||
return nextUdpPort++;
|
||||
}
|
||||
|
||||
// Cleanup function for servers - more robust implementation
|
||||
async function stopServer(server: smartdns.DnsServer | null | undefined) {
|
||||
if (!server) {
|
||||
return; // Nothing to do if server doesn't exist
|
||||
}
|
||||
|
||||
try {
|
||||
// Set a timeout for stop operation
|
||||
const stopPromise = server.stop();
|
||||
const timeoutPromise = new Promise((_, reject) => {
|
||||
setTimeout(() => reject(new Error('Stop operation timed out')), 5000);
|
||||
});
|
||||
|
||||
await Promise.race([stopPromise, timeoutPromise]);
|
||||
} catch (e) {
|
||||
console.log('Handled error when stopping server:', e.message || e);
|
||||
|
||||
// Force close if normal stop fails
|
||||
try {
|
||||
// @ts-ignore - accessing private properties for emergency cleanup
|
||||
if (server.httpsServer) {
|
||||
server.httpsServer.close();
|
||||
server.httpsServer = null;
|
||||
}
|
||||
// @ts-ignore - accessing private properties for emergency cleanup
|
||||
if (server.udpServer) {
|
||||
server.udpServer.close();
|
||||
server.udpServer = null;
|
||||
}
|
||||
} catch (forceError) {
|
||||
console.log('Force cleanup error:', forceError.message || forceError);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Setup and teardown
|
||||
tap.test('setup', async () => {
|
||||
cleanCertDir();
|
||||
// Reset dnsServer to null at the start
|
||||
dnsServer = null;
|
||||
// Reset certificate cache
|
||||
cachedCert = null;
|
||||
});
|
||||
|
||||
tap.test('teardown', async () => {
|
||||
// Stop the server if it exists
|
||||
await stopServer(dnsServer);
|
||||
dnsServer = null;
|
||||
|
||||
cleanCertDir();
|
||||
// Reset certificate cache
|
||||
cachedCert = null;
|
||||
});
|
||||
|
||||
tap.test('should create an instance of DnsServer', async () => {
|
||||
// Use valid options
|
||||
const httpsData = await tapNodeTools.createHttpsCert();
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: 8080,
|
||||
udpPort: 8081,
|
||||
dnssecZone: 'example.com',
|
||||
});
|
||||
expect(dnsServer).toBeInstanceOf(smartdns.DnsServer);
|
||||
});
|
||||
|
||||
tap.test('should start the server', async () => {
|
||||
// Clean up any existing server
|
||||
await stopServer(dnsServer);
|
||||
|
||||
const httpsData = await tapNodeTools.createHttpsCert();
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: getUniqueHttpsPort(),
|
||||
udpPort: getUniqueUdpPort(),
|
||||
dnssecZone: 'example.com',
|
||||
});
|
||||
|
||||
await dnsServer.start();
|
||||
// @ts-ignore - accessing private property for testing
|
||||
expect(dnsServer.httpsServer).toBeDefined();
|
||||
|
||||
// Stop the server at the end of this test
|
||||
await stopServer(dnsServer);
|
||||
dnsServer = null;
|
||||
});
|
||||
|
||||
tap.test('lets add a handler', async () => {
|
||||
const httpsData = await tapNodeTools.createHttpsCert();
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: 8080,
|
||||
udpPort: 8081,
|
||||
dnssecZone: 'example.com',
|
||||
});
|
||||
|
||||
dnsServer.registerHandler('*.bleu.de', ['A'], (question) => {
|
||||
return {
|
||||
name: question.name,
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: '127.0.0.1',
|
||||
};
|
||||
});
|
||||
|
||||
// @ts-ignore - accessing private method for testing
|
||||
const response = dnsServer.processDnsRequest({
|
||||
type: 'query',
|
||||
id: 1,
|
||||
flags: 0,
|
||||
questions: [
|
||||
{
|
||||
name: 'dnsly_a.bleu.de',
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
},
|
||||
],
|
||||
answers: [],
|
||||
});
|
||||
expect(response.answers[0]).toEqual({
|
||||
name: 'dnsly_a.bleu.de',
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: '127.0.0.1',
|
||||
});
|
||||
});
|
||||
|
||||
tap.test('should unregister a handler', async () => {
|
||||
const httpsData = await tapNodeTools.createHttpsCert();
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: 8080,
|
||||
udpPort: 8081,
|
||||
dnssecZone: 'example.com',
|
||||
});
|
||||
|
||||
// Register handlers
|
||||
dnsServer.registerHandler('*.bleu.de', ['A'], (question) => {
|
||||
return {
|
||||
name: question.name,
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: '127.0.0.1',
|
||||
};
|
||||
});
|
||||
|
||||
dnsServer.registerHandler('test.com', ['TXT'], (question) => {
|
||||
return {
|
||||
name: question.name,
|
||||
type: 'TXT',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: ['test'],
|
||||
};
|
||||
});
|
||||
|
||||
// Test unregistering
|
||||
const result = dnsServer.unregisterHandler('*.bleu.de', ['A']);
|
||||
expect(result).toEqual(true);
|
||||
|
||||
// Verify handler is removed
|
||||
// @ts-ignore - accessing private method for testing
|
||||
const response = dnsServer.processDnsRequest({
|
||||
type: 'query',
|
||||
id: 1,
|
||||
flags: 0,
|
||||
questions: [
|
||||
{
|
||||
name: 'dnsly_a.bleu.de',
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
},
|
||||
],
|
||||
answers: [],
|
||||
});
|
||||
|
||||
// Should get SOA record instead of A record
|
||||
expect(response.answers[0].type).toEqual('SOA');
|
||||
});
|
||||
|
||||
tap.test('lets query over https', async () => {
|
||||
// Clean up any existing server
|
||||
await stopServer(dnsServer);
|
||||
|
||||
const httpsPort = getUniqueHttpsPort();
|
||||
const httpsData = await tapNodeTools.createHttpsCert();
|
||||
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: httpsPort,
|
||||
udpPort: getUniqueUdpPort(),
|
||||
dnssecZone: 'example.com',
|
||||
});
|
||||
|
||||
await dnsServer.start();
|
||||
|
||||
dnsServer.registerHandler('*.bleu.de', ['A'], (question) => {
|
||||
return {
|
||||
name: question.name,
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: '127.0.0.1',
|
||||
};
|
||||
});
|
||||
|
||||
// Skip SSL verification for self-signed cert in tests
|
||||
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
|
||||
|
||||
const query = dnsPacket.encode({
|
||||
type: 'query',
|
||||
id: 2,
|
||||
flags: dnsPacket.RECURSION_DESIRED,
|
||||
questions: [
|
||||
{
|
||||
name: 'dnsly_a.bleu.de',
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
const response = await fetch(`https://localhost:${httpsPort}/dns-query`, {
|
||||
method: 'POST',
|
||||
body: query,
|
||||
headers: {
|
||||
'Content-Type': 'application/dns-message',
|
||||
}
|
||||
});
|
||||
|
||||
expect(response.status).toEqual(200);
|
||||
|
||||
const responseData = await response.arrayBuffer();
|
||||
const dnsResponse = dnsPacket.decode(Buffer.from(responseData));
|
||||
|
||||
console.log(dnsResponse.answers[0]);
|
||||
|
||||
expect(dnsResponse.answers[0]).toEqual({
|
||||
name: 'dnsly_a.bleu.de',
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
flush: false,
|
||||
data: '127.0.0.1',
|
||||
});
|
||||
|
||||
// Reset TLS verification
|
||||
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '1';
|
||||
|
||||
// Clean up server
|
||||
await stopServer(dnsServer);
|
||||
dnsServer = null;
|
||||
});
|
||||
|
||||
tap.test('lets query over udp', async () => {
|
||||
// Clean up any existing server
|
||||
await stopServer(dnsServer);
|
||||
|
||||
const udpPort = getUniqueUdpPort();
|
||||
const httpsData = await tapNodeTools.createHttpsCert();
|
||||
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: getUniqueHttpsPort(),
|
||||
udpPort: udpPort,
|
||||
dnssecZone: 'example.com',
|
||||
});
|
||||
|
||||
await dnsServer.start();
|
||||
|
||||
dnsServer.registerHandler('*.bleu.de', ['A'], (question) => {
|
||||
return {
|
||||
name: question.name,
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
data: '127.0.0.1',
|
||||
};
|
||||
});
|
||||
|
||||
const client = dgram.createSocket('udp4');
|
||||
|
||||
const query = dnsPacket.encode({
|
||||
type: 'query',
|
||||
id: 3,
|
||||
flags: dnsPacket.RECURSION_DESIRED,
|
||||
questions: [
|
||||
{
|
||||
name: 'dnsly_a.bleu.de',
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
},
|
||||
],
|
||||
});
|
||||
|
||||
const responsePromise = new Promise<dnsPacket.Packet>((resolve, reject) => {
|
||||
client.on('message', (msg) => {
|
||||
const dnsResponse = dnsPacket.decode(msg);
|
||||
resolve(dnsResponse);
|
||||
client.close();
|
||||
});
|
||||
|
||||
client.on('error', (err) => {
|
||||
reject(err);
|
||||
client.close();
|
||||
});
|
||||
|
||||
client.send(query, udpPort, 'localhost', (err) => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
client.close();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
const dnsResponse = await responsePromise;
|
||||
|
||||
console.log(dnsResponse.answers[0]);
|
||||
|
||||
expect(dnsResponse.answers[0]).toEqual({
|
||||
name: 'dnsly_a.bleu.de',
|
||||
type: 'A',
|
||||
class: 'IN',
|
||||
ttl: 300,
|
||||
flush: false,
|
||||
data: '127.0.0.1',
|
||||
});
|
||||
|
||||
// Clean up server
|
||||
await stopServer(dnsServer);
|
||||
dnsServer = null;
|
||||
});
|
||||
|
||||
tap.test('should filter authorized domains correctly', async () => {
|
||||
const httpsData = await tapNodeTools.createHttpsCert();
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: 8080,
|
||||
udpPort: 8081,
|
||||
dnssecZone: 'example.com',
|
||||
});
|
||||
|
||||
// Register handlers for specific domains
|
||||
dnsServer.registerHandler('*.bleu.de', ['A'], () => null);
|
||||
dnsServer.registerHandler('test.com', ['A'], () => null);
|
||||
|
||||
// Test filtering authorized domains
|
||||
const authorizedDomains = dnsServer.filterAuthorizedDomains([
|
||||
'test.com', // Should be authorized
|
||||
'sub.test.com', // Should not be authorized
|
||||
'*.bleu.de', // Pattern itself isn't a domain
|
||||
'something.bleu.de', // Should be authorized via wildcard pattern
|
||||
'example.com', // Should be authorized (dnssecZone)
|
||||
'sub.example.com', // Should be authorized (within dnssecZone)
|
||||
'othersite.org' // Should not be authorized
|
||||
]);
|
||||
|
||||
// Using toContain with expect from tapbundle
|
||||
expect(authorizedDomains.includes('test.com')).toEqual(true);
|
||||
expect(authorizedDomains.includes('something.bleu.de')).toEqual(true);
|
||||
expect(authorizedDomains.includes('example.com')).toEqual(true);
|
||||
expect(authorizedDomains.includes('sub.example.com')).toEqual(true);
|
||||
|
||||
expect(authorizedDomains.includes('sub.test.com')).toEqual(false);
|
||||
expect(authorizedDomains.includes('*.bleu.de')).toEqual(false);
|
||||
expect(authorizedDomains.includes('othersite.org')).toEqual(false);
|
||||
});
|
||||
|
||||
tap.test('should retrieve SSL certificate successfully', async () => {
|
||||
// Clean up any existing server
|
||||
await stopServer(dnsServer);
|
||||
|
||||
// Create a temporary directory for the certificate test
|
||||
const tempCertDir = path.join(process.cwd(), 'temp-certs');
|
||||
if (!fs.existsSync(tempCertDir)) {
|
||||
fs.mkdirSync(tempCertDir, { recursive: true });
|
||||
}
|
||||
|
||||
// Create a server with unique ports
|
||||
const httpsData = await tapNodeTools.createHttpsCert();
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: getUniqueHttpsPort(),
|
||||
udpPort: getUniqueUdpPort(),
|
||||
dnssecZone: 'example.com',
|
||||
});
|
||||
|
||||
// Register handlers for test domains
|
||||
dnsServer.registerHandler('*.bleu.de', ['A'], () => null);
|
||||
dnsServer.registerHandler('test.bleu.de', ['A'], () => null);
|
||||
|
||||
await dnsServer.start();
|
||||
|
||||
// Inject our mock for acme-client
|
||||
(dnsServer as any).acmeClientOverride = acmeClientMock;
|
||||
|
||||
try {
|
||||
// Request certificate for domains
|
||||
const result = await dnsServer.retrieveSslCertificate(
|
||||
['test.bleu.de', '*.bleu.de', 'unknown.org'],
|
||||
{
|
||||
email: 'test@example.com',
|
||||
staging: true,
|
||||
certDir: tempCertDir
|
||||
}
|
||||
);
|
||||
|
||||
console.log('Certificate retrieval result:', {
|
||||
success: result.success,
|
||||
certLength: result.cert.length,
|
||||
keyLength: result.key.length,
|
||||
});
|
||||
|
||||
expect(result.success).toEqual(true);
|
||||
expect(result.cert.includes('BEGIN CERTIFICATE')).toEqual(true);
|
||||
expect(typeof result.key === 'string').toEqual(true);
|
||||
|
||||
// Check that certificate directory was created
|
||||
expect(fs.existsSync(tempCertDir)).toEqual(true);
|
||||
|
||||
// Verify TXT record handler was registered and then removed
|
||||
// @ts-ignore - accessing private property for testing
|
||||
const txtHandlerCount = dnsServer.handlers.filter(h =>
|
||||
h.domainPattern.includes('_acme-challenge') &&
|
||||
h.recordTypes.includes('TXT')
|
||||
).length;
|
||||
|
||||
expect(txtHandlerCount).toEqual(0); // Should be removed after validation
|
||||
} catch (err) {
|
||||
console.error('Test error:', err);
|
||||
throw err;
|
||||
} finally {
|
||||
// Clean up server and temporary cert directory
|
||||
await stopServer(dnsServer);
|
||||
dnsServer = null;
|
||||
|
||||
if (fs.existsSync(tempCertDir)) {
|
||||
const files = fs.readdirSync(tempCertDir);
|
||||
for (const file of files) {
|
||||
fs.unlinkSync(path.join(tempCertDir, file));
|
||||
}
|
||||
fs.rmdirSync(tempCertDir);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
tap.test('should run for a while', async (toolsArg) => {
|
||||
await toolsArg.delayFor(1000);
|
||||
});
|
||||
|
||||
tap.test('should bind to localhost interface only', async () => {
|
||||
// Clean up any existing server
|
||||
await stopServer(dnsServer);
|
||||
|
||||
const httpsData = await tapNodeTools.createHttpsCert();
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: getUniqueHttpsPort(),
|
||||
udpPort: getUniqueUdpPort(),
|
||||
dnssecZone: 'example.com',
|
||||
udpBindInterface: '127.0.0.1',
|
||||
httpsBindInterface: '127.0.0.1'
|
||||
});
|
||||
|
||||
// Add timeout to start operation
|
||||
const startPromise = dnsServer.start();
|
||||
const timeoutPromise = new Promise((_, reject) => {
|
||||
setTimeout(() => reject(new Error('Start operation timed out')), 10000);
|
||||
});
|
||||
|
||||
await Promise.race([startPromise, timeoutPromise]);
|
||||
|
||||
// @ts-ignore - accessing private property for testing
|
||||
expect(dnsServer.httpsServer).toBeDefined();
|
||||
// @ts-ignore - accessing private property for testing
|
||||
expect(dnsServer.udpServer).toBeDefined();
|
||||
|
||||
await stopServer(dnsServer);
|
||||
dnsServer = null;
|
||||
});
|
||||
|
||||
tap.test('should reject invalid IP addresses', async () => {
|
||||
const httpsData = await tapNodeTools.createHttpsCert();
|
||||
|
||||
// Test invalid UDP interface
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: getUniqueHttpsPort(),
|
||||
udpPort: getUniqueUdpPort(),
|
||||
dnssecZone: 'example.com',
|
||||
udpBindInterface: 'invalid-ip',
|
||||
});
|
||||
|
||||
let error1 = null;
|
||||
try {
|
||||
await dnsServer.start();
|
||||
} catch (err) {
|
||||
error1 = err;
|
||||
}
|
||||
|
||||
expect(error1).toBeDefined();
|
||||
expect(error1.message).toContain('Invalid UDP bind interface');
|
||||
|
||||
// Test invalid HTTPS interface
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: getUniqueHttpsPort(),
|
||||
udpPort: getUniqueUdpPort(),
|
||||
dnssecZone: 'example.com',
|
||||
httpsBindInterface: '999.999.999.999',
|
||||
});
|
||||
|
||||
let error2 = null;
|
||||
try {
|
||||
await dnsServer.start();
|
||||
} catch (err) {
|
||||
error2 = err;
|
||||
}
|
||||
|
||||
expect(error2).toBeDefined();
|
||||
expect(error2.message).toContain('Invalid HTTPS bind interface');
|
||||
|
||||
dnsServer = null;
|
||||
});
|
||||
|
||||
tap.test('should work with IPv6 localhost if available', async () => {
|
||||
// Clean up any existing server
|
||||
await stopServer(dnsServer);
|
||||
|
||||
// Skip IPv6 test if not supported
|
||||
try {
|
||||
const testSocket = require('dgram').createSocket('udp6');
|
||||
testSocket.bind(0, '::1');
|
||||
testSocket.close();
|
||||
} catch (err) {
|
||||
console.log('IPv6 not supported in this environment, skipping test');
|
||||
return;
|
||||
}
|
||||
|
||||
const httpsData = await tapNodeTools.createHttpsCert();
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: getUniqueHttpsPort(),
|
||||
udpPort: getUniqueUdpPort(),
|
||||
dnssecZone: 'example.com',
|
||||
udpBindInterface: '::1',
|
||||
httpsBindInterface: '::1'
|
||||
});
|
||||
|
||||
try {
|
||||
await dnsServer.start();
|
||||
|
||||
// @ts-ignore - accessing private property for testing
|
||||
expect(dnsServer.httpsServer).toBeDefined();
|
||||
|
||||
await stopServer(dnsServer);
|
||||
} catch (err) {
|
||||
console.log('IPv6 binding failed:', err.message);
|
||||
await stopServer(dnsServer);
|
||||
throw err;
|
||||
}
|
||||
|
||||
dnsServer = null;
|
||||
});
|
||||
|
||||
tap.test('should stop the server', async () => {
|
||||
// Clean up any existing server
|
||||
await stopServer(dnsServer);
|
||||
|
||||
const httpsData = await tapNodeTools.createHttpsCert();
|
||||
dnsServer = new smartdns.DnsServer({
|
||||
httpsKey: httpsData.key,
|
||||
httpsCert: httpsData.cert,
|
||||
httpsPort: getUniqueHttpsPort(),
|
||||
udpPort: getUniqueUdpPort(),
|
||||
dnssecZone: 'example.com',
|
||||
});
|
||||
|
||||
await dnsServer.start();
|
||||
await dnsServer.stop();
|
||||
|
||||
// @ts-ignore - accessing private property for testing
|
||||
expect(dnsServer.httpsServer).toEqual(null);
|
||||
|
||||
// Clear the reference
|
||||
dnsServer = null;
|
||||
});
|
||||
|
||||
export default tap.start();
|
||||
76
test/test.ts
76
test/test.ts
@ -1,76 +0,0 @@
|
||||
import { expect, tap } from '@pushrocks/tapbundle';
|
||||
|
||||
import * as smartdns from '../ts/index';
|
||||
|
||||
let testDnsly: smartdns.Smartdns;
|
||||
|
||||
tap.test('should create an instance of Dnsly', async () => {
|
||||
testDnsly = new smartdns.Smartdns({});
|
||||
expect(testDnsly).to.be.instanceOf(smartdns.Smartdns);
|
||||
});
|
||||
|
||||
tap.test('should get an A DNS Record', async () => {
|
||||
return expect(testDnsly.getRecordA('dnsly_a.bleu.de')).to.eventually.deep.equal([
|
||||
{
|
||||
name: 'dnsly_a.bleu.de',
|
||||
value: '127.0.0.1',
|
||||
dnsSecEnabled: false,
|
||||
type: 'A',
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
tap.test('should get an AAAA Record', async () => {
|
||||
return expect(testDnsly.getRecordAAAA('dnsly_aaaa.bleu.de')).to.eventually.deep.equal([
|
||||
{
|
||||
name: 'dnsly_aaaa.bleu.de',
|
||||
value: '::1',
|
||||
dnsSecEnabled: false,
|
||||
type: 'AAAA',
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
tap.test('should get a txt record', async () => {
|
||||
return expect(testDnsly.getRecordTxt('dnsly_txt.bleu.de')).to.eventually.deep.equal([
|
||||
{
|
||||
name: 'dnsly_txt.bleu.de',
|
||||
value: 'sometext_txt',
|
||||
type: 'TXT',
|
||||
dnsSecEnabled: false,
|
||||
},
|
||||
]);
|
||||
});
|
||||
|
||||
tap.test('should, get a mx record for a domain', async () => {
|
||||
const res = await testDnsly.getRecord('bleu.de', 'MX');
|
||||
console.log(res);
|
||||
});
|
||||
|
||||
tap.test('should check until DNS is available', async () => {
|
||||
return expect(testDnsly.checkUntilAvailable('dnsly_txt.bleu.de', 'TXT', 'sometext_txt')).to
|
||||
.eventually.be.true;
|
||||
});
|
||||
|
||||
tap.test('should check until DNS is available an return false if it fails', async () => {
|
||||
return expect(testDnsly.checkUntilAvailable('dnsly_txt.bleu.de', 'TXT', 'sometext_txt2')).to
|
||||
.eventually.be.false;
|
||||
});
|
||||
|
||||
tap.test('should check until DNS is available an return false if it fails', async () => {
|
||||
return expect(testDnsly.checkUntilAvailable('dnsly_txtNotThere.bleu.de', 'TXT', 'sometext_txt2'))
|
||||
.to.eventually.be.false;
|
||||
});
|
||||
|
||||
tap.test('should get name server for hostname', async () => {
|
||||
let result = await testDnsly.getNameServer('bleu.de');
|
||||
console.log(result);
|
||||
});
|
||||
|
||||
tap.test('should detect dns sec', async () => {
|
||||
const result = await testDnsly.getRecordA('lossless.com');
|
||||
console.log(result[0]);
|
||||
expect(result[0].dnsSecEnabled).to.be.true;
|
||||
});
|
||||
|
||||
tap.start();
|
||||
8
ts/00_commitinfo_data.ts
Normal file
8
ts/00_commitinfo_data.ts
Normal file
@ -0,0 +1,8 @@
|
||||
/**
|
||||
* autocreated commitinfo by @push.rocks/commitinfo
|
||||
*/
|
||||
export const commitinfo = {
|
||||
name: '@push.rocks/smartdns',
|
||||
version: '7.2.0',
|
||||
description: 'A robust TypeScript library providing advanced DNS management and resolution capabilities including support for DNSSEC, custom DNS servers, and integration with various DNS providers.'
|
||||
}
|
||||
@ -1,15 +0,0 @@
|
||||
// node native scope
|
||||
import * as dns from 'dns';
|
||||
|
||||
export { dns };
|
||||
|
||||
// pushrocks scope
|
||||
import * as smartdelay from '@pushrocks/smartdelay';
|
||||
import * as smartpromise from '@pushrocks/smartpromise';
|
||||
import * as smartrequest from '@pushrocks/smartrequest';
|
||||
|
||||
export { smartdelay, smartpromise, smartrequest };
|
||||
|
||||
import * as tsclass from '@tsclass/tsclass';
|
||||
|
||||
export { tsclass };
|
||||
215
ts/index.ts
215
ts/index.ts
@ -1,213 +1,4 @@
|
||||
import * as plugins from './dnsly.plugins';
|
||||
import * as dnsClientMod from '../dist_ts_client/index.js';
|
||||
import * as dnsServerMod from '../dist_ts_server/index.js';
|
||||
|
||||
export type TDnsProvider = 'google' | 'cloudflare';
|
||||
|
||||
export interface ISmartDnsConstructorOptions {}
|
||||
|
||||
export interface IGoogleDNSHTTPSResponse {
|
||||
Status: number;
|
||||
TC: boolean;
|
||||
RD: boolean;
|
||||
RA: boolean;
|
||||
AD: boolean;
|
||||
CD: boolean;
|
||||
Question: Array<{ name: string; type: number }>;
|
||||
Answer: Array<{ name: string; type: number; TTL: number; data: string }>;
|
||||
Additional: [];
|
||||
Comment: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* class dnsly offers methods for working with dns from a dns provider like Google DNS
|
||||
*/
|
||||
export class Smartdns {
|
||||
public dnsServerIp: string;
|
||||
public dnsServerPort: number;
|
||||
|
||||
public dnsTypeMap: { [key: string]: number } = {
|
||||
A: 1,
|
||||
AAAA: 28,
|
||||
CNAME: 5,
|
||||
MX: 15,
|
||||
TXT: 16,
|
||||
};
|
||||
|
||||
/**
|
||||
* constructor for class dnsly
|
||||
*/
|
||||
constructor(optionsArg: ISmartDnsConstructorOptions) {}
|
||||
|
||||
/**
|
||||
* check a dns record until it has propagated to Google DNS
|
||||
* should be considerably fast
|
||||
* @param recordNameArg
|
||||
* @param recordTypeArg
|
||||
* @param expectedValue
|
||||
*/
|
||||
public async checkUntilAvailable(
|
||||
recordNameArg: string,
|
||||
recordTypeArg: plugins.tsclass.network.TDnsRecordType,
|
||||
expectedValue: string,
|
||||
cyclesArg: number = 50,
|
||||
intervalArg: number = 500
|
||||
) {
|
||||
let runCycles = 0;
|
||||
const doCheck = async () => {
|
||||
if (runCycles < cyclesArg) {
|
||||
runCycles++;
|
||||
try {
|
||||
const 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) {
|
||||
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
|
||||
*/
|
||||
public async getRecordA(recordNameArg: string): Promise<plugins.tsclass.network.IDnsRecord[]> {
|
||||
return await this.getRecord(recordNameArg, 'A');
|
||||
}
|
||||
|
||||
/**
|
||||
* get AAAA Record
|
||||
*/
|
||||
public async getRecordAAAA(recordNameArg: string) {
|
||||
return await this.getRecord(recordNameArg, 'AAAA');
|
||||
}
|
||||
|
||||
/**
|
||||
* gets a txt record
|
||||
*/
|
||||
public async getRecordTxt(recordNameArg: string): Promise<plugins.tsclass.network.IDnsRecord[]> {
|
||||
return await this.getRecord(recordNameArg, 'TXT');
|
||||
}
|
||||
|
||||
public async getRecord(
|
||||
recordNameArg: string,
|
||||
recordTypeArg: plugins.tsclass.network.TDnsRecordType
|
||||
): Promise<plugins.tsclass.network.IDnsRecord[]> {
|
||||
const requestUrl = `https://cloudflare-dns.com/dns-query?name=${recordNameArg}&type=${recordTypeArg}&do=1`;
|
||||
const response = await plugins.smartrequest.request(requestUrl, {
|
||||
method: 'GET',
|
||||
headers: {
|
||||
accept: 'application/dns-json',
|
||||
},
|
||||
});
|
||||
const returnArray: plugins.tsclass.network.IDnsRecord[] = [];
|
||||
const responseBody: IGoogleDNSHTTPSResponse = response.body;
|
||||
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
|
||||
*/
|
||||
public async getRecordWithNodeDNS(
|
||||
recordNameArg: string,
|
||||
recordTypeArg: plugins.tsclass.network.TDnsRecordType
|
||||
): Promise<plugins.tsclass.network.IDnsRecord[]> {
|
||||
this.setNodeDnsProvider('cloudflare');
|
||||
const done = plugins.smartpromise.defer<plugins.tsclass.network.IDnsRecord[]>();
|
||||
plugins.dns.resolve(recordNameArg, recordTypeArg, (err, recordsArg) => {
|
||||
if (err) {
|
||||
done.reject(err);
|
||||
return;
|
||||
}
|
||||
const returnArray: plugins.tsclass.network.IDnsRecord[] = [];
|
||||
for (const recordKey in recordsArg) {
|
||||
returnArray.push({
|
||||
name: recordNameArg,
|
||||
value: recordsArg[recordKey][0],
|
||||
type: recordTypeArg,
|
||||
dnsSecEnabled: false,
|
||||
});
|
||||
}
|
||||
done.resolve(returnArray);
|
||||
});
|
||||
return done.promise;
|
||||
}
|
||||
|
||||
public async getNameServer(domainNameArg: string): Promise<string[]> {
|
||||
const done = plugins.smartpromise.defer<string[]>();
|
||||
plugins.dns.resolveNs(domainNameArg, (err, result) => {
|
||||
if (!err) {
|
||||
done.resolve(result);
|
||||
} else {
|
||||
console.log(err);
|
||||
done.reject(err);
|
||||
}
|
||||
});
|
||||
return await done.promise;
|
||||
}
|
||||
|
||||
/**
|
||||
* set the DNS provider
|
||||
*/
|
||||
public setNodeDnsProvider(dnsProvider: TDnsProvider) {
|
||||
if (!this.dnsServerIp) {
|
||||
console.log(
|
||||
`Warning: Setting the nodejs dns authority to ${dnsProvider}. Only do this if you know what you are doing.`
|
||||
);
|
||||
}
|
||||
if (dnsProvider === 'google' && this.dnsServerIp !== '8.8.8.8') {
|
||||
this.dnsServerIp = '8.8.8.8';
|
||||
this.dnsServerPort = 53;
|
||||
plugins.dns.setServers(['8.8.8.8', '8.8.4.4']);
|
||||
} else if (dnsProvider === 'cloudflare' && this.dnsServerIp !== '1.1.1.1') {
|
||||
this.dnsServerIp = '1.1.1.1';
|
||||
this.dnsServerPort = 53;
|
||||
plugins.dns.setServers(['1.1.1.1', '1.0.0.1']);
|
||||
} else {
|
||||
throw new Error('unknown dns provider');
|
||||
}
|
||||
}
|
||||
|
||||
public convertDnsTypeNameToTypeNumber(dnsTypeNameArg: string): number {
|
||||
return this.dnsTypeMap[dnsTypeNameArg];
|
||||
}
|
||||
|
||||
public convertDnsTypeNumberToTypeName(
|
||||
dnsTypeNumberArg: number
|
||||
): plugins.tsclass.network.TDnsRecordType {
|
||||
for (const key in this.dnsTypeMap) {
|
||||
if (this.dnsTypeMap[key] === dnsTypeNumberArg) {
|
||||
return key as plugins.tsclass.network.TDnsRecordType;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
export { dnsClientMod, dnsServerMod };
|
||||
3
ts/tspublish.json
Normal file
3
ts/tspublish.json
Normal file
@ -0,0 +1,3 @@
|
||||
{
|
||||
"order": 3
|
||||
}
|
||||
8
ts_client/00_commitinfo_data.ts
Normal file
8
ts_client/00_commitinfo_data.ts
Normal file
@ -0,0 +1,8 @@
|
||||
/**
|
||||
* autocreated commitinfo by @push.rocks/commitinfo
|
||||
*/
|
||||
export const commitinfo = {
|
||||
name: '@push.rocks/smartdns',
|
||||
version: '5.0.4',
|
||||
description: 'smart dns methods written in TypeScript'
|
||||
}
|
||||
229
ts_client/classes.dnsclient.ts
Normal file
229
ts_client/classes.dnsclient.ts
Normal file
@ -0,0 +1,229 @@
|
||||
import * as plugins from './plugins.js';
|
||||
|
||||
export type TDnsProvider = 'google' | 'cloudflare';
|
||||
|
||||
export const makeNodeProcessUseDnsProvider = (providerArg: TDnsProvider) => {
|
||||
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]',
|
||||
]);
|
||||
}
|
||||
};
|
||||
|
||||
export interface ISmartDnsConstructorOptions {}
|
||||
|
||||
export interface IDnsJsonResponse {
|
||||
Status: number;
|
||||
TC: boolean;
|
||||
RD: boolean;
|
||||
RA: boolean;
|
||||
AD: boolean;
|
||||
CD: boolean;
|
||||
Question: Array<{ name: string; type: number }>;
|
||||
Answer: Array<{ name: string; type: number; TTL: number; data: string }>;
|
||||
Additional: [];
|
||||
Comment: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* class dnsly offers methods for working with dns from a dns provider like Google DNS
|
||||
*/
|
||||
export class Smartdns {
|
||||
public dnsServerIp: string;
|
||||
public dnsServerPort: number;
|
||||
|
||||
public dnsTypeMap: { [key: string]: number } = {
|
||||
A: 1,
|
||||
AAAA: 28,
|
||||
CNAME: 5,
|
||||
MX: 15,
|
||||
TXT: 16,
|
||||
};
|
||||
|
||||
/**
|
||||
* constructor for class dnsly
|
||||
*/
|
||||
constructor(optionsArg: ISmartDnsConstructorOptions) {}
|
||||
|
||||
/**
|
||||
* check a dns record until it has propagated to Google DNS
|
||||
* should be considerably fast
|
||||
* @param recordNameArg
|
||||
* @param recordTypeArg
|
||||
* @param expectedValue
|
||||
*/
|
||||
public async checkUntilAvailable(
|
||||
recordNameArg: string,
|
||||
recordTypeArg: plugins.tsclass.network.TDnsRecordType,
|
||||
expectedValue: string,
|
||||
cyclesArg: number = 50,
|
||||
intervalArg: number = 500
|
||||
) {
|
||||
let runCycles = 0;
|
||||
const doCheck = async () => {
|
||||
if (runCycles < cyclesArg) {
|
||||
runCycles++;
|
||||
try {
|
||||
let myRecordArray: plugins.tsclass.network.IDnsRecord[];
|
||||
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
|
||||
*/
|
||||
public async getRecordsA(recordNameArg: string): Promise<plugins.tsclass.network.IDnsRecord[]> {
|
||||
return await this.getRecords(recordNameArg, 'A');
|
||||
}
|
||||
|
||||
/**
|
||||
* get AAAA Record
|
||||
*/
|
||||
public async getRecordsAAAA(recordNameArg: string) {
|
||||
return await this.getRecords(recordNameArg, 'AAAA');
|
||||
}
|
||||
|
||||
/**
|
||||
* gets a txt record
|
||||
*/
|
||||
public async getRecordsTxt(recordNameArg: string): Promise<plugins.tsclass.network.IDnsRecord[]> {
|
||||
return await this.getRecords(recordNameArg, 'TXT');
|
||||
}
|
||||
|
||||
public async getRecords(
|
||||
recordNameArg: string,
|
||||
recordTypeArg: plugins.tsclass.network.TDnsRecordType,
|
||||
retriesCounterArg = 20
|
||||
): Promise<plugins.tsclass.network.IDnsRecord[]> {
|
||||
const requestUrl = `https://cloudflare-dns.com/dns-query?name=${recordNameArg}&type=${recordTypeArg}&do=1`;
|
||||
const returnArray: plugins.tsclass.network.IDnsRecord[] = [];
|
||||
const getResponseBody = async (counterArg = 0): Promise<IDnsJsonResponse> => {
|
||||
const response = await plugins.smartrequest.request(requestUrl, {
|
||||
method: 'GET',
|
||||
headers: {
|
||||
accept: 'application/dns-json',
|
||||
},
|
||||
});
|
||||
const responseBody: IDnsJsonResponse = response.body;
|
||||
if (responseBody?.Status !== 0 && counterArg < retriesCounterArg) {
|
||||
await plugins.smartdelay.delayFor(500);
|
||||
return getResponseBody(counterArg + 1);
|
||||
} 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
|
||||
*/
|
||||
public async getRecordWithNodeDNS(
|
||||
recordNameArg: string,
|
||||
recordTypeArg: plugins.tsclass.network.TDnsRecordType
|
||||
): Promise<plugins.tsclass.network.IDnsRecord[]> {
|
||||
const done = plugins.smartpromise.defer<plugins.tsclass.network.IDnsRecord[]>();
|
||||
plugins.dns.resolve(recordNameArg, recordTypeArg, (err, recordsArg) => {
|
||||
if (err) {
|
||||
done.reject(err);
|
||||
return;
|
||||
}
|
||||
const returnArray: plugins.tsclass.network.IDnsRecord[] = [];
|
||||
for (const recordKey in recordsArg) {
|
||||
returnArray.push({
|
||||
name: recordNameArg,
|
||||
value: recordsArg[recordKey][0],
|
||||
type: recordTypeArg,
|
||||
dnsSecEnabled: false,
|
||||
});
|
||||
}
|
||||
done.resolve(returnArray);
|
||||
});
|
||||
return done.promise;
|
||||
}
|
||||
|
||||
public async getNameServers(domainNameArg: string): Promise<string[]> {
|
||||
const done = plugins.smartpromise.defer<string[]>();
|
||||
plugins.dns.resolveNs(domainNameArg, (err, result) => {
|
||||
if (!err) {
|
||||
done.resolve(result);
|
||||
} else {
|
||||
console.log(err);
|
||||
done.reject(err);
|
||||
}
|
||||
});
|
||||
return await done.promise;
|
||||
}
|
||||
|
||||
public convertDnsTypeNameToTypeNumber(dnsTypeNameArg: string): number {
|
||||
return this.dnsTypeMap[dnsTypeNameArg];
|
||||
}
|
||||
|
||||
public convertDnsTypeNumberToTypeName(
|
||||
dnsTypeNumberArg: number
|
||||
): plugins.tsclass.network.TDnsRecordType {
|
||||
for (const key in this.dnsTypeMap) {
|
||||
if (this.dnsTypeMap[key] === dnsTypeNumberArg) {
|
||||
return key as plugins.tsclass.network.TDnsRecordType;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
1
ts_client/index.ts
Normal file
1
ts_client/index.ts
Normal file
@ -0,0 +1 @@
|
||||
export * from './classes.dnsclient.js';
|
||||
18
ts_client/plugins.ts
Normal file
18
ts_client/plugins.ts
Normal file
@ -0,0 +1,18 @@
|
||||
import * as smartenv from '@push.rocks/smartenv';
|
||||
const smartenvInstance = new smartenv.Smartenv();
|
||||
// node native scope
|
||||
import type dnsType from 'dns';
|
||||
const dns: typeof dnsType = 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 };
|
||||
3
ts_client/tspublish.json
Normal file
3
ts_client/tspublish.json
Normal file
@ -0,0 +1,3 @@
|
||||
{
|
||||
"order": 2
|
||||
}
|
||||
189
ts_server/classes.dnssec.ts
Normal file
189
ts_server/classes.dnssec.ts
Normal file
@ -0,0 +1,189 @@
|
||||
// Import necessary plugins from plugins.ts
|
||||
import * as plugins from './plugins.js';
|
||||
|
||||
interface DnssecZone {
|
||||
zone: string;
|
||||
algorithm: 'ECDSA' | 'ED25519' | 'RSA';
|
||||
keySize: number;
|
||||
days: number;
|
||||
}
|
||||
|
||||
interface DnssecKeyPair {
|
||||
privateKey: string;
|
||||
publicKey: string;
|
||||
}
|
||||
|
||||
export class DnsSec {
|
||||
private zone: DnssecZone;
|
||||
private keyPair: DnssecKeyPair;
|
||||
private ec?: plugins.elliptic.ec; // For ECDSA algorithms
|
||||
private eddsa?: plugins.elliptic.eddsa; // For EdDSA algorithms
|
||||
|
||||
constructor(zone: DnssecZone) {
|
||||
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();
|
||||
}
|
||||
|
||||
private generateKeyPair(): DnssecKeyPair {
|
||||
let privateKey: string;
|
||||
let publicKey: string;
|
||||
|
||||
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 };
|
||||
}
|
||||
|
||||
public getAlgorithmNumber(): number {
|
||||
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}`);
|
||||
}
|
||||
}
|
||||
|
||||
public signData(data: Buffer): Buffer {
|
||||
switch (this.zone.algorithm) {
|
||||
case 'ECDSA':
|
||||
if (!this.ec) throw new Error('EC instance is not initialized.');
|
||||
const ecKeyPair = this.ec.keyFromPrivate(this.keyPair.privateKey, 'hex');
|
||||
const ecSignature = ecKeyPair.sign(plugins.crypto.createHash('sha256').update(data).digest());
|
||||
return Buffer.from(ecSignature.toDER());
|
||||
|
||||
case 'ED25519':
|
||||
if (!this.eddsa) throw new Error('EdDSA instance is not initialized.');
|
||||
const edKeyPair = this.eddsa.keyFromSecret(Buffer.from(this.keyPair.privateKey, 'hex'));
|
||||
// ED25519 doesn't need a separate hash function as it includes the hashing internally
|
||||
const edSignature = edKeyPair.sign(data);
|
||||
// Convert the signature to the correct format for Buffer.from
|
||||
return Buffer.from(edSignature.toBytes());
|
||||
|
||||
case 'RSA':
|
||||
throw new Error('RSA signing is not yet implemented.');
|
||||
|
||||
default:
|
||||
throw new Error(`Unsupported algorithm: ${this.zone.algorithm}`);
|
||||
}
|
||||
}
|
||||
|
||||
private generateDNSKEY(): Buffer {
|
||||
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: Buffer;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
private computeKeyTag(dnskeyRdata: Buffer): number {
|
||||
// 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;
|
||||
}
|
||||
|
||||
private getDNSKEYRecord(): string {
|
||||
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}`;
|
||||
}
|
||||
|
||||
public getDSRecord(): string {
|
||||
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}`;
|
||||
}
|
||||
|
||||
public getKeyPair(): DnssecKeyPair {
|
||||
return this.keyPair;
|
||||
}
|
||||
|
||||
public getDsAndKeyPair(): { keyPair: DnssecKeyPair; dsRecord: string; dnskeyRecord: string } {
|
||||
const dsRecord = this.getDSRecord();
|
||||
const dnskeyRecord = this.getDNSKEYRecord();
|
||||
return { keyPair: this.keyPair, dsRecord, dnskeyRecord };
|
||||
}
|
||||
}
|
||||
830
ts_server/classes.dnsserver.ts
Normal file
830
ts_server/classes.dnsserver.ts
Normal file
@ -0,0 +1,830 @@
|
||||
import * as plugins from './plugins.js';
|
||||
import { DnsSec } from './classes.dnssec.js';
|
||||
import * as dnsPacket from 'dns-packet';
|
||||
|
||||
export interface IDnsServerOptions {
|
||||
httpsKey: string;
|
||||
httpsCert: string;
|
||||
httpsPort: number;
|
||||
udpPort: number;
|
||||
dnssecZone: string;
|
||||
udpBindInterface?: string;
|
||||
httpsBindInterface?: string;
|
||||
}
|
||||
|
||||
export interface DnsAnswer {
|
||||
name: string;
|
||||
type: string;
|
||||
class: string | number;
|
||||
ttl: number;
|
||||
data: any;
|
||||
}
|
||||
|
||||
export interface IDnsHandler {
|
||||
domainPattern: string;
|
||||
recordTypes: string[];
|
||||
handler: (question: dnsPacket.Question) => DnsAnswer | null;
|
||||
}
|
||||
|
||||
// Define types for DNSSEC records if not provided
|
||||
interface DNSKEYData {
|
||||
flags: number;
|
||||
algorithm: number;
|
||||
key: Buffer;
|
||||
}
|
||||
|
||||
|
||||
// Let's Encrypt related interfaces
|
||||
interface LetsEncryptOptions {
|
||||
email?: string;
|
||||
staging?: boolean;
|
||||
certDir?: string;
|
||||
}
|
||||
|
||||
export class DnsServer {
|
||||
private udpServer: plugins.dgram.Socket;
|
||||
private httpsServer: plugins.https.Server;
|
||||
private handlers: IDnsHandler[] = [];
|
||||
|
||||
// DNSSEC related properties
|
||||
private dnsSec: DnsSec;
|
||||
private dnskeyRecord: DNSKEYData;
|
||||
private keyTag: number;
|
||||
|
||||
constructor(private options: IDnsServerOptions) {
|
||||
// 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);
|
||||
}
|
||||
|
||||
public registerHandler(
|
||||
domainPattern: string,
|
||||
recordTypes: string[],
|
||||
handler: (question: dnsPacket.Question) => DnsAnswer | null
|
||||
): void {
|
||||
this.handlers.push({ domainPattern, recordTypes, handler });
|
||||
}
|
||||
|
||||
// Unregister a specific handler
|
||||
public unregisterHandler(domainPattern: string, recordTypes: string[]): boolean {
|
||||
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
|
||||
*/
|
||||
public async retrieveSslCertificate(
|
||||
domainNames: string[],
|
||||
options: LetsEncryptOptions = {}
|
||||
): Promise<{ cert: string; key: string; success: boolean }> {
|
||||
// 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: Buffer;
|
||||
|
||||
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: { domain: string; pattern: string }[] = [];
|
||||
|
||||
// Process each authorization
|
||||
for (const auth of authorizations) {
|
||||
const domain = auth.identifier.value;
|
||||
|
||||
// Get DNS challenge
|
||||
const challenge = auth.challenges.find((c: any) => 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: dnsPacket.Question): DnsAnswer | null => {
|
||||
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);
|
||||
|
||||
// Create CSR
|
||||
// Define an interface for the expected CSR result structure
|
||||
interface CSRResult {
|
||||
csr: Buffer;
|
||||
}
|
||||
|
||||
// Use the forge.createCsr method and handle typing with a more direct approach
|
||||
const csrResult = await acmeClient.forge.createCsr({
|
||||
commonName: authorizedDomains[0],
|
||||
altNames: authorizedDomains
|
||||
}) as unknown as CSRResult;
|
||||
|
||||
// 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
|
||||
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
|
||||
*/
|
||||
private getDnsRecordValueForChallenge(keyAuthorization: string): string {
|
||||
// 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
|
||||
*/
|
||||
private async restartHttpsServer(): Promise<void> {
|
||||
return new Promise<void>((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)
|
||||
);
|
||||
|
||||
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();
|
||||
});
|
||||
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)
|
||||
);
|
||||
|
||||
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();
|
||||
});
|
||||
} 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
|
||||
*/
|
||||
public filterAuthorizedDomains(domainNames: string[]): string[] {
|
||||
const authorizedDomains: string[] = [];
|
||||
|
||||
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)
|
||||
*/
|
||||
private isValidIpAddress(ip: string): boolean {
|
||||
// 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
|
||||
*/
|
||||
private isIPv6(ip: string): boolean {
|
||||
return ip.includes(':');
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the server is authoritative for a domain
|
||||
*/
|
||||
private isAuthorizedForDomain(domain: string): boolean {
|
||||
// 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;
|
||||
}
|
||||
|
||||
public processDnsRequest(request: dnsPacket.Packet): dnsPacket.Packet {
|
||||
const response: dnsPacket.Packet = {
|
||||
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);
|
||||
|
||||
for (const question of request.questions) {
|
||||
console.log(`Query for ${question.name} of type ${question.type}`);
|
||||
|
||||
let answered = false;
|
||||
|
||||
// Handle DNSKEY queries if DNSSEC is requested
|
||||
if (dnssecRequested && question.type === 'DNSKEY' && question.name === this.options.dnssecZone) {
|
||||
const dnskeyAnswer: DnsAnswer = {
|
||||
name: question.name,
|
||||
type: 'DNSKEY',
|
||||
class: 'IN',
|
||||
ttl: 3600,
|
||||
data: this.dnskeyRecord,
|
||||
};
|
||||
response.answers.push(dnskeyAnswer as plugins.dnsPacket.Answer);
|
||||
|
||||
// Sign the DNSKEY RRset
|
||||
const rrsig = this.generateRRSIG('DNSKEY', [dnskeyAnswer], question.name);
|
||||
response.answers.push(rrsig as plugins.dnsPacket.Answer);
|
||||
|
||||
answered = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
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: DnsAnswer = {
|
||||
...answer,
|
||||
ttl: answer.ttl || 300,
|
||||
class: answer.class || 'IN',
|
||||
};
|
||||
response.answers.push(dnsAnswer as plugins.dnsPacket.Answer);
|
||||
|
||||
if (dnssecRequested) {
|
||||
// Sign the answer RRset
|
||||
const rrsig = this.generateRRSIG(question.type, [dnsAnswer], question.name);
|
||||
response.answers.push(rrsig as plugins.dnsPacket.Answer);
|
||||
}
|
||||
|
||||
answered = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!answered) {
|
||||
console.log(`No handler found for ${question.name} of type ${question.type}`);
|
||||
response.flags |= dnsPacket.AUTHORITATIVE_ANSWER;
|
||||
const soaAnswer: DnsAnswer = {
|
||||
name: question.name,
|
||||
type: 'SOA',
|
||||
class: 'IN',
|
||||
ttl: 3600,
|
||||
data: {
|
||||
mname: `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 as plugins.dnsPacket.Answer);
|
||||
}
|
||||
}
|
||||
|
||||
return response;
|
||||
}
|
||||
|
||||
private isDnssecRequested(request: dnsPacket.Packet): boolean {
|
||||
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;
|
||||
}
|
||||
|
||||
private generateRRSIG(
|
||||
type: string,
|
||||
rrset: DnsAnswer[],
|
||||
name: string
|
||||
): DnsAnswer {
|
||||
// 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);
|
||||
|
||||
// Construct the RRSIG record
|
||||
const rrsig: DnsAnswer = {
|
||||
name,
|
||||
type: 'RRSIG',
|
||||
class: 'IN',
|
||||
ttl,
|
||||
data: {
|
||||
typeCovered: type, // Changed to type string
|
||||
algorithm,
|
||||
labels: name.split('.').length - 1,
|
||||
originalTTL: ttl,
|
||||
expiration,
|
||||
inception,
|
||||
keyTag,
|
||||
signerName,
|
||||
signature: signature,
|
||||
},
|
||||
};
|
||||
|
||||
return rrsig;
|
||||
}
|
||||
|
||||
private serializeRRset(rrset: DnsAnswer[]): Buffer {
|
||||
// Implement canonical DNS RRset serialization as per RFC 4034 Section 6
|
||||
const buffers: Buffer[] = [];
|
||||
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);
|
||||
}
|
||||
|
||||
private serializeRData(type: string, data: any): Buffer {
|
||||
// Implement serialization for each record type you support
|
||||
switch (type) {
|
||||
case 'A':
|
||||
return Buffer.from(data.split('.').map((octet: string) => parseInt(octet, 10)));
|
||||
case 'AAAA':
|
||||
// Handle IPv6 addresses
|
||||
return Buffer.from(data.split(':').flatMap((segment: string) => {
|
||||
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: 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 'SOA':
|
||||
// Implement SOA record serialization if needed
|
||||
// For now, return an empty buffer or handle as needed
|
||||
return Buffer.alloc(0);
|
||||
// Add cases for other record types as needed
|
||||
default:
|
||||
throw new Error(`Serialization for record type ${type} is not implemented.`);
|
||||
}
|
||||
}
|
||||
|
||||
private parseDNSKEYRecord(dnskeyRecord: string): DNSKEYData {
|
||||
// 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,
|
||||
};
|
||||
}
|
||||
|
||||
private computeKeyTag(dnskeyRecord: DNSKEYData): number {
|
||||
// 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;
|
||||
}
|
||||
|
||||
private handleHttpsRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void {
|
||||
if (req.method === 'POST' && req.url === '/dns-query') {
|
||||
let body: Buffer[] = [];
|
||||
|
||||
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();
|
||||
}
|
||||
}
|
||||
|
||||
public async start(): Promise<void> {
|
||||
// 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}`);
|
||||
}
|
||||
|
||||
this.httpsServer = plugins.https.createServer(
|
||||
{
|
||||
key: this.options.httpsKey,
|
||||
cert: this.options.httpsCert,
|
||||
},
|
||||
this.handleHttpsRequest.bind(this)
|
||||
);
|
||||
|
||||
// Create appropriate socket type based on interface
|
||||
const socketType = this.isIPv6(udpInterface) ? 'udp6' : 'udp4';
|
||||
this.udpServer = plugins.dgram.createSocket(socketType);
|
||||
this.udpServer.on('message', (msg, rinfo) => {
|
||||
const request = dnsPacket.decode(msg);
|
||||
const response = this.processDnsRequest(request);
|
||||
const responseData = 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<void>();
|
||||
const httpsListeningDeferred = plugins.smartpromise.defer<void>();
|
||||
|
||||
try {
|
||||
this.udpServer.bind(this.options.udpPort, udpInterface, () => {
|
||||
console.log(`UDP DNS server running on ${udpInterface}:${this.options.udpPort}`);
|
||||
udpListeningDeferred.resolve();
|
||||
});
|
||||
|
||||
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 DNS server:', err);
|
||||
process.exit(1);
|
||||
}
|
||||
await Promise.all([udpListeningDeferred.promise, httpsListeningDeferred.promise]);
|
||||
}
|
||||
|
||||
public async stop(): Promise<void> {
|
||||
const doneUdp = plugins.smartpromise.defer<void>();
|
||||
const doneHttps = plugins.smartpromise.defer<void>();
|
||||
|
||||
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]);
|
||||
}
|
||||
|
||||
// Helper methods
|
||||
|
||||
private qtypeToNumber(type: string): number {
|
||||
const QTYPE_NUMBERS: { [key: string]: number } = {
|
||||
'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;
|
||||
}
|
||||
|
||||
private classToNumber(cls: string | number): number {
|
||||
const CLASS_NUMBERS: { [key: string]: number } = {
|
||||
'IN': 1,
|
||||
'CH': 3,
|
||||
'HS': 4,
|
||||
// Add more as needed
|
||||
};
|
||||
if (typeof cls === 'number') {
|
||||
return cls;
|
||||
}
|
||||
return CLASS_NUMBERS[cls.toUpperCase()] || 1;
|
||||
}
|
||||
|
||||
private nameToBuffer(name: string): Buffer {
|
||||
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
|
||||
}
|
||||
}
|
||||
1
ts_server/index.ts
Normal file
1
ts_server/index.ts
Normal file
@ -0,0 +1 @@
|
||||
export * from './classes.dnsserver.js';
|
||||
34
ts_server/plugins.ts
Normal file
34
ts_server/plugins.ts
Normal file
@ -0,0 +1,34 @@
|
||||
// node native
|
||||
import crypto from 'crypto';
|
||||
import dgram from 'dgram';
|
||||
import fs from 'fs';
|
||||
import http from 'http';
|
||||
import https from 'https';
|
||||
import * as path from 'path';
|
||||
|
||||
export {
|
||||
crypto,
|
||||
fs,
|
||||
http,
|
||||
https,
|
||||
dgram,
|
||||
path,
|
||||
}
|
||||
|
||||
// @push.rocks scope
|
||||
import * as smartpromise from '@push.rocks/smartpromise';
|
||||
|
||||
export {
|
||||
smartpromise,
|
||||
}
|
||||
|
||||
// third party
|
||||
import elliptic from 'elliptic';
|
||||
import * as dnsPacket from 'dns-packet';
|
||||
import * as minimatch from 'minimatch';
|
||||
|
||||
export {
|
||||
dnsPacket,
|
||||
elliptic,
|
||||
minimatch,
|
||||
}
|
||||
3
ts_server/tspublish.json
Normal file
3
ts_server/tspublish.json
Normal file
@ -0,0 +1,3 @@
|
||||
{
|
||||
"order": 1
|
||||
}
|
||||
14
tsconfig.json
Normal file
14
tsconfig.json
Normal file
@ -0,0 +1,14 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"experimentalDecorators": true,
|
||||
"useDefineForClassFields": false,
|
||||
"target": "ES2022",
|
||||
"module": "NodeNext",
|
||||
"moduleResolution": "NodeNext",
|
||||
"esModuleInterop": true,
|
||||
"verbatimModuleSyntax": true
|
||||
},
|
||||
"exclude": [
|
||||
"dist_*/**/*.d.ts"
|
||||
]
|
||||
}
|
||||
17
tslint.json
17
tslint.json
@ -1,17 +0,0 @@
|
||||
{
|
||||
"extends": ["tslint:latest", "tslint-config-prettier"],
|
||||
"rules": {
|
||||
"semicolon": [true, "always"],
|
||||
"no-console": false,
|
||||
"ordered-imports": false,
|
||||
"object-literal-sort-keys": false,
|
||||
"member-ordering": {
|
||||
"options":{
|
||||
"order": [
|
||||
"static-method"
|
||||
]
|
||||
}
|
||||
}
|
||||
},
|
||||
"defaultSeverity": "warning"
|
||||
}
|
||||
Reference in New Issue
Block a user