feat: ✨ 同步 2.21.46

Author: bestrui

src/core/proxy-utils/parsers/peggy/loon.js

@@ -44,7 +44,7 @@ shadowsocksr = tag equals "shadowsocksr"i address method password (ssr_protocol/
     // handle ssr obfs
     proxy.obfs = obfs.type;
 }
-shadowsocks = tag equals "shadowsocks"i address method password (obfs_typev obfs_hostv)? (obfs_ss/obfs_host/obfs_uri/fast_open/udp_relay/udp_port/shadow_tls_version/shadow_tls_sni/shadow_tls_password/ip_mode/block_quic/others)* {
+shadowsocks = tag equals "shadowsocks"i address method password (obfs_typev obfs_hostv)? (obfs_ss/obfs_host/obfs_uri/fast_open/udp_relay/udp_port/shadow_tls_version/shadow_tls_sni/shadow_tls_password/ip_mode/block_quic/udp_over_tcp/others)* {
     proxy.type = "ss";
     // handle ss obfs
     if (obfs.type == "http" || obfs.type === "tls") {
@@ -204,6 +204,8 @@ idle_session_timeout = comma "idle-session-timeout" equals match:$[0-9]+ { proxy
 min_idle_session = comma "min-idle-session" equals match:$[0-9]+ { proxy["min-idle-session"] = parseInt(match.trim()); }
 max_stream_count = comma "max-stream-count" equals match:$[0-9]+ { proxy["max-stream-count"] = parseInt(match.trim()); }
 
+udp_over_tcp = comma "udp-over-tcp" equals flag:bool { proxy["udp-over-tcp"] = true; proxy["udp-over-tcp-version"] = 2; }
+
 tag = match:[^=,]* { proxy.name = match.join("").trim(); }
 comma = _ "," _
 equals = _ "=" _

src/core/proxy-utils/parsers/peggy/loon.peg

@@ -37,7 +37,7 @@ start = (shadowsocksr/shadowsocks/vmess/vless/trojan/https/http/socks5/hysteria2
     return proxy;
 }
 
-shadowsocksr = tag equals "shadowsocksr"i address method password (ssr_protocol/ssr_protocol_param/obfs_ssr/obfs_ssr_param/obfs_host/obfs_uri/fast_open/udp_relay/udp_port/shadow_tls_version/shadow_tls_sni/shadow_tls_password/ip_mode/block_quic/others)*{
+shadowsocksr = tag equals "shadowsocksr"i address method password (ssr_protocol/ssr_protocol_param/obfs_ssr/obfs_ssr_param/obfs_host/obfs_uri/fast_open/udp_relay/udp_port/shadow_tls_version/shadow_tls_sni/shadow_tls_password/ip_mode/block_quic/udp_over_tcp/others)*{
     proxy.type = "ssr";
     // handle ssr obfs
     proxy.obfs = obfs.type;
@@ -202,6 +202,8 @@ idle_session_timeout = comma "idle-session-timeout" equals match:$[0-9]+ { proxy
 min_idle_session = comma "min-idle-session" equals match:$[0-9]+ { proxy["min-idle-session"] = parseInt(match.trim()); }
 max_stream_count = comma "max-stream-count" equals match:$[0-9]+ { proxy["max-stream-count"] = parseInt(match.trim()); }
 
+udp_over_tcp = comma "udp-over-tcp" equals flag:bool { proxy["udp-over-tcp"] = true; proxy["udp-over-tcp-version"] = 2; }
+
 tag = match:[^=,]* { proxy.name = match.join("").trim(); }
 comma = _ "," _
 equals = _ "=" _

src/core/proxy-utils/producers/loon.js

@@ -2,6 +2,7 @@
 const targetPlatform = 'Loon';
 import { isPresent, Result } from './utils';
 import { isIPv4, isIPv6 } from '@/utils';
+import $ from '@/core/app';
 
 const ipVersions = {
     dual: 'dual',
@@ -148,6 +149,23 @@ function shadowsocks(proxy) {
         }
     }
 
+    // udp over tcp
+    if (proxy['udp-over-tcp']) {
+        if (proxy['udp-over-tcp-version'] === 2) {
+            if (proxy.plugin === 'obfs') {
+                $.error(
+                    `Platform ${targetPlatform} shadowsocks udp-over-tcp does not support obfs`,
+                );
+            } else {
+                result.append(`,udp-over-tcp=true`);
+            }
+        } else {
+            $.error(
+                `Platform ${targetPlatform} shadowsocks only supports udp-over-tcp-version 2`,
+            );
+        }
+    }
+
     // tfo
     result.appendIfPresent(`,fast-open=${proxy.tfo}`, 'tfo');
 

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

@@ -840,19 +840,27 @@ const anytlsParser = (proxy = {}) => {
 };
 
 const wireguardParser = (proxy = {}) => {
-    const local_address = ['ip', 'ipv6']
+    const address = ['ip', 'ipv6']
         .map((i) => proxy[i])
         .map((i) => {
             if (isIPv4(i)) return `${i}/32`;
             if (isIPv6(i)) return `${i}/128`;
         })
         .filter((i) => i);
     const parsedProxy = {
+        system: !!proxy.system,
+        mtu: proxy.mtu ? parseInt(`${proxy.mtu}`, 10) : undefined,
+        udp_timeout: proxy['udp-timeout']
+            ? parseInt(`${proxy['udp-timeout']}`, 10)
+            : undefined,
+        workers: proxy['workers']
+            ? parseInt(`${proxy['workers']}`, 10)
+            : undefined,
         tag: proxy.name,
         type: 'wireguard',
         server: proxy.server,
         server_port: parseInt(`${proxy.port}`, 10),
-        local_address,
+        address,
         private_key: proxy['private-key'],
         peer_public_key: proxy['public-key'],
         pre_shared_key: proxy['pre-shared-key'],
@@ -868,14 +876,42 @@ const wireguardParser = (proxy = {}) => {
     } else {
         delete parsedProxy.reserved;
     }
+    if (!Array.isArray(proxy.peers) || proxy.peers.length === 0) {
+        proxy.peers = [{}];
+    }
     if (proxy.peers && proxy.peers.length > 0) {
         parsedProxy.peers = [];
         for (const p of proxy.peers) {
+            let address;
+            let port;
+            if (p.server && p.port) {
+                address = p.server;
+                port = parseInt(`${p.port}`, 10);
+            } else {
+                address = parsedProxy.server;
+                port = parseInt(`${parsedProxy.server_port}`, 10);
+            }
             const peer = {
-                server: p.server,
-                server_port: parseInt(`${p.port}`, 10),
-                public_key: p['public-key'],
-                allowed_ips: p['allowed-ips'] || p.allowed_ips,
+                address,
+                port,
+                persistent_keepalive_interval: p[
+                    'persistent-keepalive-interval'
+                ]
+                    ? parseInt(`${p['persistent-keepalive-interval']}`, 10)
+                    : undefined,
+                public_key:
+                    p['public-key'] ||
+                    p['public_key'] ||
+                    parsedProxy.peer_public_key,
+                pre_shared_key:
+                    p['pre-shared-key'] ||
+                    p['pre_shared_key'] ||
+                    parsedProxy.pre_shared_key,
+                allowed_ips: p['allowed-ips'] ||
+                    p.allowed_ips || [
+                        '0.0.0.0/0',
+                        ...(proxy.ipv6 ? ['::/0'] : []),
+                    ],
                 reserved: [],
             };
             if (typeof p.reserved === 'string') {
@@ -885,7 +921,10 @@ const wireguardParser = (proxy = {}) => {
             } else {
                 delete peer.reserved;
             }
-            if (p['pre-shared-key']) peer.pre_shared_key = p['pre-shared-key'];
+            if (!Array.isArray(peer.reserved) || peer.reserved.length === 0) {
+                peer.reserved = parsedProxy.reserved;
+            }
+            // if (p['pre-shared-key']) peer.pre_shared_key = p['pre-shared-key'];
             parsedProxy.peers.push(peer);
         }
     }
@@ -894,6 +933,11 @@ const wireguardParser = (proxy = {}) => {
     detourParser(proxy, parsedProxy);
     smuxParser(proxy.smux, parsedProxy);
     ipVersionParser(proxy, parsedProxy);
+    delete parsedProxy.server;
+    delete parsedProxy.server_port;
+    delete parsedProxy.pre_shared_key;
+    delete parsedProxy.peer_public_key;
+    delete parsedProxy.reserved;
     return parsedProxy;
 };
 
@@ -1052,9 +1096,21 @@ export default function singbox_Producer() {
                 }
             });
 
-        return type === 'internal'
-            ? list
-            : JSON.stringify({ outbounds: list }, null, 2);
+        if (type === 'internal') return list;
+
+        const categorized = list.reduce(
+            (result, item) => {
+                if (['wireguard'].includes(item.type)) {
+                    result.endpoints.push(item);
+                } else {
+                    result.outbounds.push(item);
+                }
+                return result;
+            },
+            { outbounds: [], endpoints: [] },
+        );
+
+        return JSON.stringify(categorized, null, 2);
     };
     return { type, produce };
 }