feat: sing-box 支持 Shadowsocks/Snell/VMess/VLESS/Trojan 搭配 ShadowTLS

Author: xream

backend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sub-store",
-  "version": "2.36.12",
+  "version": "2.36.13",
   "description": "Advanced Subscription Manager for QX, Loon, Surge, Stash and Shadowrocket.",
   "main": "src/main.js",
   "packageManager": "pnpm@11.0.9",

backend/src/core/proxy-utils/producers/sing-box.js

@@ -1300,11 +1300,10 @@ export default function singbox_Producer() {
     const type = 'ALL';
     const produce = (proxies, type, opts = {}) => {
         const list = [];
-        const originalSnellShadowTLS = new Map(
+        const originalShadowTLS = new Map(
             proxies
                 .filter(
                     (proxy) =>
-                        proxy?.type === 'snell' &&
                         proxy?.plugin === 'shadow-tls' &&
                         proxy?.['plugin-opts'],
                 )
@@ -1324,22 +1323,81 @@ export default function singbox_Producer() {
         ClashMeta_Producer()
             .produce(proxies, 'internal', { 'include-unsupported-proxy': true })
             .map((proxy) => {
+                const listStart = list.length;
                 try {
-                    const originalShadowTLS = originalSnellShadowTLS.get(proxy);
-                    if (originalShadowTLS) {
-                        proxy.plugin = originalShadowTLS.plugin;
-                        proxy['plugin-opts'] = originalShadowTLS['plugin-opts'];
-                        if (originalShadowTLS['obfs-opts']) {
-                            proxy['obfs-opts'] = originalShadowTLS['obfs-opts'];
+                    const shadowTLS = originalShadowTLS.get(proxy);
+                    if (shadowTLS) {
+                        proxy.plugin = shadowTLS.plugin;
+                        proxy['plugin-opts'] = shadowTLS['plugin-opts'];
+                        if (shadowTLS['obfs-opts']) {
+                            proxy['obfs-opts'] = shadowTLS['obfs-opts'];
                         } else {
                             delete proxy['obfs-opts'];
                         }
                     }
+                    const shadowTLSPluginOpts = getShadowTLSPluginOpts(proxy);
+                    const shadowTLSEnabled = Boolean(
+                        shadowTLSPluginOpts &&
+                            (shadowTLSPluginOpts.password ||
+                                (shadowTLSPluginOpts.version != null &&
+                                    Number(shadowTLSPluginOpts.version) !== 0)),
+                    );
+                    let streamShadowTLSOutbound;
+                    if (
+                        shadowTLSEnabled &&
+                        ['vmess', 'vless', 'trojan'].includes(proxy.type)
+                    ) {
+                        if (proxy['reality-opts']) {
+                            throw new Error(
+                                `Platform sing-box cannot chain ShadowTLS with Reality for proxy ${proxy.name}`,
+                            );
+                        }
+                        if (
+                            ['vmess', 'vless'].includes(proxy.type) &&
+                            proxy.network === 'h2'
+                        ) {
+                            throw new Error(
+                                `Platform sing-box cannot chain ShadowTLS with network h2 for proxy ${proxy.name}`,
+                            );
+                        }
+                        if (
+                            proxy.type === 'vless' &&
+                            proxy.flow === 'xtls-rprx-vision'
+                        ) {
+                            throw new Error(
+                                `Platform sing-box cannot chain ShadowTLS with flow xtls-rprx-vision for proxy ${proxy.name}`,
+                            );
+                        }
+
+                        const rawVersion = shadowTLSPluginOpts.version;
+                        const parsedVersion =
+                            typeof rawVersion === 'string' &&
+                            rawVersion.trim() === ''
+                                ? NaN
+                                : Number(rawVersion ?? 0);
+                        const version = parsedVersion === 0 ? 2 : parsedVersion;
+                        if (
+                            !Number.isInteger(version) ||
+                            ![1, 2, 3].includes(version)
+                        ) {
+                            throw new Error(
+                                `Platform sing-box does not support shadow-tls version ${rawVersion} for proxy ${proxy.name}`,
+                            );
+                        }
+                        streamShadowTLSOutbound = shadowTLSOutboundParser(
+                            proxy,
+                            { ...shadowTLSPluginOpts, version },
+                        );
+                    }
+                    if (proxy.type === 'anytls' && shadowTLSEnabled) {
+                        throw new Error(
+                            'Platform sing-box cannot replace AnyTLS TLS with ShadowTLS',
+                        );
+                    }
                     if (['xhttp'].includes(proxy.network))
                         throw new Error(
                             `Platform sing-box does not support network: ${proxy.network}`,
                         );
-                    const listStart = list.length;
                     switch (proxy.type) {
                         case 'ssh':
                             list.push(sshParser(proxy));
@@ -1503,6 +1561,12 @@ export default function singbox_Producer() {
                                 `Platform sing-box does not support proxy type: ${proxy.type}`,
                             );
                     }
+                    if (streamShadowTLSOutbound) {
+                        const outbound = list[listStart];
+                        outbound.detour = getShadowTLSTag(proxy);
+                        delete outbound.tls;
+                        list.push(streamShadowTLSOutbound);
+                    }
                     if (
                         opts['include-unsupported-proxy'] &&
                         proxy['name-cert-verify']
@@ -1516,6 +1580,7 @@ export default function singbox_Producer() {
                     }
                 } catch (e) {
                     // console.log(e);
+                    list.length = listStart;
                     $.error(e.message ?? e);
                 }
             });