ddan-js 2.6.17 → 2.6.19

package/bin/lib/modules/node/socks-server.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocksServer = void 0;
+const net_1 = require("net");
+const socks_1 = require("socks");
+class SocksServer {
+    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 = debug;
+    }
+    validateProxyConfig() {
+        const { ipaddress, port, userId, password } = this.upstreamProxy;
+        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.validateProxyConfig())
+            return 0;
+        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.SocksServer = SocksServer;

package/bin/lib/util/is.js

@@ -1,24 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const _object_1 = require("../common/_object");
+const _root_1 = require("../common/_root");
+const nodeTypes_1 = require("../common/internal/nodeTypes");
 /** `Object#toString` result references. */
 var argsTag = '[object Arguments]', funcTag = '[object Function]', genTag = '[object GeneratorFunction]', asyncTag = '[object AsyncFunction]', stringTag = '[object String]', promiseTag = '[object Promise]';
 var MAX_SAFE_INTEGER = 9007199254740991, NAN = 0 / 0;
 /** Used to detect unsigned integer values. */
 const reIsUint = /^(?:0|[1-9]\d*)$/;
+const nativeIsBuffer = _root_1.default?.Buffer?.isBuffer;
+const reTypedTag = /^\[object (?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)Array\]$/;
+/* Node.js helper references. */
+const nodeIsTypedArray = nodeTypes_1.default && nodeTypes_1.default.isTypedArray;
 function is(val, type) {
     return _object_1.default.getTag(val) === `[object ${type}]`;
 }
 function isNumber(value) {
-    return _object_1.default.getTag(value) === "[object Number]";
+    return _object_1.default.getTag(value) === '[object Number]';
 }
 function isString(value) {
-    return typeof value == 'string' ||
-        (!isArray(value) && isObjectLike(value) && _object_1.default.getTag(value) == stringTag);
+    return (typeof value == 'string' ||
+        (!isArray(value) && isObjectLike(value) && _object_1.default.getTag(value) == stringTag));
 }
 function isObject(value) {
     const type = typeof value;
-    return value != null && (type == "object" || type == "function");
+    return value != null && (type == 'object' || type == 'function');
 }
 function isObjectLike(value) {
     return value != null && typeof value == 'object';
@@ -37,7 +43,8 @@ function isPlainObject(value) {
     return Object.getPrototypeOf(value) === proto;
 }
 function isSymbol(value) {
-    return typeof value === 'symbol' || (isObjectLike(value) && _object_1.default.getTag(value) === '[object Symbol]');
+    return (typeof value === 'symbol' ||
+        (isObjectLike(value) && _object_1.default.getTag(value) === '[object Symbol]'));
 }
 const isArray = Array.isArray;
 function isArrayLike(value) {
@@ -55,22 +62,24 @@ function isPromise(value) {
     return tag === promiseTag;
 }
 function isLength(value) {
-    return typeof value == 'number' &&
-        value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+    return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
 }
 function isIndex(value, length) {
     length = length == null ? MAX_SAFE_INTEGER : length;
-    return !!length &&
+    return (!!length &&
         (typeof value == 'number' || reIsUint.test(value)) &&
-        (value > -1 && value % 1 == 0 && value < length);
+        value > -1 &&
+        value % 1 == 0 &&
+        value < length);
 }
 function isPrototype(value) {
     var Ctor = value && value.constructor, proto = (typeof Ctor == 'function' && Ctor.prototype) || Object.prototype;
     return value === proto;
 }
 function isArguments(value) {
-    return isArrayLikeObject(value) && _object_1.default.hasOwnProperty.call(value, 'callee') &&
-        (!_object_1.default.propertyIsEnumerable.call(value, 'callee') || _object_1.default.toString.call(value) == argsTag);
+    return (isArrayLikeObject(value) &&
+        _object_1.default.hasOwnProperty.call(value, 'callee') &&
+        (!_object_1.default.propertyIsEnumerable.call(value, 'callee') || _object_1.default.toString.call(value) == argsTag));
 }
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
 const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
@@ -83,6 +92,37 @@ const isUint8Array = (data) => {
 const isArrayBuffer = (data) => {
     return data instanceof ArrayBuffer;
 };
+const isTypedArray = nodeIsTypedArray
+    ? (value) => nodeIsTypedArray(value)
+    : (value) => isObjectLike(value) && reTypedTag.test(_object_1.default.getTag(value));
+const isBuffer = typeof nativeIsBuffer === 'function' ? nativeIsBuffer : () => false;
+const isEmpty = (value) => {
+    if (value == null) {
+        return true;
+    }
+    if (isArrayLike(value) &&
+        (Array.isArray(value) ||
+            typeof value === 'string' ||
+            typeof value.splice === 'function' ||
+            isBuffer(value) ||
+            isTypedArray(value) ||
+            isArguments(value))) {
+        return !value.length;
+    }
+    const tag = _object_1.default.getTag(value);
+    if (tag === '[object Map]' || tag === '[object Set]') {
+        return !value.size;
+    }
+    if (isPrototype(value)) {
+        return !Object.keys(value).length;
+    }
+    for (const key in value) {
+        if (_object_1.default.hasOwnProperty.call(value, key)) {
+            return false;
+        }
+    }
+    return true;
+};
 exports.default = {
     is,
     isNumber,
@@ -103,5 +143,6 @@ exports.default = {
     isNode,
     isBlobOrBuffer,
     isUint8Array,
-    isArrayBuffer
+    isArrayBuffer,
+    isEmpty,
 };

package/bin/types/common/_freeGlobal.d.ts

@@ -1,3 +1,3 @@
 /** Detect free variable `global` from Node.js. */
-declare var freeGlobal: any;
+declare const freeGlobal: any;
 export default freeGlobal;

package/bin/types/common/_root.d.ts

@@ -1,3 +1,3 @@
 /** Used as a reference to the global object. */
-declare var root: any;
+declare const root: any;
 export default root;

package/bin/types/common/internal/nodeTypes.d.ts

@@ -0,0 +1,3 @@
+/** Used to access faster Node.js helpers. */
+declare const nodeTypes: any;
+export default nodeTypes;

package/bin/types/index.d.ts

@@ -500,7 +500,8 @@ declare const dWeb: {
 };
 declare const dNode: {
     Ecdh: typeof import("./modules/node/ecdh").default;
-    EcdhSpki: typeof import("./modules/node/ecdhSpki").default;
+    EcdhSpki: typeof import("./modules/node/ecdh-spki").default;
+    SocksServer: typeof import("./modules/node/socks-server").SocksServer;
     brotliCompress: typeof import("./modules/node/brotli").brotliCompress;
     brotliDecompress: typeof import("./modules/node/brotli").brotliDecompress;
 };

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

@@ -1,8 +1,10 @@
 import Ecdh from "./ecdh";
-import EcdhSpki from "./ecdhSpki";
+import EcdhSpki from "./ecdh-spki";
+import { SocksServer } from "./socks-server";
 declare const _default: {
     Ecdh: typeof Ecdh;
     EcdhSpki: typeof EcdhSpki;
+    SocksServer: typeof SocksServer;
     brotliCompress: typeof import("./brotli").brotliCompress;
     brotliDecompress: typeof import("./brotli").brotliDecompress;
 };

package/bin/types/modules/node/socks-server.d.ts

@@ -0,0 +1,28 @@
+interface IProxyConfig {
+    ipaddress: string;
+    port: number;
+    type?: 5;
+    userId: string;
+    password: string;
+}
+export declare class SocksServer {
+    private upstreamProxy;
+    private server;
+    private clientSockets;
+    private allowedDomains;
+    private connectionPool;
+    __debug: boolean;
+    constructor(upstreamProxy: IProxyConfig, allowedDomains?: string[], debug?: boolean);
+    validateProxyConfig(): "无效的上游代理 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/bin/types/util/is.d.ts

@@ -33,5 +33,6 @@ declare const _default: {
     isBlobOrBuffer: (data: any) => boolean;
     isUint8Array: (data: any) => boolean;
     isArrayBuffer: (data: any) => boolean;
+    isEmpty: (value: any) => boolean;
 };
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddan-js",
-  "version": "2.6.17",
+  "version": "2.6.19",
   "description": "",
   "keywords": [
     "ddan-js",
@@ -143,5 +143,8 @@
     "tslint-config-standard": "^9.0.0",
     "typedoc": "^0.24.0",
     "typescript": "^5.0.4"
+  },
+  "dependencies": {
+    "socks": "^2.8.3"
   }
 }