ddan-js 2.7.6 → 2.7.8

package/bin/lib/modules/crypto/rsa.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const convert_1 = require("../convert");
+const RSAPublicKey = `MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEApiLWsPmoaiGdr02AmPYS
+4/VgxyJNNJSK2VICirXl4P8qAP3b/6GIs7Hwnsmmuj7gledJ0XiZodFjDNgQEZEG
+j4K9KX8NixcrJwnTQV5UebiERdj+64ihwqPVWo9dIOj43ZPJ8f4dritJv5tnQaBb
+b9zTkU3Ofzk1g8RU00Ith6quOGZcU2IWC4OQ+5YiZvzrCBKEvjFwK2OvGq43tI51
+GaZdI9H09jisypqefsMvv6esjEQQOtl+WGlI5fof7KZUt3dppvuDI4CYgeXIoKKL
+9T9qDl8F9aNSs3XHx32YyA7L1FraFD6PjqRjueIFp2emsXQcIMeMqqgVyV+4qb+0
+uwIDAQAB`;
+const RSAPrivateKey = `MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCmItaw+ahqIZ2v
+TYCY9hLj9WDHIk00lIrZUgKKteXg/yoA/dv/oYizsfCeyaa6PuCV50nReJmh0WMM
+2BARkQaPgr0pfw2LFysnCdNBXlR5uIRF2P7riKHCo9Vaj10g6Pjdk8nx/h2uK0m/
+m2dBoFtv3NORTc5/OTWDxFTTQi2Hqq44ZlxTYhYLg5D7liJm/OsIEoS+MXArY68a
+rje0jnUZpl0j0fT2OKzKmp5+wy+/p6yMRBA62X5YaUjl+h/splS3d2mm+4MjgJiB
+5cigoov1P2oOXwX1o1KzdcfHfZjIDsvUWtoUPo+OpGO54gWnZ6axdBwgx4yqqBXJ
+X7ipv7S7AgMBAAECggEAE1kuWLkSsJ2OoDpt9iJ+a7cJmNd5V1zPWOTwr9fkWFJP
+QYNPKlPVOFxKUivY84rcHAkuMyuQ9OQOXZISOQGDWpZW0mzeFmtR1r+Rr2S9gNmI
+6huOAL9OW306HUxiA7GuPhv2omy+Zyjac2q1WVLEI2B78Um2+WEfxuNIH7xu0gRR
+z/wluevMBQlv6hSeMESP6e9s2kB+FuM4bL7+1sexwS1TudKbHybujaiB8un9E2V3
+C9BkE6yf00Rhvii6Q4E4w3PFQfcBEFnjOD0S2Watx8GIbYjlYvtquy8Yj7OtyZB6
+w5sxyaYhKVVnkpGAbOgaCj94ABYF47VuwXr45I4PzQKBgQDp6svzD+QKlARjcWgO
+rH7UEpFX6m49G6Ib4c63xEg9+GesTgfDxoYxtXDKsC7I8OwMrmffJGbyfjaAvzmg
+icM3Y7kF6UPO9+q2mBRsyhoJSNONTeUVyoFSc+QDsVgndlTZIjqC5XLrONGaSPLJ
+7jJzqKhp3NQcpO8+xY0d7Efm1QKBgQC10fCNuF1LUTYgsWvvGxTiCCAIBurZmHU+
+GMb2Okfoco/P+QNl1jEba91AC7FudW3g/lRn0vTnDajlNoz2/CKunrTKN4/9lEBI
+tiwEOvhc5FtapRifSfrrNwFqPM+LijvOkcteWVhAUWCEP1eLmpnXGqfmZxnTaaVe
+5DyDgyAVTwKBgQDhEawfOQEANJ9sV2f6BnsZ7quuXcCoR3hZP5G5O8EO735BSesq
+sk/YcG4QeCjr6vQU15LWH552YH5srpHyJ9uP5gHW8DTwZZaPDhFJA8S9fjcfVP3B
+U9HO1fdknjTl83N8YPTPkZpbPZZfzyTcqrYclwFEqtfkn8YbLdW0Hu6n6QKBgDEv
+jvS3uD1ExfDILlurptWSvx+Mx4F/1c+roj8/+u3t9+uaAIpPDE/PuTW3NBOens/r
+3WeM0QWkU1lWjYHPKY61jlDaARDnRxCkf3nRfhibCf+Wg/erar6wzagwtTCZf55d
+IHfwkYgsu4BrJkK02wMuydbxczIW9U6bTaeCFG7PAoGAN3oHYzTEBwZ7ZKv11QiQ
+Ep/HeHBvD8fH/e1uVyBel4Co7NO5pV2s8qjS8+3+jxumKLNXCirjqwHo03YCdzxi
+cy4GFDsukHmDQ7FF9VC4QV0fJ0F7jGYE9nNZ+K9qwS5KrihOSBPxj0HptrF6TSOw
+BTSwr0byL3TC0m0StkSNKpo=`;
+const generateKeys = async (subtle) => {
+    try {
+        // 生成RSA密钥对
+        const keyPair = await subtle.generateKey({
+            name: 'RSA-OAEP',
+            modulusLength: 2048,
+            publicExponent: new Uint8Array([1, 0, 1]),
+            hash: 'SHA-256',
+        }, true, // 是否可导出密钥
+        ['encrypt', 'decrypt']);
+        // 导出公钥为SPKI格式（可共享）
+        const publicBuffer = await window.crypto.subtle.exportKey('spki', keyPair.publicKey);
+        const publicKey = format_pem_content(publicBuffer);
+        const publicKeyPem = format_pem_key(publicKey, 'PUBLIC KEY');
+        // 导出私钥为PKCS#8格式（需保护）
+        const privateBuffer = await window.crypto.subtle.exportKey('pkcs8', keyPair.privateKey);
+        const privateKey = format_pem_content(privateBuffer);
+        const privateKeyPem = format_pem_key(privateKey, 'PRIVATE KEY');
+        return {
+            publicKey,
+            publicKeyPem,
+            privateKey,
+            privateKeyPem,
+        };
+    }
+    catch (err) {
+        console.error('generateKeys failed:', err);
+        return {
+            publicKey: '',
+            publicKeyPem: '',
+            privateKey: '',
+            privateKeyPem: '',
+        };
+    }
+};
+const format_pem_content = (buffer) => {
+    try {
+        const base64String = convert_1.default.ab2str(buffer, true);
+        return base64String.match(/.{1,64}/g)?.join('\n') || '';
+    }
+    catch (error) {
+        return '';
+    }
+};
+const format_pem_key = (pemContent = '', label = 'PUBLIC KEY') => {
+    return `-----BEGIN ${label}-----\n${pemContent}\n-----END ${label}-----`;
+};
+// SHA256: 256 - 2 - 2*32  = 190
+// SHA1: 256 - 2 - 2*20  = 214
+const maxChunkSize = 190;
+const encrypt = async (subtle, data, publicKey) => {
+    try {
+        const bytes = new TextEncoder().encode(data);
+        const key = await subtle.importKey('spki', convert_1.default.str2ab(publicKey, true), {
+            name: 'RSA-OAEP',
+            hash: 'SHA-256',
+        }, true, ['encrypt']);
+        const encryptedChunks = [];
+        for (let i = 0; i < bytes.length; i += maxChunkSize) {
+            let chunk = bytes.slice(i, i + maxChunkSize);
+            let encryptedChunk = await subtle.encrypt({
+                name: 'RSA-OAEP',
+            }, key, chunk);
+            encryptedChunks.push(new Uint8Array(encryptedChunk));
+        }
+        const enctryptedBytes = convert_1.default.concatBytes(...encryptedChunks);
+        return convert_1.default.bytesToBase64(enctryptedBytes);
+    }
+    catch (error) {
+        console.error(`[debug] encrypt`, error);
+        return '';
+    }
+};
+const decrypt = async (subtle, encryptedBase64, privateKey) => {
+    try {
+        const encrypted = convert_1.default.base64ToBytes(encryptedBase64);
+        const key = await subtle.importKey('pkcs8', convert_1.default.str2ab(privateKey, true), {
+            name: 'RSA-OAEP',
+            hash: 'SHA-256',
+        }, true, ['decrypt']);
+        const decryptedChunks = [];
+        const chunkSize = 256; // 每个加密块的大小（2048位 RSA 的加密输出为 256 字节）
+        for (let i = 0; i < encrypted.length; i += chunkSize) {
+            let chunk = encrypted.slice(i, i + chunkSize);
+            let decryptedChunk = await subtle.decrypt({
+                name: 'RSA-OAEP',
+            }, key, chunk);
+            // 添加解密后的数据
+            decryptedChunks.push(new Uint8Array(decryptedChunk));
+        }
+        const encryptedBytes = convert_1.default.concatBytes(...decryptedChunks);
+        return convert_1.default.bytesToStr(encryptedBytes);
+    }
+    catch (err) {
+        console.error('decrypt failed:', err);
+        return '';
+    }
+};
+exports.default = {
+    RSAPublicKey,
+    RSAPrivateKey,
+    generateKeys,
+    format_pem_key,
+    format_pem_content,
+    encrypt,
+    decrypt,
+};

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

@@ -6,4 +6,5 @@ const socks5_1 = require("./socks5");
 const child_1 = require("./child");
 const proxy_1 = require("./proxy");
 const ecdh_web_1 = require("./ecdh-web");
-exports.default = { ...brotli_1.default, ...child_1.default, ...proxy_1.default, Ecdh: ecdh_1.default, EcdhWeb: ecdh_web_1.default, Socks5: socks5_1.Socks5 };
+const rsa_web_1 = require("./rsa-web");
+exports.default = { ...brotli_1.default, ...child_1.default, ...proxy_1.default, Ecdh: ecdh_1.default, EcdhWeb: ecdh_web_1.default, Socks5: socks5_1.Socks5, rsa: rsa_web_1.default };

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

@@ -135,13 +135,13 @@ const pacScript = async (host, port, options) => {
     const pac_proxy = toPacProxy(host, port, { type });
     if (!pac_proxy)
         return "";
-    let pac_sys = undefined;
+    let pac_default = undefined;
     if (useSystem) {
         const sysproxy = await getSystemProxy();
         if (sysproxy) {
-            pac_sys = toPacProxy(sysproxy?.ipaddress || '', sysproxy?.port || 0, { direct: true });
+            pac_default = toPacProxy(sysproxy?.ipaddress || '', sysproxy?.port || 0, { direct: true });
         }
     }
-    return toPacScript(pac_proxy, rules || [], pac_sys);
+    return toPacScript(pac_proxy, rules || [], pac_default);
 };
 exports.default = { getSystemProxy, toPacScript, toPacProxy, pacScript };

package/bin/lib/modules/node/rsa-web.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rsa_1 = require("../crypto/rsa");
+const crypto_1 = require("crypto");
+const getSubtle = () => crypto_1.default.webcrypto.subtle;
+const generateKeys = () => rsa_1.default.generateKeys(getSubtle());
+// SHA256: 256 - 2 - 2*32  = 190
+// SHA1: 256 - 2 - 2*20  = 214
+const encrypt = async (data, publicKey) => rsa_1.default.encrypt(getSubtle(), data, publicKey);
+const decrypt = async (encryptedBase64, privateKey) => rsa_1.default.decrypt(getSubtle(), encryptedBase64, privateKey);
+const encode = async (data) => rsa_1.default.encrypt(getSubtle(), data, rsa_1.default.RSAPublicKey);
+const decode = async (encryptedBase64) => rsa_1.default.decrypt(getSubtle(), encryptedBase64, rsa_1.default.RSAPrivateKey);
+exports.default = {
+    generateKeys,
+    encrypt,
+    decrypt,
+    encode,
+    decode,
+};

package/bin/lib/modules/rsa.js

@@ -1,92 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const convert_1 = require("./convert");
-const generateKeys = async () => {
-    try {
-        // 生成RSA密钥对
-        const keyPair = await window.crypto.subtle.generateKey({
-            name: 'RSA-OAEP',
-            modulusLength: 2048,
-            publicExponent: new Uint8Array([1, 0, 1]),
-            hash: 'SHA-256',
-        }, true, // 是否可导出密钥
-        ['encrypt', 'decrypt']);
-        // 导出公钥为SPKI格式（可共享）
-        const publicBuffer = await window.crypto.subtle.exportKey('spki', keyPair.publicKey);
-        const publicKey = format_pem_content(publicBuffer);
-        const publicKeyPem = format_pem_key(publicKey, 'PUBLIC KEY');
-        // 导出私钥为PKCS#8格式（需保护）
-        const privateBuffer = await window.crypto.subtle.exportKey('pkcs8', keyPair.privateKey);
-        const privateKey = format_pem_content(privateBuffer);
-        const privateKeyPem = format_pem_key(privateKey, 'PRIVATE KEY');
-        return {
-            publicKey,
-            publicKeyPem,
-            privateKey,
-            privateKeyPem,
-        };
-    }
-    catch (err) {
-        console.error('generateKeys failed:', err);
-        return {
-            publicKey: "",
-            publicKeyPem: "",
-            privateKey: "",
-            privateKeyPem: ""
-        };
-    }
-};
-const format_pem_content = (buffer) => {
-    try {
-        const base64String = convert_1.default.ab2str(buffer, true);
-        return base64String.match(/.{1,64}/g)?.join('\n') || '';
-    }
-    catch (error) {
-        return '';
-    }
-};
-const format_pem_key = (pemContent = '', label = 'PUBLIC KEY') => {
-    return `-----BEGIN ${label}-----\n${pemContent}\n-----END ${label}-----`;
-};
-const encrypt = async (data, publicKey) => {
-    try {
-        const encodedData = new TextEncoder().encode(data);
-        const key = await window.crypto.subtle.importKey('spki', convert_1.default.str2ab(publicKey, true), {
-            name: 'RSA-OAEP',
-            hash: 'SHA-256',
-        }, true, ['encrypt']);
-        const encrypted = await window.crypto.subtle.encrypt({
-            name: 'RSA-OAEP',
-        }, key, encodedData);
-        return convert_1.default.ab2str(encrypted, true);
-    }
-    catch (err) {
-        console.error('encrypt failed:', err);
-        return '';
-    }
-};
-const decrypt = async (encryptedData, privateKey) => {
-    try {
-        const encrypted = convert_1.default.str2ab(encryptedData, true);
-        const key = await window.crypto.subtle.importKey('pkcs8', convert_1.default.str2ab(privateKey, true), {
-            name: 'RSA-OAEP',
-            hash: 'SHA-256',
-        }, true, ['decrypt']);
-        const decrypted = await window.crypto.subtle.decrypt({
-            name: 'RSA-OAEP',
-        }, key, encrypted);
-        const decodedData = new TextDecoder().decode(decrypted);
-        return decodedData;
-    }
-    catch (err) {
-        console.error('decrypt failed:', err);
-        return '';
-    }
-};
+const rsa_1 = require("./crypto/rsa");
+const __subtle = ((typeof window !== 'undefined') ? window.crypto.subtle : {});
+const generateKeys = () => rsa_1.default.generateKeys(__subtle);
+// SHA256: 256 - 2 - 2*32  = 190
+// SHA1: 256 - 2 - 2*20  = 214
+const encrypt = async (data, publicKey) => rsa_1.default.encrypt(__subtle, data, publicKey);
+const decrypt = async (encryptedBase64, privateKey) => rsa_1.default.decrypt(__subtle, encryptedBase64, privateKey);
+const encode = async (data) => rsa_1.default.encrypt(__subtle, data, rsa_1.default.RSAPublicKey);
+const decode = async (encryptedBase64) => rsa_1.default.decrypt(__subtle, encryptedBase64, rsa_1.default.RSAPrivateKey);
 exports.default = {
     generateKeys,
-    format_pem_key,
-    format_pem_content,
     encrypt,
     decrypt,
+    encode,
+    decode,
 };

package/bin/types/class/mapping.d.ts

@@ -5,6 +5,7 @@ export default class Mapping<T = any> {
     get keys(): string[];
     get values(): KValue<T>[];
     get(key: string): T | undefined;
+    getKV(key: string): KValue<T> | undefined;
     set(key: string, value?: T): void;
     delete(key: string, cb?: (value?: T, key?: string) => void): void;
     clear(): void;

package/bin/types/index.d.ts

@@ -557,16 +557,28 @@ declare const dWeb: {
             privateKey: string;
             privateKeyPem: string;
         }>;
-        format_pem_key: (pemContent?: string, label?: string) => string;
-        format_pem_content: (buffer: ArrayBuffer) => string;
         encrypt: (data: string, publicKey: string) => Promise<string>;
-        decrypt: (encryptedData: string, privateKey: string) => Promise<string>;
+        decrypt: (encryptedBase64: string, privateKey: string) => Promise<string>;
+        encode: (data: string) => Promise<string>;
+        decode: (encryptedBase64: string) => Promise<string>;
     };
 };
 declare const dNode: {
     Ecdh: typeof import("./modules/node/ecdh").default;
     EcdhWeb: typeof import("./modules/node/ecdh-web").default;
     Socks5: typeof import("./modules/node/socks5").Socks5;
+    rsa: {
+        generateKeys: () => Promise<{
+            publicKey: string;
+            publicKeyPem: string;
+            privateKey: string;
+            privateKeyPem: string;
+        }>;
+        encrypt: (data: string, publicKey: string) => Promise<string>;
+        decrypt: (encryptedBase64: string, privateKey: string) => Promise<string>;
+        encode: (data: string) => Promise<string>;
+        decode: (encryptedBase64: string) => Promise<string>;
+    };
     getSystemProxy: () => Promise<{
         ipaddress: string;
         port: number;
@@ -968,10 +980,10 @@ declare const _default: {
             privateKey: string;
             privateKeyPem: string;
         }>;
-        format_pem_key: (pemContent?: string, label?: string) => string;
-        format_pem_content: (buffer: ArrayBuffer) => string;
         encrypt: (data: string, publicKey: string) => Promise<string>;
-        decrypt: (encryptedData: string, privateKey: string) => Promise<string>;
+        decrypt: (encryptedBase64: string, privateKey: string) => Promise<string>;
+        encode: (data: string) => Promise<string>;
+        decode: (encryptedBase64: string) => Promise<string>;
     };
 };
 export default _default;

package/bin/types/modules/crypto/rsa.d.ts

@@ -0,0 +1,15 @@
+declare const _default: {
+    RSAPublicKey: string;
+    RSAPrivateKey: string;
+    generateKeys: (subtle: any) => Promise<{
+        publicKey: string;
+        publicKeyPem: string;
+        privateKey: string;
+        privateKeyPem: string;
+    }>;
+    format_pem_key: (pemContent?: string, label?: string) => string;
+    format_pem_content: (buffer: ArrayBuffer) => string;
+    encrypt: (subtle: any, data: string, publicKey: string) => Promise<string>;
+    decrypt: (subtle: any, encryptedBase64: string, privateKey: string) => Promise<string>;
+};
+export default _default;

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

@@ -5,6 +5,18 @@ declare const _default: {
     Ecdh: typeof Ecdh;
     EcdhWeb: typeof EcdhWeb;
     Socks5: typeof Socks5;
+    rsa: {
+        generateKeys: () => Promise<{
+            publicKey: string;
+            publicKeyPem: string;
+            privateKey: string;
+            privateKeyPem: string;
+        }>;
+        encrypt: (data: string, publicKey: string) => Promise<string>;
+        decrypt: (encryptedBase64: string, privateKey: string) => Promise<string>;
+        encode: (data: string) => Promise<string>;
+        decode: (encryptedBase64: string) => Promise<string>;
+    };
     getSystemProxy: () => Promise<{
         ipaddress: string;
         port: number;

package/bin/types/modules/node/rsa-web.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    generateKeys: () => Promise<{
+        publicKey: string;
+        publicKeyPem: string;
+        privateKey: string;
+        privateKeyPem: string;
+    }>;
+    encrypt: (data: string, publicKey: string) => Promise<string>;
+    decrypt: (encryptedBase64: string, privateKey: string) => Promise<string>;
+    encode: (data: string) => Promise<string>;
+    decode: (encryptedBase64: string) => Promise<string>;
+};
+export default _default;

package/bin/types/modules/rsa.d.ts

@@ -5,9 +5,9 @@ declare const _default: {
         privateKey: string;
         privateKeyPem: string;
     }>;
-    format_pem_key: (pemContent?: string, label?: string) => string;
-    format_pem_content: (buffer: ArrayBuffer) => string;
     encrypt: (data: string, publicKey: string) => Promise<string>;
-    decrypt: (encryptedData: string, privateKey: string) => Promise<string>;
+    decrypt: (encryptedBase64: string, privateKey: string) => Promise<string>;
+    encode: (data: string) => Promise<string>;
+    decode: (encryptedBase64: string) => Promise<string>;
 };
 export default _default;

package/package.json

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