fix: double encode base64 in xray links #232

Author: 7Sageer

src/BaseConfigBuilder.js

@@ -1,5 +1,5 @@
 import { ProxyParser } from './ProxyParsers.js';
-import { DeepCopy, decodeBase64 } from './utils.js';
+import { DeepCopy, tryDecodeSubscriptionLines } from './utils.js';
 import { t, setLanguage } from './i18n/index.js';
 import { generateRules, getOutbounds, PREDEFINED_RULE_SETS } from './config.js';
 
@@ -26,7 +26,7 @@ export class BaseConfigBuilder {
 
         for (const url of urls) {
             // Try to decode if it might be base64
-            let processedUrls = this.tryDecodeBase64(url);
+            let processedUrls = tryDecodeSubscriptionLines(url);
 
             // Handle single URL or array of URLs
             if(!Array.isArray(processedUrls)){
@@ -52,37 +52,6 @@ export class BaseConfigBuilder {
         return parsedItems;
     }
 
-    tryDecodeBase64(str) {
-        // If the string already has a protocol prefix, return as is
-        if (str.includes('://')) {
-            return str;
-        }
-
-        try {
-            // Try to decode as base64
-            const decoded = decodeBase64(str);
-            
-            // Check if decoded content contains multiple links
-            if (decoded.includes('\n')) {
-                // Split by newline and filter out empty lines
-                const multipleUrls = decoded.split('\n').filter(url => url.trim() !== '');
-                
-                // Check if at least one URL is valid
-                if (multipleUrls.some(url => url.includes('://'))) {
-                    return multipleUrls;
-                }
-            }
-            
-            // Check if the decoded string looks like a valid URL
-            if (decoded.includes('://')) {
-                return decoded;
-            }
-        } catch (e) {
-            // If decoding fails, return original string
-        }
-        return str;
-    }
-
     getOutboundsList() {
         let outbounds;
         if (typeof this.selectedRules === 'string' && PREDEFINED_RULE_SETS[this.selectedRules]) {

src/index.js

@@ -2,7 +2,7 @@ import { SingboxConfigBuilder } from './SingboxConfigBuilder.js';
 import { generateHtml } from './htmlBuilder.js';
 import { ClashConfigBuilder } from './ClashConfigBuilder.js';
 import { SurgeConfigBuilder } from './SurgeConfigBuilder.js';
-import { decodeBase64, encodeBase64, GenerateWebPath } from './utils.js';
+import { encodeBase64, GenerateWebPath, tryDecodeSubscriptionLines } from './utils.js';
 import { PREDEFINED_RULE_SETS } from './config.js';
 import { t, setLanguage } from './i18n/index.js';
 import yaml from 'js-yaml';
@@ -156,38 +156,48 @@ async function handleRequest(request) {
     } else if (url.pathname.startsWith('/xray')) {
       // Handle Xray config requests
       const inputString = url.searchParams.get('config');
-      const proxylist = inputString.split('\n');
+      if (!inputString) {
+        return new Response('Missing config parameter', { status: 400 });
+      }
 
+      const proxylist = inputString.split('\n');
       const finalProxyList = [];
       // Use custom UserAgent (for Xray) Hmmm...
       let userAgent = url.searchParams.get('ua');
       if (!userAgent) {
         userAgent = 'curl/7.74.0';
       }
-      let headers = new Headers({
-        "User-Agent"   : userAgent
+      const headers = new Headers({
+        'User-Agent': userAgent
       });
 
       for (const proxy of proxylist) {
-        if (proxy.startsWith('http://') || proxy.startsWith('https://')) {
+        const trimmedProxy = proxy.trim();
+        if (!trimmedProxy) {
+          continue;
+        }
+
+        if (trimmedProxy.startsWith('http://') || trimmedProxy.startsWith('https://')) {
           try {
-            const response = await fetch(proxy, {
-              method : 'GET',
-              headers : headers
-            })
+            const response = await fetch(trimmedProxy, {
+              method: 'GET',
+              headers
+            });
             const text = await response.text();
-            let decodedText;
-            decodedText = decodeBase64(text.trim());
-            // Check if the decoded text needs URL decoding
-            if (decodedText.includes('%')) {
-              decodedText = decodeURIComponent(decodedText);
+            let processed = tryDecodeSubscriptionLines(text, { decodeUriComponent: true });
+            if (!Array.isArray(processed)) {
+              processed = [processed];
             }
-            finalProxyList.push(...decodedText.split('\n'));
+            finalProxyList.push(...processed.filter(item => typeof item === 'string' && item.trim() !== ''));
           } catch (e) {
             console.warn('Failed to fetch the proxy:', e);
           }
         } else {
-          finalProxyList.push(proxy);
+          let processed = tryDecodeSubscriptionLines(trimmedProxy);
+          if (!Array.isArray(processed)) {
+            processed = [processed];
+          }
+          finalProxyList.push(...processed.filter(item => typeof item === 'string' && item.trim() !== ''));
         }
       }
 
@@ -292,4 +302,4 @@ async function handleRequest(request) {
     console.error('Error processing request:', error);
     return new Response(t('internalError'), { status: 500 });
   }
-}
+}

src/utils.js

@@ -89,6 +89,66 @@ export function base64ToBinary(base64String) {
 
 	return binaryString;
 }
+
+export function tryDecodeSubscriptionLines(input, { decodeUriComponent = false } = {}) {
+	if (typeof input !== 'string') {
+		return input;
+	}
+
+	const trimmed = input.trim();
+	if (trimmed === '') {
+		return trimmed;
+	}
+
+	const splitIfMultiple = (value) => {
+		if (typeof value !== 'string') {
+			return value;
+		}
+
+		const normalized = value.replace(/\r\n/g, '\n');
+		const segments = normalized
+			.split('\n')
+			.map(segment => segment.trim())
+			.filter(segment => segment !== '');
+
+		if (segments.length > 1 && segments.some(segment => segment.includes('://'))) {
+			return segments;
+		}
+
+		return normalized.trim();
+	};
+
+	const directResult = splitIfMultiple(trimmed);
+	if (Array.isArray(directResult)) {
+		return directResult;
+	}
+	if (typeof directResult === 'string' && directResult.includes('://')) {
+		return directResult;
+	}
+
+	try {
+		let decoded = decodeBase64(trimmed);
+		if (decodeUriComponent && decoded.includes('%')) {
+			try {
+				decoded = decodeURIComponent(decoded);
+			} catch (_) {
+				// ignore URI decode errors and fall back to the decoded string
+			}
+		}
+
+		const decodedResult = splitIfMultiple(decoded);
+		if (Array.isArray(decodedResult)) {
+			return decodedResult;
+		}
+		if (typeof decodedResult === 'string' && decodedResult.includes('://')) {
+			return decodedResult;
+		}
+	} catch (_) {
+		// ignore decoding errors and return the original trimmed input
+	}
+
+	return trimmed;
+}
 export function DeepCopy(obj) {
 	if (obj === null || typeof obj !== 'object') {
 		return obj;