ddan-js 2.6.16 → 2.6.18

package/bin/lib/modules/node/sockServer.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SockServer = void 0;
+const net_1 = require("net");
+const socks_1 = require("socks");
+class SockServer {
+    upstreamProxy;
+    server = null;
+    clientSockets = new Set();
+    allowedDomains;
+    connectionPool = {};
+    __debug = false;
+    constructor(upstreamProxy, allowedDomains = [], debug = false) {
+        this.upstreamProxy = upstreamProxy;
+        this.allowedDomains = new Set(allowedDomains);
+        this.__debug = false;
+    }
+    validateProxyConfig(proxyConfig) {
+        const { ipaddress, port, userId, password } = proxyConfig;
+        if (!ipaddress || typeof ipaddress !== 'string') {
+            return '无效的上游代理 IP 地址';
+        }
+        if (!port || typeof port !== 'number') {
+            return '无效的上游代理端口';
+        }
+        if (!userId || typeof userId !== 'string') {
+            return '无效的上游代理用户名';
+        }
+        if (!password || typeof password !== 'string') {
+            return '无效的上游代理密码';
+        }
+        return '';
+    }
+    async start(startPort = 9968) {
+        if (this.server) {
+            console.log(`Server is already running`);
+            return 0;
+        }
+        const port = await this.findAvailablePort(startPort);
+        if (!port)
+            return port;
+        this.server = net_1.default.createServer((socket) => this.handleSocksConnection(socket));
+        this.server.listen(port, () => {
+            this.__debug && console.log(`SOCKS5 proxy server is running on port ${port}`);
+        });
+        this.server.on('error', (err) => {
+            console.error('SOCKS5 proxy server error:', err);
+            this.close();
+        });
+        return port;
+    }
+    async findAvailablePort(startPort, maxRetries = 200 // 最大重试次数
+    ) {
+        let port = startPort;
+        let retries = 0;
+        while (retries < maxRetries) {
+            try {
+                await new Promise((resolve, reject) => {
+                    const testServer = net_1.default.createServer();
+                    testServer.unref();
+                    testServer.on('error', reject);
+                    testServer.listen(port, () => {
+                        testServer.close(() => resolve());
+                    });
+                });
+                return port; // 找到可用端口
+            }
+            catch {
+                retries++; // 记录重试次数
+                port++; // 尝试下一个端口
+            }
+        }
+        console.warn('findAvailablePort failed');
+        return 0;
+    }
+    async handleSocksConnection(clientSocket) {
+        this.clientSockets.add(clientSocket);
+        clientSocket.on('close', () => {
+            this.clientSockets.delete(clientSocket);
+            clientSocket?.destroy();
+        });
+        try {
+            await this.performHandshake(clientSocket);
+            const destination = await this.parseClientRequest(clientSocket);
+            this.__debug && console.log(`SockServer handleSocksConnection`, destination.addr);
+            if (this.isAllowedDomain(destination.addr)) {
+                // 允许的域名，走上游代理
+                const upstreamSocket = await this.connectToUpstreamProxy(destination);
+                this.setupDataForwarding(clientSocket, upstreamSocket);
+            }
+            else {
+                // 不允许的域名，走本地连接
+                const localSocket = await this.connectToLocal(destination);
+                this.setupDataForwarding(clientSocket, localSocket);
+            }
+        }
+        catch (err) {
+            console.error('Error handling SOCKS connection:', err);
+            clientSocket.end(new Uint8Array([0x05, 0x01]));
+        }
+    }
+    performHandshake(clientSocket) {
+        return new Promise((resolve, reject) => {
+            clientSocket.once('data', (data) => {
+                if (data[0] !== 0x05) {
+                    return reject(new Error('Unsupported SOCKS version'));
+                }
+                clientSocket.write(new Uint8Array([0x05, 0x00]));
+                resolve();
+            });
+        });
+    }
+    parseClientRequest(clientSocket) {
+        return new Promise((resolve, reject) => {
+            clientSocket.once('data', (data) => {
+                let addr;
+                let port;
+                if (data[1] !== 0x01) {
+                    return reject(new Error('Unsupported command'));
+                }
+                if (data[3] === 0x01) {
+                    // IPv4 地址
+                    addr = data.slice(4, 8).join('.');
+                    port = data.readUInt16BE(8);
+                }
+                else if (data[3] === 0x03) {
+                    // 域名
+                    const len = data[4];
+                    addr = data.slice(5, 5 + len).toString();
+                    port = data.readUInt16BE(5 + len);
+                }
+                else {
+                    return reject(new Error('Unsupported address type'));
+                }
+                resolve({ addr, port });
+            });
+        });
+    }
+    // 上游代理连接
+    async connectToUpstreamProxy(destination) {
+        const destKey = `${destination.addr}:${destination.port}`;
+        // 如果已有连接在池中，复用
+        if (this.connectionPool[destKey] && !this.connectionPool[destKey].destroyed) {
+            console.log(`Reusing connection for ${destKey}`);
+            return this.connectionPool[destKey];
+        }
+        const options = {
+            proxy: { ...this.upstreamProxy, type: 5 },
+            command: 'connect',
+            destination: {
+                host: destination.addr,
+                port: destination.port,
+            },
+        };
+        try {
+            const { socket: upstreamSocket } = await socks_1.SocksClient.createConnection(options);
+            this.connectionPool[destKey] = upstreamSocket;
+            upstreamSocket.on('close', () => {
+                delete this.connectionPool[destKey];
+            });
+            return upstreamSocket;
+        }
+        catch (err) {
+            throw new Error('Failed to connect to upstream proxy: ' + err);
+        }
+    }
+    // 本地连接
+    connectToLocal(destination) {
+        return new Promise((resolve, reject) => {
+            const localSocket = net_1.default.createConnection(destination.port, destination.addr, () => {
+                resolve(localSocket);
+            });
+            localSocket.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    setupDataForwarding(clientSocket, targetSocket) {
+        clientSocket.write(new Uint8Array([0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]));
+        clientSocket.pipe(targetSocket);
+        targetSocket.pipe(clientSocket);
+        clientSocket.on('close', () => {
+            targetSocket.end();
+        });
+        targetSocket.on('close', () => {
+            clientSocket.end();
+        });
+        clientSocket.on('error', (err) => {
+            console.error('Client socket error:', err);
+            targetSocket.end();
+        });
+        targetSocket.on('error', (err) => {
+            console.error('Target socket error:', err);
+            clientSocket.end();
+        });
+    }
+    isAllowedDomain(addr) {
+        // return this.allowedDomains.has(addr);
+        // 只匹配主域名，忽略子域名
+        for (const domain of this.allowedDomains) {
+            if (domain === '*')
+                return true;
+            if (addr.includes(domain))
+                return true;
+        }
+        return false;
+    }
+    close() {
+        if (this.server) {
+            console.log('Closing SOCKS5 proxy server...');
+            this.server.close((err) => {
+                if (err) {
+                    console.error('Error closing the server:', err);
+                }
+            });
+            // 销毁客户端 socket
+            this.clientSockets.forEach((socket) => socket.destroy());
+            // 销毁所有连接池中的 socket
+            Object.values(this.connectionPool).forEach((socket) => socket.destroy());
+            this.server = null;
+        }
+    }
+}
+exports.SockServer = SockServer;

package/bin/types/index.d.ts

@@ -390,6 +390,7 @@ declare const dLogger: {
     }) => void;
 };
 declare const dWeb: {
+    Ecdh: typeof import("./modules/browser/ecdh").default;
     fetch: {
         getDataURL: (url: string) => Promise<[any, undefined] | [null, {
             contentType: string;
@@ -499,6 +500,8 @@ declare const dWeb: {
 };
 declare const dNode: {
     Ecdh: typeof import("./modules/node/ecdh").default;
+    EcdhSpki: typeof import("./modules/node/ecdhSpki").default;
+    SockServer: typeof import("./modules/node/sockServer").SockServer;
     brotliCompress: typeof import("./modules/node/brotli").brotliCompress;
     brotliDecompress: typeof import("./modules/node/brotli").brotliDecompress;
 };

package/bin/types/modules/browser/ecdh.d.ts

@@ -0,0 +1,17 @@
+export default class Ecdh {
+    publicKey: string;
+    iv: string;
+    __keyPair: CryptoKeyPair | undefined;
+    __sharedSecret: CryptoKey | undefined;
+    __curve: string;
+    constructor(curve?: string);
+    generateKeys(iv: string): Promise<this>;
+    exportSpkiKey(cryptoKey: CryptoKey): Promise<string>;
+    importSpkiKey(keyBase64: string): Promise<CryptoKey>;
+    deriveSharedSecret(publicKeyBase64: string): Promise<this>;
+    encode(data: string): Promise<{
+        text: string;
+        iv: string;
+    }>;
+    decode(encrypted: string, iv: string): Promise<string>;
+}

package/bin/types/modules/browser/index.d.ts

@@ -0,0 +1,5 @@
+import Ecdh from "./ecdh";
+declare const _default: {
+    Ecdh: typeof Ecdh;
+};
+export default _default;

package/bin/types/modules/node/ecdhSpki.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import crypto from "node:crypto";
+export default class EcdhSpki {
+    publicKey: string;
+    iv: string;
+    __keyPair: CryptoKeyPair | undefined;
+    __sharedSecret: CryptoKey | undefined;
+    __curve: string;
+    constructor(curve?: string);
+    generateKeys(iv: string): Promise<this>;
+    exportSpkiKey(cryptoKey: CryptoKey): Promise<string>;
+    importSpkiKey(keyBase64: string): Promise<crypto.webcrypto.CryptoKey>;
+    deriveSharedSecret(publicKeyBase64: string): Promise<this>;
+    encode(data: string): Promise<{
+        text: string;
+        iv: string;
+    }>;
+    decode(encrypted: string, iv: string): Promise<string>;
+}

package/bin/types/modules/node/index.d.ts

@@ -1,6 +1,10 @@
 import Ecdh from "./ecdh";
+import EcdhSpki from "./ecdhSpki";
+import { SockServer } from "./sockServer";
 declare const _default: {
     Ecdh: typeof Ecdh;
+    EcdhSpki: typeof EcdhSpki;
+    SockServer: typeof SockServer;
     brotliCompress: typeof import("./brotli").brotliCompress;
     brotliDecompress: typeof import("./brotli").brotliDecompress;
 };

package/bin/types/modules/node/sockServer.d.ts

@@ -0,0 +1,28 @@
+interface IProxyConfig {
+    ipaddress: string;
+    port: number;
+    type?: 5;
+    userId: string;
+    password: string;
+}
+export declare class SockServer {
+    private upstreamProxy;
+    private server;
+    private clientSockets;
+    private allowedDomains;
+    private connectionPool;
+    __debug: boolean;
+    constructor(upstreamProxy: IProxyConfig, allowedDomains?: string[], debug?: boolean);
+    validateProxyConfig(proxyConfig: IProxyConfig): "无效的上游代理 IP 地址" | "无效的上游代理端口" | "无效的上游代理用户名" | "无效的上游代理密码" | "";
+    start(startPort?: number): Promise<number>;
+    private findAvailablePort;
+    private handleSocksConnection;
+    private performHandshake;
+    private parseClientRequest;
+    private connectToUpstreamProxy;
+    private connectToLocal;
+    private setupDataForwarding;
+    private isAllowedDomain;
+    close(): void;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddan-js",
-  "version": "2.6.16",
+  "version": "2.6.18",
   "description": "",
   "keywords": [
     "ddan-js",
@@ -35,7 +35,7 @@
   },
   "license": "MIT",
   "engines": {
-    "node": ">=6.0.0"
+    "node": ">=15.0.0"
   },
   "scripts": {
     "lint": "tslint  --project tsconfig.json -t codeFrame 'src/**/*.ts' 'test/**/*.ts'",
@@ -107,7 +107,7 @@
     "@types/babel__core": "7.1.19",
     "@types/babel__traverse": "7.17.1",
     "@types/jest": "^23.3.2",
-    "@types/node": "^14.17.0",
+    "@types/node": "^16.18.0",
     "colors": "^1.4.0",
     "commitizen": "^4.3.0",
     "coveralls": "^3.1.1",
@@ -143,5 +143,8 @@
     "tslint-config-standard": "^9.0.0",
     "typedoc": "^0.24.0",
     "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "socks": "^2.8.3"
   }
 }