ddan-js 2.6.39 → 2.6.41

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

@@ -7,15 +7,15 @@ class Ecdh {
     privateKey = '';
     sharedSecret;
     iv = '';
-    _curve;
-    _algorithm;
-    _ecdh;
+    __curve;
+    __algorithm;
+    __ecdh;
     constructor(curve = 'prime256v1', algorithm = 'aes-256-gcm') {
-        this._curve = curve;
-        this._algorithm = algorithm;
-        this.generateKey();
+        this.__curve = curve;
+        this.__algorithm = algorithm;
+        this.generateKeys();
     }
-    generateKey() {
+    generateKeys() {
         // 使用 P-256 曲线
         const ecdh = node_crypto_1.default.createECDH('prime256v1');
         ecdh.generateKeys();
@@ -23,28 +23,38 @@ class Ecdh {
         this.publicKey = ecdh.getPublicKey('base64');
         // 私钥以 base64 格式导出
         this.privateKey = ecdh.getPrivateKey('base64');
-        this._ecdh = ecdh;
+        this.__ecdh = ecdh;
     }
-    deriveSharedSecret(otherPublicKey, iv) {
-        if (!otherPublicKey || !iv)
+    setPrivateKey(privateBase64) {
+        if (!privateBase64)
+            return false;
+        if (!this.__ecdh)
             return false;
-        this.sharedSecret = this._ecdh.computeSecret(otherPublicKey, 'base64').toString('base64');
-        this.iv = iv;
+        this.__ecdh.setPrivateKey(privateBase64, 'base64');
+        this.publicKey = this.__ecdh.getPublicKey('base64');
         return true;
     }
-    setPrivateKey(privateBase64) {
-        if (!privateBase64)
+    setSharedSecret(secretBase64) {
+        if (!secretBase64)
             return false;
-        if (!this._ecdh)
+        this.sharedSecret = secretBase64;
+        return true;
+    }
+    deriveSharedSecret(otherPublicKey, iv) {
+        if (!otherPublicKey)
             return false;
-        this._ecdh.setPrivateKey(privateBase64, 'base64');
-        this.publicKey = this._ecdh.getPublicKey('base64');
+        this.sharedSecret = this.__ecdh.computeSecret(otherPublicKey, 'base64').toString('base64');
+        this.iv = iv || '';
         return true;
     }
-    encode(data) {
-        if (!this.sharedSecret || !this.iv)
+    encode(data, iv) {
+        if (!this.sharedSecret)
+            return '';
+        const _iv = iv || this.iv;
+        if (!_iv)
             return '';
-        const cipher = node_crypto_1.default.createCipheriv('aes-256-gcm', convert_1.default.base64ToBytes(this.sharedSecret), convert_1.default.base64ToBytes(this.iv));
+        const ivBytes = convert_1.default.base64ToBytes(_iv);
+        const cipher = node_crypto_1.default.createCipheriv('aes-256-gcm', convert_1.default.base64ToBytes(this.sharedSecret), ivBytes);
         const encrypted = Buffer.concat([
             new Uint8Array(cipher.update(data, 'utf8')),
             new Uint8Array(cipher.final()),
@@ -53,10 +63,11 @@ class Ecdh {
         const combined = Buffer.concat([new Uint8Array(encrypted), new Uint8Array(tagBuf)]);
         return combined.toString('base64');
     }
-    encodeiv(data) {
-        if (!this.sharedSecret || !this.iv)
+    encodeiv(data, iv) {
+        if (!this.sharedSecret)
             return '';
-        const ivBytes = convert_1.default.base64ToBytes(this.iv);
+        const _iv = iv || this.iv;
+        const ivBytes = _iv ? convert_1.default.base64ToBytes(_iv) : convert_1.default.getRandomBytes(12);
         const cipher = node_crypto_1.default.createCipheriv('aes-256-gcm', convert_1.default.base64ToBytes(this.sharedSecret), ivBytes);
         const encrypted = Buffer.concat([
             new Uint8Array(cipher.update(data, 'utf8')),
@@ -70,6 +81,8 @@ class Ecdh {
         if (!encrypted || !this.sharedSecret)
             return '';
         const _iv = iv || this.iv;
+        if (!_iv)
+            return '';
         const decipher = node_crypto_1.default.createDecipheriv('aes-256-gcm', convert_1.default.base64ToBytes(this.sharedSecret), convert_1.default.base64ToBytes(_iv));
         const allBytes = convert_1.default.base64ToBytes(encrypted);
         const authTagBytes = allBytes.slice(allBytes.length - 16);

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

@@ -7,6 +7,7 @@ const uuid_1 = require("../crypto/uuid");
 const mapping_1 = require("../../class/mapping");
 const index_1 = require("../qs/index");
 const event_1 = require("../../class/event");
+const pipeline_1 = require("../hook/modules/pipeline");
 const Socks5Event = {
     Error: 'error',
 };
@@ -22,6 +23,7 @@ class Socks5 {
     __uuid;
     __port = 0;
     __event;
+    __pipeline;
     constructor(upstreamProxy, allowedDomains = ['*'], debug = false) {
         this.__event = new event_1.default();
         this.upstreamProxy = upstreamProxy;
@@ -29,6 +31,7 @@ class Socks5 {
         this.__debug = debug;
         this.__uuid = (0, uuid_1.default)();
         this.connectionPool = new mapping_1.default();
+        this.__pipeline = new pipeline_1.default(1);
     }
     get id() {
         return this.__uuid;
@@ -115,6 +118,11 @@ class Socks5 {
         return 0;
     }
     async handleSocksConnection(clientSocket) {
+        this.__pipeline.push(() => this._handleSocksConnection(clientSocket));
+    }
+    async _handleSocksConnection(clientSocket) {
+        if (!clientSocket)
+            return;
         this.clientSockets.add(clientSocket);
         clientSocket.on('close', () => {
             this.clientSockets.delete(clientSocket);
@@ -126,20 +134,21 @@ class Socks5 {
             await this.performHandshake(clientSocket);
             const destination = await this.parseClientRequest(clientSocket);
             addrport = `${destination.addr}:${destination.port}`;
+            const clienAddrport = `${clientSocket.localAddress}:${clientSocket.localPort}`;
             if (this.isAllowedDomain(destination.addr)) {
                 // 走上游代理
                 const upstreamSocket = await this.connectToUpstreamProxy(destination);
-                this.__debug && console.info(`[socks] handle connection upstream`, addrport);
+                this.__debug && console.info(`[socks] handle connection upstream`, addrport, clienAddrport);
                 this.setupDataForwarding(clientSocket, upstreamSocket);
             }
             else if (this.useSystemProxy && this.systemProxy) {
                 // 走系统代理
                 const systemSocket = await this.connectToSystemProxy(destination);
-                this.__debug && console.info(`[socks] handle connection system`, addrport);
+                this.__debug && console.info(`[socks] handle connection system`, addrport, clienAddrport);
                 this.setupDataForwarding(clientSocket, systemSocket);
             }
             else {
-                this.__debug && console.info(`[socks] handle connection local`, addrport);
+                this.__debug && console.info(`[socks] handle connection local`, addrport, clienAddrport);
                 // 本地连接
                 const localSocket = await this.connectToLocal(destination);
                 this.setupDataForwarding(clientSocket, localSocket);
@@ -212,10 +221,6 @@ class Socks5 {
             return undefined;
         const connection = this.connectionPool.get(key);
         // 如果已有连接在池中，复用
-        if (this.connectionPool[key] && !this.connectionPool[key].destroyed) {
-            return this.connectionPool[key];
-        }
-        // 如果已有连接在池中，复用
         if (connection && !connection.destroyed) {
             return connection;
         }
@@ -304,14 +309,14 @@ class Socks5 {
         clientSocket.write(new Uint8Array([0x05, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]));
         clientSocket.pipe(targetSocket);
         targetSocket.pipe(clientSocket);
-        const localIpPort = `${targetSocket.localAddress}:${targetSocket.localPort}`;
-        this.__debug && console.info(`[socks] setupDataForwarding ${localIpPort}`);
+        const addrPort = `${targetSocket.localAddress}:${targetSocket.localPort}`;
+        this.__debug && console.info(`[socks] setupDataForwarding ${addrPort}`);
         clientSocket.on('close', () => {
-            this.__debug && console.info('[socks] client socket close', localIpPort);
+            this.__debug && console.info('[socks] client socket close', addrPort);
             targetSocket.end();
         });
         targetSocket.on('close', () => {
-            this.__debug && console.info('[socks] target socket close', localIpPort);
+            this.__debug && console.info('[socks] target socket close', addrPort);
             clientSocket.end();
         });
         clientSocket.on('error', (err) => {

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

@@ -13,9 +13,9 @@ export default class Ecdh {
     exportKey(cryptoKey: CryptoKey, keyFormat?: TKeyFormat): Promise<string>;
     importKey(keyBase64: string, keyFormat?: TKeyFormat, usages?: KeyUsage[]): Promise<CryptoKey>;
     setPrivateKey(privateBase64: string): Promise<boolean>;
-    deriveSharedSecret(publicKeyBase64: string, iv: string): Promise<boolean>;
-    encode(data: string): Promise<string>;
-    encodeiv(data: string): Promise<string>;
+    deriveSharedSecret(publicKeyBase64: string, iv?: string): Promise<boolean>;
+    encode(data: string, iv?: string): Promise<string>;
+    encodeiv(data: string, iv?: string): Promise<string>;
     decode(encrypted: string, iv?: string): Promise<string>;
     decodeiv(encrypted: string): Promise<string>;
 }

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

@@ -5,15 +5,16 @@ export default class Ecdh {
     privateKey: string;
     sharedSecret: string | undefined;
     iv: string;
-    _curve: string;
-    _algorithm: string;
-    _ecdh: crypto.ECDH | undefined;
+    __curve: string;
+    __algorithm: string;
+    __ecdh: crypto.ECDH | undefined;
     constructor(curve?: string, algorithm?: string);
-    generateKey(): void;
-    deriveSharedSecret(otherPublicKey: string, iv: string): boolean;
+    generateKeys(): void;
     setPrivateKey(privateBase64: string): boolean;
-    encode(data: string): string;
-    encodeiv(data: string): string;
+    setSharedSecret(secretBase64: string): boolean;
+    deriveSharedSecret(otherPublicKey: string, iv?: string): boolean;
+    encode(data: string, iv?: string): string;
+    encodeiv(data: string, iv?: string): string;
     decode(encrypted: string, iv?: string): string;
     decodeiv(encrypted: string): string;
 }

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

@@ -1,4 +1,5 @@
 import DEvent from '../../class/event';
+import DPipeline from '../hook/modules/pipeline';
 interface IProxyConfig {
     ipaddress: string;
     port: number;
@@ -22,6 +23,7 @@ export declare class Socks5 {
     __uuid: string;
     __port: number;
     __event: DEvent;
+    __pipeline: DPipeline;
     constructor(upstreamProxy: IProxyConfig, allowedDomains?: string[] | ['*'], debug?: boolean);
     get id(): string;
     get port(): number;
@@ -32,6 +34,7 @@ export declare class Socks5 {
     setAllowedDomains(allowedDomains?: string[]): void;
     private findAvailablePort;
     private handleSocksConnection;
+    private _handleSocksConnection;
     /**
      * 回复客户端请求响应数据
      * VER是SOCKS版本，这里应该是0x05；

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddan-js",
-  "version": "2.6.39",
+  "version": "2.6.41",
   "description": "",
   "keywords": [
     "ddan-js",