#69

修复 GetRawConfHandler 中短链的构建问题 | Fix URL construction in GetRawConfHandler

.github/workflows/docker.yml

@@ -45,7 +45,7 @@ jobs:
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build and push
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v6
         with:
           build-args: |
             "version=${{ github.ref_name }}"
@@ -53,3 +53,5 @@ jobs:
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
           platforms: linux/amd64,linux/arm64,linux/arm/v7
+          file: Containerfile
+          

.github/workflows/release.yml

@@ -13,13 +13,18 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: Set up Go
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v5
+
+      - name: Install UPX
+        uses: crazy-max/ghaction-upx@v3
+        with:
+          install-only: true
 
       - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v5
+        uses: goreleaser/goreleaser-action@v6
         with:
           distribution: goreleaser
           version: latest

.gitignore

@@ -5,4 +5,7 @@ subs
 logs
 data
 .env
-.vscode/settings.json
+.vscode/settings.json
+config.yaml
+config.yml
+config.json

.goreleaser.yaml

@@ -1,3 +1,4 @@
+version: 2
 project_name: sub2clash
 builds:
   - env:
@@ -9,19 +10,15 @@ builds:
     goarch:
       - amd64
       - arm64
-      - arm
       - "386"
-    goarm:
-      - "6"
-      - "7"
     ldflags:
-      - -s -w -X sub2clash/constant.Version={{ .Version }}
+      - -s -w -X github.com/bestnite/sub2clash/constant.Version={{ .Version }}
     flags:
       - -trimpath
 archives:
-  - format: tar.gz
+  - formats: ["tar.gz"]
     format_overrides:
-      - format: zip
+      - formats: ["zip"]
         goos: windows
     wrap_in_directory: true
     files:
@@ -30,3 +27,19 @@ archives:
       - templates
 release:
   draft: true
+upx:
+  - enabled: true
+    compress: best
+nfpms:
+  - id: sub2clash
+    homepage: https://github.com/bestnite/sub2clash
+    maintainer: Nite <admin@nite07.com>
+    license: "MIT"
+    formats:
+      - apk
+      - deb
+      - rpm
+      - termux.deb
+      - archlinux
+    provides:
+      - sub2clash

API.md

@@ -1,47 +0,0 @@
-# `GET /clash`, `GET /meta`
-
-获取 Clash/Clash.Meta 配置链接
-
-| Query 参数   | 类型   | 是否必须                 | 默认值    | 说明                                                                                                                                                                                                                                      |
-| ------------ | ------ | ------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| sub          | string | sub/proxy 至少有一项存在 | -         | 订阅链接，可以在链接结尾加上`#名称`，来给订阅中的节点加上统一前缀（可以输入多个，用 `,` 分隔）                                                                                                                                            |
-| proxy        | string | sub/proxy 至少有一项存在 | -         | 节点分享链接（可以输入多个，用 `,` 分隔）                                                                                                                                                                                                 |
-| refresh      | bool   | 否                       | `false`   | 强制刷新配置（默认缓存 5 分钟）                                                                                                                                                                                                           |
-| template     | string | 否                       | -         | 外部模板链接或内部模板名称                                                                                                                                                                                                                |
-| ruleProvider | string | 否                       | -         | 格式 `[Behavior,Url,Group,Prepend,Name],[Behavior,Url,Group,Prepend,Name]...`，其中 `Group` 是该规则集使用的策略组名，`Prepend` 为 bool 类型，如果为 `true` 规则将被添加到规则列表顶部，否则添加到规则列表底部（会调整到 MATCH 规则之前） |
-| rule         | string | 否                       | -         | 格式 `[Rule,Prepend],[Rule,Prepend]...`，其中 `Prepend` 为 bool 类型，如果为 `true` 规则将被添加到规则列表顶部，否则添加到规则列表底部（会调整到 MATCH 规则之前）                                                                         |
-| autoTest     | bool   | 否                       | `false`   | 国家策略组是否自动测速                                                                                                                                                                                                                    |
-| lazy         | bool   | 否                       | `false`   | 自动测速是否启用 lazy                                                                                                                                                                                                                     |
-| sort         | string | 否                       | `nameasc` | 国家策略组排序策略，可选值 `nameasc`、`namedesc`、`sizeasc`、`sizedesc`                                                                                                                                                                   |
-| replace      | string | 否                       | -         | 通过正则表达式重命名节点，格式 `[<ReplaceKey>,<ReplaceTo>],[<ReplaceKey>,<ReplaceTo>]...`                                                                                                                                                 |
-| remove       | string | 否                       | -         | 通过正则表达式删除节点                                                                                                                                                                                                                    |
-| nodeList     | bool   | 否                       | `false`   | 只输出节点                                                                                                                                                                                                                                |
-
-# `POST /short`
-
-获取短链，Content-Type 为 `application/json`
-具体参考使用可以参考 [api\templates\index.html](api/static/index.html)
-
-| Body 参数 | 类型   | 是否必须 | 默认值 | 说明                      |
-| --------- | ------ | -------- | ------ | ------------------------- |
-| url       | string | 是       | -      | 需要转换的 Query 参数部分 |
-| password  | string | 否       | -      | 短链密码                  |
-
-# `GET /s/:hash`
-
-短链跳转
-`hash` 为动态路由参数，可以通过 `/short` 接口获取
-
-| Query 参数 | 类型   | 是否必须 | 默认值 | 说明     |
-| ---------- | ------ | -------- | ------ | -------- |
-| password   | string | 否       | -      | 短链密码 |
-
-# `PUT /short`
-
-更新短链，Content-Type 为 `application/json`
-
-| Body 参数 | 类型   | 是否必须 | 默认值 | 说明                      |
-| --------- | ------ | -------- | ------ | ------------------------- |
-| url       | string | 是       | -      | 需要转换的 Query 参数部分 |
-| password  | string | 否       | -      | 短链密码                  |
-| hash      | string | 是       | -      | 短链 hash                 |

Containerfile

@@ -1,4 +1,4 @@
-FROM golang:1.21-alpine as builder
+FROM golang:1.25 as builder
 LABEL authors="nite07"
 WORKDIR /app
 COPY . .

README.md

@@ -59,7 +59,80 @@
 
 ### API
 
-[API 文档](./API.md)
+#### `GET /convert/:config`
+
+获取 Clash/Clash.Meta 配置链接
+
+| Path 参数 | 类型   | 说明                                           |
+| --------- | ------ | ---------------------------------------------- |
+| config    | string | Base64 URL Safe 编码后的 JSON 字符串，格式如下 |
+
+##### `config` JSON 结构
+
+| Query 参数         | 类型              | 是否必须                 | 默认值    | 说明                                                                                                     |
+| ------------------ | ----------------- | ------------------------ | --------- | -------------------------------------------------------------------------------------------------------- |
+| clashType          | int               | 是                       | 1         | 配置文件类型 (1: Clash, 2: Clash.Meta)                                                                   |
+| subscriptions      | []string          | sub/proxy 至少有一项存在 | -         | 订阅链接（v2ray 或 clash 格式），可以在链接结尾加上`#名称`，来给订阅中的节点加上统一前缀（可以输入多个） |
+| proxies            | []string          | sub/proxy 至少有一项存在 | -         | 节点分享链接（可以输入多个）                                                                             |
+| refresh            | bool              | 否                       | `false`   | 强制刷新配置（默认缓存 5 分钟）                                                                          |
+| template           | string            | 否                       | -         | 外部模板链接或内部模板名称                                                                               |
+| ruleProviders      | []RuleProvider    | 否                       | -         | 规则                                                                                                     |
+| rules              | []Rule            | 否                       | -         | 规则                                                                                                     |
+| autoTest           | bool              | 否                       | `false`   | 国家策略组是否自动测速                                                                                   |
+| lazy               | bool              | 否                       | `false`   | 自动测速是否启用 lazy                                                                                    |
+| sort               | string            | 否                       | `nameasc` | 国家策略组排序策略，可选值 `nameasc`、`namedesc`、`sizeasc`、`sizedesc`                                  |
+| replace            | map[string]string | 否                       | -         | 通过正则表达式重命名节点                                                                                 |
+| remove             | string            | 否                       | -         | 通过正则表达式删除节点                                                                                   |
+| nodeList           | bool              | 否                       | `false`   | 只输出节点                                                                                               |
+| ignoreCountryGroup | bool              | 否                       | `false`   | 是否忽略国家分组                                                                                         |
+| userAgent          | string            | 否                       | -         | 订阅 user-agent                                                                                          |
+| useUDP             | bool              | 否                       | `false`   | 是否使用 UDP                                                                                             |
+
+###### `RuleProvider` 结构
+
+| 字段     | 类型   | 说明                                                             |
+| -------- | ------ | ---------------------------------------------------------------- |
+| behavior | string | rule-set 的 behavior                                             |
+| url      | string | rule-set 的 url                                                  |
+| group    | string | 该规则集使用的策略组名                                           |
+| prepend  | bool   | 如果为 `true` 规则将被添加到规则列表顶部，否则添加到规则列表底部 |
+| name     | string | 该 rule-provider 的名称，不能重复                                |
+
+###### `Rule` 结构
+
+| 字段    | 类型   | 说明                                                             |
+| ------- | ------ | ---------------------------------------------------------------- |
+| rule    | string | 规则                                                             |
+| prepend | bool   | 如果为 `true` 规则将被添加到规则列表顶部，否则添加到规则列表底部 |
+
+#### `POST /short`
+
+获取短链，Content-Type 为 `application/json`
+具体参考使用可以参考 [api\templates\index.html](api/static/index.html)
+
+| Body 参数 | 类型   | 是否必须 | 默认值 | 说明                      |
+| --------- | ------ | -------- | ------ | ------------------------- |
+| url       | string | 是       | -      | 需要转换的 Query 参数部分 |
+| password  | string | 否       | -      | 短链密码                  |
+
+#### `GET /s/:hash`
+
+短链跳转
+`hash` 为动态路由参数，可以通过 `/short` 接口获取
+
+| Query 参数 | 类型   | 是否必须 | 默认值 | 说明     |
+| ---------- | ------ | -------- | ------ | -------- |
+| password   | string | 否       | -      | 短链密码 |
+
+#### `PUT /short`
+
+更新短链，Content-Type 为 `application/json`
+
+| Body 参数 | 类型   | 是否必须 | 默认值 | 说明                      |
+| --------- | ------ | -------- | ------ | ------------------------- |
+| url       | string | 是       | -      | 需要转换的 Query 参数部分 |
+| password  | string | 否       | -      | 短链密码                  |
+| hash      | string | 是       | -      | 短链 hash                 |
 
 ### 模板
 

common/errors.go

@@ -133,8 +133,8 @@ func NewTemplateLoadError(template string, cause error) *CommonError {
 	return NewError(ErrTemplateLoad, fmt.Sprintf("failed to load template: %s", template), cause)
 }
 
-func NewTemplateParseError(cause error) *CommonError {
-	return NewError(ErrTemplateParse, "failed to parse template", cause)
+func NewTemplateParseError(data []byte, cause error) *CommonError {
+	return NewError(ErrTemplateParse, fmt.Sprintf("failed to parse template: %s", data), cause)
 }
 
 // Subscription errors
@@ -142,8 +142,8 @@ func NewSubscriptionLoadError(url string, cause error) *CommonError {
 	return NewError(ErrSubscriptionLoad, fmt.Sprintf("failed to load subscription: %s", url), cause)
 }
 
-func NewSubscriptionParseError(cause error) *CommonError {
-	return NewError(ErrSubscriptionParse, "failed to parse subscription", cause)
+func NewSubscriptionParseError(data []byte, cause error) *CommonError {
+	return NewError(ErrSubscriptionParse, fmt.Sprintf("failed to parse subscription: %s", string(data)), cause)
 }
 
 // Regex errors

common/sub.go

@@ -19,6 +19,7 @@ import (
 	"github.com/bestnite/sub2clash/model"
 	P "github.com/bestnite/sub2clash/model/proxy"
 	"github.com/bestnite/sub2clash/parser"
+	"github.com/bestnite/sub2clash/utils"
 	"go.uber.org/zap"
 	"gopkg.in/yaml.v3"
 )
@@ -92,7 +93,7 @@ func FetchSubscriptionFromAPI(url string, userAgent string, retryTimes int) ([]b
 	return data, nil
 }
 
-func BuildSub(clashType model.ClashType, query model.SubConfig, template string, cacheExpire int64, retryTimes int) (
+func BuildSub(clashType model.ClashType, query model.ConvertConfig, template string, cacheExpire int64, retryTimes int) (
 	*model.Subscription, error,
 ) {
 	var temp = &model.Subscription{}
@@ -128,22 +129,22 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 	err = yaml.Unmarshal(templateBytes, &temp)
 	if err != nil {
 		logger.Logger.Debug("parse template failed", zap.Error(err))
-		return nil, NewTemplateParseError(err)
+		return nil, NewTemplateParseError(templateBytes, err)
 	}
 	var proxyList []P.Proxy
 
 	for i := range query.Subs {
 		data, err := LoadSubscription(query.Subs[i], query.Refresh, query.UserAgent, cacheExpire, retryTimes)
-		subName := ""
-		if strings.Contains(query.Subs[i], "#") {
-			subName = query.Subs[i][strings.LastIndex(query.Subs[i], "#")+1:]
-		}
 		if err != nil {
 			logger.Logger.Debug(
 				"load subscription failed", zap.String("url", query.Subs[i]), zap.Error(err),
 			)
 			return nil, NewSubscriptionLoadError(query.Subs[i], err)
 		}
+		subName := ""
+		if strings.Contains(query.Subs[i], "#") {
+			subName = query.Subs[i][strings.LastIndex(query.Subs[i], "#")+1:]
+		}
 
 		err = yaml.Unmarshal(data, &sub)
 		var newProxies []P.Proxy
@@ -154,22 +155,22 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 				return nil, NewRegexInvalidError("prefix", err)
 			}
 			if reg.Match(data) {
-				p, err := parser.ParseProxies(strings.Split(string(data), "\n")...)
+				p, err := parser.ParseProxies(parser.ParseConfig{UseUDP: query.UseUDP}, strings.Split(string(data), "\n")...)
 				if err != nil {
 					return nil, err
 				}
 				newProxies = p
 			} else {
-				base64, err := parser.DecodeBase64(string(data))
+				base64, err := utils.DecodeBase64(string(data), false)
 				if err != nil {
 					logger.Logger.Debug(
 						"parse subscription failed", zap.String("url", query.Subs[i]),
 						zap.String("data", string(data)),
 						zap.Error(err),
 					)
-					return nil, NewSubscriptionParseError(err)
+					return nil, NewSubscriptionParseError(data, err)
 				}
-				p, err := parser.ParseProxies(strings.Split(base64, "\n")...)
+				p, err := parser.ParseProxies(parser.ParseConfig{UseUDP: query.UseUDP}, strings.Split(base64, "\n")...)
 				if err != nil {
 					return nil, err
 				}
@@ -186,8 +187,8 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 		proxyList = append(proxyList, newProxies...)
 	}
 
-	if len(query.Proxy) != 0 {
-		p, err := parser.ParseProxies(query.Proxies...)
+	if len(query.Proxies) != 0 {
+		p, err := parser.ParseProxies(parser.ParseConfig{UseUDP: query.UseUDP}, query.Proxies...)
 		if err != nil {
 			return nil, err
 		}
@@ -200,6 +201,7 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 		}
 	}
 
+	// 去重
 	proxies := make(map[string]*P.Proxy)
 	newProxies := make([]P.Proxy, 0, len(proxyList))
 	for i := range proxyList {
@@ -216,6 +218,7 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 	}
 	proxyList = newProxies
 
+	// 移除
 	if strings.TrimSpace(query.Remove) != "" {
 		newProxyList := make([]P.Proxy, 0, len(proxyList))
 		for i := range proxyList {
@@ -233,29 +236,25 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 		proxyList = newProxyList
 	}
 
-	if len(query.ReplaceKeys) != 0 {
-
-		replaceRegs := make([]*regexp.Regexp, 0, len(query.ReplaceKeys))
-		for _, v := range query.ReplaceKeys {
-			replaceReg, err := regexp.Compile(v)
+	// 替换
+	if len(query.Replace) != 0 {
+		for k, v := range query.Replace {
+			replaceReg, err := regexp.Compile(k)
 			if err != nil {
 				logger.Logger.Debug("replace regexp compile failed", zap.Error(err))
 				return nil, NewRegexInvalidError("replace", err)
 			}
-			replaceRegs = append(replaceRegs, replaceReg)
-		}
-		for i := range proxyList {
-
-			for j, v := range replaceRegs {
-				if v.MatchString(proxyList[i].Name) {
-					proxyList[i].Name = v.ReplaceAllString(
-						proxyList[i].Name, query.ReplaceTo[j],
+			for i := range proxyList {
+				if replaceReg.MatchString(proxyList[i].Name) {
+					proxyList[i].Name = replaceReg.ReplaceAllString(
+						proxyList[i].Name, v,
 					)
 				}
 			}
 		}
 	}
 
+	// 重命名有相同名称的节点
 	names := make(map[string]int)
 	for i := range proxyList {
 		if _, exist := names[proxyList[i].Name]; exist {
@@ -273,6 +272,7 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
 	var t = &model.Subscription{}
 	AddProxy(t, query.AutoTest, query.Lazy, clashType, proxyList...)
 
+	// 排序
 	switch query.Sort {
 	case "sizeasc":
 		sort.Sort(model.ProxyGroupsSortBySize(t.ProxyGroup))

common/template.go

@@ -3,11 +3,27 @@ package common
 import (
 	"io"
 	"os"
+	"path/filepath"
+	"strings"
 )
 
-func LoadTemplate(templatePath string) ([]byte, error) {
-	if _, err := os.Stat(templatePath); err == nil {
-		file, err := os.Open(templatePath)
+const templatesDir = "templates"
+
+// LoadTemplate 只读取运行目录下的 templates 目录，防止其他文件内容泄漏
+func LoadTemplate(templateName string) ([]byte, error) {
+	// 清理路径，防止目录遍历攻击
+	cleanTemplateName := filepath.Clean(templateName)
+
+	// 检查是否尝试访问父目录
+	if strings.HasPrefix(cleanTemplateName, "..") || strings.Contains(cleanTemplateName, string(filepath.Separator)+".."+string(filepath.Separator)) {
+		return nil, NewFileNotFoundError(templateName) // 拒绝包含父目录的路径
+	}
+
+	// 构建完整路径，确保只从 templates 目录读取
+	fullPath := filepath.Join(templatesDir, cleanTemplateName)
+
+	if _, err := os.Stat(fullPath); err == nil {
+		file, err := os.Open(fullPath)
 		if err != nil {
 			return nil, err
 		}
@@ -22,5 +38,5 @@ func LoadTemplate(templatePath string) ([]byte, error) {
 		}
 		return result, nil
 	}
-	return nil, NewFileNotFoundError(templatePath)
+	return nil, NewFileNotFoundError(templateName)
 }

go.mod

@@ -1,8 +1,6 @@
 module github.com/bestnite/sub2clash
 
-go 1.21.0
-
-toolchain go1.24.3
+go 1.25
 
 require (
 	github.com/gin-gonic/gin v1.10.1

model/clash.go

@@ -13,11 +13,12 @@ func GetSupportProxyTypes(clashType ClashType) map[string]bool {
 	supportProxyTypes := make(map[string]bool)
 
 	for _, parser := range parser.GetAllParsers() {
-		if clashType == Clash {
+		switch clashType {
+		case Clash:
 			if parser.SupportClash() {
 				supportProxyTypes[parser.GetType()] = true
 			}
-		} else if clashType == ClashMeta {
+		case ClashMeta:
 			if parser.SupportMeta() {
 				supportProxyTypes[parser.GetType()] = true
 			}

model/convert_config.go

@@ -0,0 +1,92 @@
+package model
+
+import (
+	"encoding/json"
+	"errors"
+	"net/url"
+	"strings"
+
+	"github.com/bestnite/sub2clash/utils"
+	"github.com/gin-gonic/gin"
+)
+
+type ConvertConfig struct {
+	ClashType           ClashType            `json:"clashType" binding:"required"`
+	Subs                []string             `json:"subscriptions" binding:""`
+	Proxies             []string             `json:"proxies" binding:""`
+	Refresh             bool                 `json:"refresh" binding:""`
+	Template            string               `json:"template" binding:""`
+	RuleProviders       []RuleProviderStruct `json:"ruleProviders" binding:""`
+	Rules               []RuleStruct         `json:"rules" binding:""`
+	AutoTest            bool                 `json:"autoTest" binding:""`
+	Lazy                bool                 `json:"lazy" binding:""`
+	Sort                string               `json:"sort" binding:""`
+	Remove              string               `json:"remove" binding:""`
+	Replace             map[string]string    `json:"replace" binding:""`
+	NodeListMode        bool                 `json:"nodeList" binding:""`
+	IgnoreCountryGrooup bool                 `json:"ignoreCountryGroup" binding:""`
+	UserAgent           string               `json:"userAgent" binding:""`
+	UseUDP              bool                 `json:"useUDP" binding:""`
+}
+
+type RuleProviderStruct struct {
+	Behavior string `json:"behavior" binding:""`
+	Url      string `json:"url" binding:""`
+	Group    string `json:"group" binding:""`
+	Prepend  bool   `json:"prepend" binding:""`
+	Name     string `json:"name" binding:""`
+}
+
+type RuleStruct struct {
+	Rule    string `json:"rule" binding:""`
+	Prepend bool   `json:"prepend" binding:""`
+}
+
+func ParseConvertQuery(c *gin.Context) (ConvertConfig, error) {
+	config := c.Param("config")
+	queryBytes, err := utils.DecodeBase64(config, true)
+	if err != nil {
+		return ConvertConfig{}, errors.New("参数错误: " + err.Error())
+	}
+	var query ConvertConfig
+	err = json.Unmarshal([]byte(queryBytes), &query)
+	if err != nil {
+		return ConvertConfig{}, errors.New("参数错误: " + err.Error())
+	}
+	if len(query.Subs) == 0 && len(query.Proxies) == 0 {
+		return ConvertConfig{}, errors.New("参数错误: sub 和 proxy 不能同时为空")
+	}
+	if len(query.Subs) > 0 {
+		for i := range query.Subs {
+			if !strings.HasPrefix(query.Subs[i], "http") {
+				return ConvertConfig{}, errors.New("参数错误: sub 格式错误")
+			}
+			if _, err := url.ParseRequestURI(query.Subs[i]); err != nil {
+				return ConvertConfig{}, errors.New("参数错误: " + err.Error())
+			}
+		}
+	} else {
+		query.Subs = nil
+	}
+	if query.Template != "" {
+		if strings.HasPrefix(query.Template, "http") {
+			uri, err := url.ParseRequestURI(query.Template)
+			if err != nil {
+				return ConvertConfig{}, err
+			}
+			query.Template = uri.String()
+		}
+	}
+	if len(query.RuleProviders) > 0 {
+		names := make(map[string]bool)
+		for _, ruleProvider := range query.RuleProviders {
+			if _, ok := names[ruleProvider.Name]; ok {
+				return ConvertConfig{}, errors.New("参数错误: Rule-Provider 名称重复")
+			}
+			names[ruleProvider.Name] = true
+		}
+	} else {
+		query.RuleProviders = nil
+	}
+	return query, nil
+}

model/proxy/anytls.go

@@ -2,17 +2,17 @@ package proxy
 
 // https://github.com/MetaCubeX/mihomo/blob/Meta/adapter/outbound/anytls.go
 type Anytls struct {
-	Server                   string     `yaml:"server"`
-	Port                     int        `yaml:"port"`
-	Password                 string     `yaml:"password"`
-	ALPN                     []string   `yaml:"alpn,omitempty"`
-	SNI                      string     `yaml:"sni,omitempty"`
-	ECHOpts                  ECHOptions `yaml:"ech-opts,omitempty"`
-	ClientFingerprint        string     `yaml:"client-fingerprint,omitempty"`
-	SkipCertVerify           bool       `yaml:"skip-cert-verify,omitempty"`
-	Fingerprint              string     `yaml:"fingerprint,omitempty"`
-	UDP                      bool       `yaml:"udp,omitempty"`
-	IdleSessionCheckInterval int        `yaml:"idle-session-check-interval,omitempty"`
-	IdleSessionTimeout       int        `yaml:"idle-session-timeout,omitempty"`
-	MinIdleSession           int        `yaml:"min-idle-session,omitempty"`
+	Server                   string      `yaml:"server"`
+	Port                     IntOrString `yaml:"port"`
+	Password                 string      `yaml:"password"`
+	ALPN                     []string    `yaml:"alpn,omitempty"`
+	SNI                      string      `yaml:"sni,omitempty"`
+	ECHOpts                  ECHOptions  `yaml:"ech-opts,omitempty"`
+	ClientFingerprint        string      `yaml:"client-fingerprint,omitempty"`
+	SkipCertVerify           bool        `yaml:"skip-cert-verify,omitempty"`
+	Fingerprint              string      `yaml:"fingerprint,omitempty"`
+	UDP                      bool        `yaml:"udp,omitempty"`
+	IdleSessionCheckInterval int         `yaml:"idle-session-check-interval,omitempty"`
+	IdleSessionTimeout       int         `yaml:"idle-session-timeout,omitempty"`
+	MinIdleSession           int         `yaml:"min-idle-session,omitempty"`
 }

model/proxy/hysteria.go

@@ -2,28 +2,28 @@ package proxy
 
 // https://github.com/MetaCubeX/mihomo/blob/Meta/adapter/outbound/hysteria.go
 type Hysteria struct {
-	Server              string     `yaml:"server"`
-	Port                int        `yaml:"port,omitempty"`
-	Ports               string     `yaml:"ports,omitempty"`
-	Protocol            string     `yaml:"protocol,omitempty"`
-	ObfsProtocol        string     `yaml:"obfs-protocol,omitempty"` // compatible with Stash
-	Up                  string     `yaml:"up"`
-	UpSpeed             int        `yaml:"up-speed,omitempty"` // compatible with Stash
-	Down                string     `yaml:"down"`
-	DownSpeed           int        `yaml:"down-speed,omitempty"` // compatible with Stash
-	Auth                string     `yaml:"auth,omitempty"`
-	AuthString          string     `yaml:"auth-str,omitempty"`
-	Obfs                string     `yaml:"obfs,omitempty"`
-	SNI                 string     `yaml:"sni,omitempty"`
-	ECHOpts             ECHOptions `yaml:"ech-opts,omitempty"`
-	SkipCertVerify      bool       `yaml:"skip-cert-verify,omitempty"`
-	Fingerprint         string     `yaml:"fingerprint,omitempty"`
-	ALPN                []string   `yaml:"alpn,omitempty"`
-	CustomCA            string     `yaml:"ca,omitempty"`
-	CustomCAString      string     `yaml:"ca-str,omitempty"`
-	ReceiveWindowConn   int        `yaml:"recv-window-conn,omitempty"`
-	ReceiveWindow       int        `yaml:"recv-window,omitempty"`
-	DisableMTUDiscovery bool       `yaml:"disable-mtu-discovery,omitempty"`
-	FastOpen            bool       `yaml:"fast-open,omitempty"`
-	HopInterval         int        `yaml:"hop-interval,omitempty"`
+	Server              string      `yaml:"server"`
+	Port                IntOrString `yaml:"port,omitempty"`
+	Ports               string      `yaml:"ports,omitempty"`
+	Protocol            string      `yaml:"protocol,omitempty"`
+	ObfsProtocol        string      `yaml:"obfs-protocol,omitempty"` // compatible with Stash
+	Up                  string      `yaml:"up"`
+	UpSpeed             int         `yaml:"up-speed,omitempty"` // compatible with Stash
+	Down                string      `yaml:"down"`
+	DownSpeed           int         `yaml:"down-speed,omitempty"` // compatible with Stash
+	Auth                string      `yaml:"auth,omitempty"`
+	AuthString          string      `yaml:"auth-str,omitempty"`
+	Obfs                string      `yaml:"obfs,omitempty"`
+	SNI                 string      `yaml:"sni,omitempty"`
+	ECHOpts             ECHOptions  `yaml:"ech-opts,omitempty"`
+	SkipCertVerify      bool        `yaml:"skip-cert-verify,omitempty"`
+	Fingerprint         string      `yaml:"fingerprint,omitempty"`
+	ALPN                []string    `yaml:"alpn,omitempty"`
+	CustomCA            string      `yaml:"ca,omitempty"`
+	CustomCAString      string      `yaml:"ca-str,omitempty"`
+	ReceiveWindowConn   int         `yaml:"recv-window-conn,omitempty"`
+	ReceiveWindow       int         `yaml:"recv-window,omitempty"`
+	DisableMTUDiscovery bool        `yaml:"disable-mtu-discovery,omitempty"`
+	FastOpen            bool        `yaml:"fast-open,omitempty"`
+	HopInterval         int         `yaml:"hop-interval,omitempty"`
 }

model/proxy/hysteria2.go

@@ -2,24 +2,24 @@ package proxy
 
 // https://github.com/MetaCubeX/mihomo/blob/Meta/adapter/outbound/hysteria2.go
 type Hysteria2 struct {
-	Server         string     `yaml:"server"`
-	Port           int        `yaml:"port,omitempty"`
-	Ports          string     `yaml:"ports,omitempty"`
-	HopInterval    int        `yaml:"hop-interval,omitempty"`
-	Up             string     `yaml:"up,omitempty"`
-	Down           string     `yaml:"down,omitempty"`
-	Password       string     `yaml:"password,omitempty"`
-	Obfs           string     `yaml:"obfs,omitempty"`
-	ObfsPassword   string     `yaml:"obfs-password,omitempty"`
-	SNI            string     `yaml:"sni,omitempty"`
-	ECHOpts        ECHOptions `yaml:"ech-opts,omitempty"`
-	SkipCertVerify bool       `yaml:"skip-cert-verify,omitempty"`
-	Fingerprint    string     `yaml:"fingerprint,omitempty"`
-	ALPN           []string   `yaml:"alpn,omitempty"`
-	CustomCA       string     `yaml:"ca,omitempty"`
-	CustomCAString string     `yaml:"ca-str,omitempty"`
-	CWND           int        `yaml:"cwnd,omitempty"`
-	UdpMTU         int        `yaml:"udp-mtu,omitempty"`
+	Server         string      `yaml:"server"`
+	Port           IntOrString `yaml:"port,omitempty"`
+	Ports          string      `yaml:"ports,omitempty"`
+	HopInterval    int         `yaml:"hop-interval,omitempty"`
+	Up             string      `yaml:"up,omitempty"`
+	Down           string      `yaml:"down,omitempty"`
+	Password       string      `yaml:"password,omitempty"`
+	Obfs           string      `yaml:"obfs,omitempty"`
+	ObfsPassword   string      `yaml:"obfs-password,omitempty"`
+	SNI            string      `yaml:"sni,omitempty"`
+	ECHOpts        ECHOptions  `yaml:"ech-opts,omitempty"`
+	SkipCertVerify bool        `yaml:"skip-cert-verify,omitempty"`
+	Fingerprint    string      `yaml:"fingerprint,omitempty"`
+	ALPN           []string    `yaml:"alpn,omitempty"`
+	CustomCA       string      `yaml:"ca,omitempty"`
+	CustomCAString string      `yaml:"ca-str,omitempty"`
+	CWND           int         `yaml:"cwnd,omitempty"`
+	UdpMTU         int         `yaml:"udp-mtu,omitempty"`
 
 	// quic-go special config
 	InitialStreamReceiveWindow     uint64 `yaml:"initial-stream-receive-window,omitempty"`

model/proxy/proxy.go

@@ -1,6 +1,31 @@
 package proxy
 
-import "fmt"
+import (
+	"fmt"
+	"strconv"
+
+	"gopkg.in/yaml.v3"
+)
+
+type IntOrString int
+
+func (i *IntOrString) UnmarshalYAML(value *yaml.Node) error {
+	intVal := 0
+	err := yaml.Unmarshal([]byte(value.Value), &intVal)
+	if err == nil {
+		*i = IntOrString(intVal)
+	}
+	strVal := ""
+	err = yaml.Unmarshal([]byte(value.Value), &strVal)
+	if err == nil {
+		_int, err := strconv.ParseInt(strVal, 10, 64)
+		if err != nil {
+			*i = IntOrString(_int)
+		}
+		return err
+	}
+	return nil
+}
 
 type HTTPOptions struct {
 	Method  string              `yaml:"method,omitempty"`
@@ -144,7 +169,137 @@ func (p Proxy) MarshalYAML() (any, error) {
 			Name:  p.Name,
 			Vmess: p.Vmess,
 		}, nil
+	case "socks5":
+		return struct {
+			Type  string `yaml:"type"`
+			Name  string `yaml:"name"`
+			Socks `yaml:",inline"`
+		}{
+			Type:  p.Type,
+			Name:  p.Name,
+			Socks: p.Socks,
+		}, nil
 	default:
 		return nil, fmt.Errorf("unsupported proxy type: %s", p.Type)
 	}
 }
+
+func (p *Proxy) UnmarshalYAML(node *yaml.Node) error {
+	var temp struct {
+		Type string `yaml:"type"`
+		Name string `yaml:"name"`
+	}
+
+	if err := node.Decode(&temp); err != nil {
+		return err
+	}
+
+	p.Type = temp.Type
+	p.Name = temp.Name
+
+	switch temp.Type {
+	case "anytls":
+		var data struct {
+			Type   string `yaml:"type"`
+			Name   string `yaml:"name"`
+			Anytls `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Anytls = data.Anytls
+
+	case "hysteria":
+		var data struct {
+			Type     string `yaml:"type"`
+			Name     string `yaml:"name"`
+			Hysteria `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Hysteria = data.Hysteria
+
+	case "hysteria2":
+		var data struct {
+			Type      string `yaml:"type"`
+			Name      string `yaml:"name"`
+			Hysteria2 `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Hysteria2 = data.Hysteria2
+
+	case "ss":
+		var data struct {
+			Type        string `yaml:"type"`
+			Name        string `yaml:"name"`
+			ShadowSocks `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.ShadowSocks = data.ShadowSocks
+
+	case "ssr":
+		var data struct {
+			Type         string `yaml:"type"`
+			Name         string `yaml:"name"`
+			ShadowSocksR `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.ShadowSocksR = data.ShadowSocksR
+
+	case "trojan":
+		var data struct {
+			Type   string `yaml:"type"`
+			Name   string `yaml:"name"`
+			Trojan `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Trojan = data.Trojan
+
+	case "vless":
+		var data struct {
+			Type  string `yaml:"type"`
+			Name  string `yaml:"name"`
+			Vless `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Vless = data.Vless
+
+	case "vmess":
+		var data struct {
+			Type  string `yaml:"type"`
+			Name  string `yaml:"name"`
+			Vmess `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Vmess = data.Vmess
+
+	case "socks5":
+		var data struct {
+			Type  string `yaml:"type"`
+			Name  string `yaml:"name"`
+			Socks `yaml:",inline"`
+		}
+		if err := node.Decode(&data); err != nil {
+			return err
+		}
+		p.Socks = data.Socks
+
+	default:
+		return fmt.Errorf("unsupported proxy type: %s", temp.Type)
+	}
+
+	return nil
+}

model/proxy/shadowsocks.go

@@ -3,7 +3,7 @@ package proxy
 // https://github.com/MetaCubeX/mihomo/blob/Meta/adapter/outbound/shadowsocks.go
 type ShadowSocks struct {
 	Server            string         `yaml:"server"`
-	Port              int            `yaml:"port"`
+	Port              IntOrString    `yaml:"port"`
 	Password          string         `yaml:"password"`
 	Cipher            string         `yaml:"cipher"`
 	UDP               bool           `yaml:"udp,omitempty"`

model/proxy/shadowsocksr.go

@@ -2,13 +2,13 @@ package proxy
 
 // https://github.com/MetaCubeX/mihomo/blob/Meta/adapter/outbound/shadowsocksr.go
 type ShadowSocksR struct {
-	Server        string `yaml:"server"`
-	Port          int    `yaml:"port"`
-	Password      string `yaml:"password"`
-	Cipher        string `yaml:"cipher"`
-	Obfs          string `yaml:"obfs"`
-	ObfsParam     string `yaml:"obfs-param,omitempty"`
-	Protocol      string `yaml:"protocol"`
-	ProtocolParam string `yaml:"protocol-param,omitempty"`
-	UDP           bool   `yaml:"udp,omitempty"`
+	Server        string      `yaml:"server"`
+	Port          IntOrString `yaml:"port"`
+	Password      string      `yaml:"password"`
+	Cipher        string      `yaml:"cipher"`
+	Obfs          string      `yaml:"obfs"`
+	ObfsParam     string      `yaml:"obfs-param,omitempty"`
+	Protocol      string      `yaml:"protocol"`
+	ProtocolParam string      `yaml:"protocol-param,omitempty"`
+	UDP           bool        `yaml:"udp,omitempty"`
 }

model/proxy/socks.go

@@ -2,12 +2,12 @@ package proxy
 
 // https://github.com/MetaCubeX/mihomo/blob/Meta/adapter/outbound/socks5.go
 type Socks struct {
-	Server         string `yaml:"server"`
-	Port           int    `yaml:"port"`
-	UserName       string `yaml:"username,omitempty"`
-	Password       string `yaml:"password,omitempty"`
-	TLS            bool   `yaml:"tls,omitempty"`
-	UDP            bool   `yaml:"udp,omitempty"`
-	SkipCertVerify bool   `yaml:"skip-cert-verify,omitempty"`
-	Fingerprint    string `yaml:"fingerprint,omitempty"`
+	Server         string      `yaml:"server"`
+	Port           IntOrString `yaml:"port"`
+	UserName       string      `yaml:"username,omitempty"`
+	Password       string      `yaml:"password,omitempty"`
+	TLS            bool        `yaml:"tls,omitempty"`
+	UDP            bool        `yaml:"udp,omitempty"`
+	SkipCertVerify bool        `yaml:"skip-cert-verify,omitempty"`
+	Fingerprint    string      `yaml:"fingerprint,omitempty"`
 }

model/proxy/trojan.go

@@ -3,7 +3,7 @@ package proxy
 // https://github.com/MetaCubeX/mihomo/blob/Meta/adapter/outbound/trojan.go
 type Trojan struct {
 	Server            string         `yaml:"server"`
-	Port              int            `yaml:"port"`
+	Port              IntOrString    `yaml:"port"`
 	Password          string         `yaml:"password"`
 	ALPN              []string       `yaml:"alpn,omitempty"`
 	SNI               string         `yaml:"sni,omitempty"`

model/proxy/vless.go

@@ -3,7 +3,7 @@ package proxy
 // https://github.com/MetaCubeX/mihomo/blob/Meta/adapter/outbound/vless.go
 type Vless struct {
 	Server            string            `yaml:"server"`
-	Port              int               `yaml:"port"`
+	Port              IntOrString       `yaml:"port"`
 	UUID              string            `yaml:"uuid"`
 	Flow              string            `yaml:"flow,omitempty"`
 	TLS               bool              `yaml:"tls,omitempty"`

model/proxy/vmess.go

@@ -3,9 +3,9 @@ package proxy
 // https://github.com/MetaCubeX/mihomo/blob/Meta/adapter/outbound/vmess.go
 type Vmess struct {
 	Server              string         `yaml:"server"`
-	Port                int            `yaml:"port"`
+	Port                IntOrString    `yaml:"port"`
 	UUID                string         `yaml:"uuid"`
-	AlterID             int            `yaml:"alterId"`
+	AlterID             IntOrString    `yaml:"alterId"`
 	Cipher              string         `yaml:"cipher"`
 	UDP                 bool           `yaml:"udp,omitempty"`
 	Network             string         `yaml:"network,omitempty"`

model/sub_config.go

@@ -1,158 +0,0 @@
-package model
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"errors"
-	"net/url"
-	"regexp"
-	"strings"
-
-	"github.com/gin-gonic/gin"
-)
-
-type SubConfig struct {
-	Sub                 string               `form:"sub" binding:""`
-	Subs                []string             `form:"-" binding:""`
-	Proxy               string               `form:"proxy" binding:""`
-	Proxies             []string             `form:"-" binding:""`
-	Refresh             bool                 `form:"refresh,default=false" binding:""`
-	Template            string               `form:"template" binding:""`
-	RuleProvider        string               `form:"ruleProvider" binding:""`
-	RuleProviders       []RuleProviderStruct `form:"-" binding:""`
-	Rule                string               `form:"rule" binding:""`
-	Rules               []RuleStruct         `form:"-" binding:""`
-	AutoTest            bool                 `form:"autoTest,default=false" binding:""`
-	Lazy                bool                 `form:"lazy,default=false" binding:""`
-	Sort                string               `form:"sort" binding:""`
-	Remove              string               `form:"remove" binding:""`
-	Replace             string               `form:"replace" binding:""`
-	ReplaceKeys         []string             `form:"-" binding:""`
-	ReplaceTo           []string             `form:"-" binding:""`
-	NodeListMode        bool                 `form:"nodeList,default=false" binding:""`
-	IgnoreCountryGrooup bool                 `form:"ignoreCountryGroup,default=false" binding:""`
-	UserAgent           string               `form:"userAgent" binding:""`
-}
-
-type RuleProviderStruct struct {
-	Behavior string
-	Url      string
-	Group    string
-	Prepend  bool
-	Name     string
-}
-
-type RuleStruct struct {
-	Rule    string
-	Prepend bool
-}
-
-func ParseSubQuery(c *gin.Context) (SubConfig, error) {
-	var query SubConfig
-	if err := c.ShouldBind(&query); err != nil {
-		return SubConfig{}, errors.New("参数错误: " + err.Error())
-	}
-	if query.Sub == "" && query.Proxy == "" {
-		return SubConfig{}, errors.New("参数错误: sub 和 proxy 不能同时为空")
-	}
-	if query.Sub != "" {
-		query.Subs = strings.Split(query.Sub, ",")
-		for i := range query.Subs {
-			if !strings.HasPrefix(query.Subs[i], "http") {
-				return SubConfig{}, errors.New("参数错误: sub 格式错误")
-			}
-			if _, err := url.ParseRequestURI(query.Subs[i]); err != nil {
-				return SubConfig{}, errors.New("参数错误: " + err.Error())
-			}
-		}
-	} else {
-		query.Subs = nil
-	}
-	if query.Proxy != "" {
-		query.Proxies = strings.Split(query.Proxy, ",")
-	} else {
-		query.Proxies = nil
-	}
-	if query.Template != "" {
-		if strings.HasPrefix(query.Template, "http") {
-			uri, err := url.ParseRequestURI(query.Template)
-			if err != nil {
-				return SubConfig{}, err
-			}
-			query.Template = uri.String()
-		}
-	}
-	if query.RuleProvider != "" {
-		reg := regexp.MustCompile(`\[(.*?)\]`)
-		ruleProviders := reg.FindAllStringSubmatch(query.RuleProvider, -1)
-		for i := range ruleProviders {
-			length := len(ruleProviders)
-			parts := strings.Split(ruleProviders[length-i-1][1], ",")
-			if len(parts) < 4 {
-				return SubConfig{}, errors.New("参数错误: ruleProvider 格式错误")
-			}
-			u := parts[1]
-			uri, err := url.ParseRequestURI(u)
-			if err != nil {
-				return SubConfig{}, errors.New("参数错误: " + err.Error())
-			}
-			u = uri.String()
-			if len(parts) == 4 {
-				hash := sha256.Sum224([]byte(u))
-				parts = append(parts, hex.EncodeToString(hash[:]))
-			}
-			query.RuleProviders = append(
-				query.RuleProviders, RuleProviderStruct{
-					Behavior: parts[0],
-					Url:      u,
-					Group:    parts[2],
-					Prepend:  parts[3] == "true",
-					Name:     parts[4],
-				},
-			)
-		}
-
-		names := make(map[string]bool)
-		for _, ruleProvider := range query.RuleProviders {
-			if _, ok := names[ruleProvider.Name]; ok {
-				return SubConfig{}, errors.New("参数错误: Rule-Provider 名称重复")
-			}
-			names[ruleProvider.Name] = true
-		}
-	} else {
-		query.RuleProviders = nil
-	}
-	if query.Rule != "" {
-		reg := regexp.MustCompile(`\[(.*?)\]`)
-		rules := reg.FindAllStringSubmatch(query.Rule, -1)
-		for i := range rules {
-			length := len(rules)
-			r := rules[length-1-i][1]
-			strings.LastIndex(r, ",")
-			parts := [2]string{}
-			parts[0] = r[:strings.LastIndex(r, ",")]
-			parts[1] = r[strings.LastIndex(r, ",")+1:]
-			query.Rules = append(
-				query.Rules, RuleStruct{
-					Rule:    parts[0],
-					Prepend: parts[1] == "true",
-				},
-			)
-		}
-	} else {
-		query.Rules = nil
-	}
-	if strings.TrimSpace(query.Replace) != "" {
-		reg := regexp.MustCompile(`\[<(.*?)>,<(.*?)>\]`)
-		replaces := reg.FindAllStringSubmatch(query.Replace, -1)
-		for i := range replaces {
-			length := len(replaces[i])
-			if length != 3 {
-				return SubConfig{}, errors.New("参数错误: replace 格式错误")
-			}
-			query.ReplaceKeys = append(query.ReplaceKeys, replaces[i][1])
-			query.ReplaceTo = append(query.ReplaceTo, replaces[i][2])
-		}
-	}
-	return query, nil
-}

model/subscription.go

@@ -14,51 +14,51 @@ type NodeList struct {
 
 // https://github.com/MetaCubeX/mihomo/blob/Meta/config/config.go RawConfig
 type Subscription struct {
-	Port                    int            `yaml:"port,omitempty" json:"port"`
-	SocksPort               int            `yaml:"socks-port,omitempty" json:"socks-port"`
-	RedirPort               int            `yaml:"redir-port,omitempty" json:"redir-port"`
-	TProxyPort              int            `yaml:"tproxy-port,omitempty" json:"tproxy-port"`
-	MixedPort               int            `yaml:"mixed-port,omitempty" json:"mixed-port"`
-	ShadowSocksConfig       string         `yaml:"ss-config,omitempty" json:"ss-config"`
-	VmessConfig             string         `yaml:"vmess-config,omitempty" json:"vmess-config"`
-	InboundTfo              bool           `yaml:"inbound-tfo,omitempty" json:"inbound-tfo"`
-	InboundMPTCP            bool           `yaml:"inbound-mptcp,omitempty" json:"inbound-mptcp"`
-	Authentication          []string       `yaml:"authentication,omitempty" json:"authentication"`
-	SkipAuthPrefixes        []netip.Prefix `yaml:"skip-auth-prefixes,omitempty" json:"skip-auth-prefixes"`
-	LanAllowedIPs           []netip.Prefix `yaml:"lan-allowed-ips,omitempty" json:"lan-allowed-ips"`
-	LanDisAllowedIPs        []netip.Prefix `yaml:"lan-disallowed-ips,omitempty" json:"lan-disallowed-ips"`
-	AllowLan                bool           `yaml:"allow-lan,omitempty" json:"allow-lan"`
-	BindAddress             string         `yaml:"bind-address,omitempty" json:"bind-address"`
-	Mode                    string         `yaml:"mode,omitempty" json:"mode"`
-	UnifiedDelay            bool           `yaml:"unified-delay,omitempty" json:"unified-delay"`
-	LogLevel                string         `yaml:"log-level,omitempty" json:"log-level"`
-	IPv6                    bool           `yaml:"ipv6,omitempty" json:"ipv6"`
-	ExternalController      string         `yaml:"external-controller,omitempty" json:"external-controller"`
-	ExternalControllerPipe  string         `yaml:"external-controller-pipe,omitempty" json:"external-controller-pipe"`
-	ExternalControllerUnix  string         `yaml:"external-controller-unix,omitempty" json:"external-controller-unix"`
-	ExternalControllerTLS   string         `yaml:"external-controller-tls,omitempty" json:"external-controller-tls"`
-	ExternalControllerCors  C.RawCors      `yaml:"external-controller-cors,omitempty" json:"external-controller-cors"`
-	ExternalUI              string         `yaml:"external-ui,omitempty" json:"external-ui"`
-	ExternalUIURL           string         `yaml:"external-ui-url,omitempty" json:"external-ui-url"`
-	ExternalUIName          string         `yaml:"external-ui-name,omitempty" json:"external-ui-name"`
-	ExternalDohServer       string         `yaml:"external-doh-server,omitempty" json:"external-doh-server"`
-	Secret                  string         `yaml:"secret,omitempty" json:"secret"`
-	Interface               string         `yaml:"interface-name,omitempty" json:"interface-name"`
-	RoutingMark             int            `yaml:"routing-mark,omitempty" json:"routing-mark"`
-	Tunnels                 []LC.Tunnel    `yaml:"tunnels,omitempty" json:"tunnels"`
-	GeoAutoUpdate           bool           `yaml:"geo-auto-update,omitempty" json:"geo-auto-update"`
-	GeoUpdateInterval       int            `yaml:"geo-update-interval,omitempty" json:"geo-update-interval"`
-	GeodataMode             bool           `yaml:"geodata-mode,omitempty" json:"geodata-mode"`
-	GeodataLoader           string         `yaml:"geodata-loader,omitempty" json:"geodata-loader"`
-	GeositeMatcher          string         `yaml:"geosite-matcher,omitempty" json:"geosite-matcher"`
-	TCPConcurrent           bool           `yaml:"tcp-concurrent,omitempty" json:"tcp-concurrent"`
-	FindProcessMode         string         `yaml:"find-process-mode,omitempty" json:"find-process-mode"`
-	GlobalClientFingerprint string         `yaml:"global-client-fingerprint,omitempty" json:"global-client-fingerprint"`
-	GlobalUA                string         `yaml:"global-ua,omitempty" json:"global-ua"`
-	ETagSupport             bool           `yaml:"etag-support,omitempty" json:"etag-support"`
-	KeepAliveIdle           int            `yaml:"keep-alive-idle,omitempty" json:"keep-alive-idle"`
-	KeepAliveInterval       int            `yaml:"keep-alive-interval,omitempty" json:"keep-alive-interval"`
-	DisableKeepAlive        bool           `yaml:"disable-keep-alive,omitempty" json:"disable-keep-alive"`
+	Port                    proxy.IntOrString `yaml:"port,omitempty" json:"port"`
+	SocksPort               proxy.IntOrString `yaml:"socks-port,omitempty" json:"socks-port"`
+	RedirPort               proxy.IntOrString `yaml:"redir-port,omitempty" json:"redir-port"`
+	TProxyPort              proxy.IntOrString `yaml:"tproxy-port,omitempty" json:"tproxy-port"`
+	MixedPort               proxy.IntOrString `yaml:"mixed-port,omitempty" json:"mixed-port"`
+	ShadowSocksConfig       string            `yaml:"ss-config,omitempty" json:"ss-config"`
+	VmessConfig             string            `yaml:"vmess-config,omitempty" json:"vmess-config"`
+	InboundTfo              bool              `yaml:"inbound-tfo,omitempty" json:"inbound-tfo"`
+	InboundMPTCP            bool              `yaml:"inbound-mptcp,omitempty" json:"inbound-mptcp"`
+	Authentication          []string          `yaml:"authentication,omitempty" json:"authentication"`
+	SkipAuthPrefixes        []netip.Prefix    `yaml:"skip-auth-prefixes,omitempty" json:"skip-auth-prefixes"`
+	LanAllowedIPs           []netip.Prefix    `yaml:"lan-allowed-ips,omitempty" json:"lan-allowed-ips"`
+	LanDisAllowedIPs        []netip.Prefix    `yaml:"lan-disallowed-ips,omitempty" json:"lan-disallowed-ips"`
+	AllowLan                bool              `yaml:"allow-lan,omitempty" json:"allow-lan"`
+	BindAddress             string            `yaml:"bind-address,omitempty" json:"bind-address"`
+	Mode                    string            `yaml:"mode,omitempty" json:"mode"`
+	UnifiedDelay            bool              `yaml:"unified-delay,omitempty" json:"unified-delay"`
+	LogLevel                string            `yaml:"log-level,omitempty" json:"log-level"`
+	IPv6                    bool              `yaml:"ipv6,omitempty" json:"ipv6"`
+	ExternalController      string            `yaml:"external-controller,omitempty" json:"external-controller"`
+	ExternalControllerPipe  string            `yaml:"external-controller-pipe,omitempty" json:"external-controller-pipe"`
+	ExternalControllerUnix  string            `yaml:"external-controller-unix,omitempty" json:"external-controller-unix"`
+	ExternalControllerTLS   string            `yaml:"external-controller-tls,omitempty" json:"external-controller-tls"`
+	ExternalControllerCors  C.RawCors         `yaml:"external-controller-cors,omitempty" json:"external-controller-cors"`
+	ExternalUI              string            `yaml:"external-ui,omitempty" json:"external-ui"`
+	ExternalUIURL           string            `yaml:"external-ui-url,omitempty" json:"external-ui-url"`
+	ExternalUIName          string            `yaml:"external-ui-name,omitempty" json:"external-ui-name"`
+	ExternalDohServer       string            `yaml:"external-doh-server,omitempty" json:"external-doh-server"`
+	Secret                  string            `yaml:"secret,omitempty" json:"secret"`
+	Interface               string            `yaml:"interface-name,omitempty" json:"interface-name"`
+	RoutingMark             int               `yaml:"routing-mark,omitempty" json:"routing-mark"`
+	Tunnels                 []LC.Tunnel       `yaml:"tunnels,omitempty" json:"tunnels"`
+	GeoAutoUpdate           bool              `yaml:"geo-auto-update,omitempty" json:"geo-auto-update"`
+	GeoUpdateInterval       int               `yaml:"geo-update-interval,omitempty" json:"geo-update-interval"`
+	GeodataMode             bool              `yaml:"geodata-mode,omitempty" json:"geodata-mode"`
+	GeodataLoader           string            `yaml:"geodata-loader,omitempty" json:"geodata-loader"`
+	GeositeMatcher          string            `yaml:"geosite-matcher,omitempty" json:"geosite-matcher"`
+	TCPConcurrent           bool              `yaml:"tcp-concurrent,omitempty" json:"tcp-concurrent"`
+	FindProcessMode         string            `yaml:"find-process-mode,omitempty" json:"find-process-mode"`
+	GlobalClientFingerprint string            `yaml:"global-client-fingerprint,omitempty" json:"global-client-fingerprint"`
+	GlobalUA                string            `yaml:"global-ua,omitempty" json:"global-ua"`
+	ETagSupport             bool              `yaml:"etag-support,omitempty" json:"etag-support"`
+	KeepAliveIdle           int               `yaml:"keep-alive-idle,omitempty" json:"keep-alive-idle"`
+	KeepAliveInterval       int               `yaml:"keep-alive-interval,omitempty" json:"keep-alive-interval"`
+	DisableKeepAlive        bool              `yaml:"disable-keep-alive,omitempty" json:"disable-keep-alive"`
 
 	ProxyProvider map[string]map[string]any `yaml:"proxy-providers,omitempty" json:"proxy-providers"`
 	RuleProvider  map[string]RuleProvider   `yaml:"rule-providers,omitempty" json:"rule-providers"`

parser/anytls.go

@@ -26,7 +26,7 @@ func (p *AnytlsParser) GetType() string {
 	return "anytls"
 }
 
-func (p *AnytlsParser) Parse(proxy string) (P.Proxy, error) {
+func (p *AnytlsParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -68,10 +68,11 @@ func (p *AnytlsParser) Parse(proxy string) (P.Proxy, error) {
 		Name: remarks,
 		Anytls: P.Anytls{
 			Server:         server,
-			Port:           port,
+			Port:           P.IntOrString(port),
 			Password:       password,
 			SNI:            sni,
 			SkipCertVerify: insecureBool,
+			UDP:            config.UseUDP,
 		},
 	}
 	return result, nil

parser/common.go

@@ -1,12 +1,13 @@
 package parser
 
 import (
-	"encoding/base64"
 	"errors"
 	"strconv"
 	"strings"
+	"unicode/utf8"
 
 	P "github.com/bestnite/sub2clash/model/proxy"
+	"github.com/bestnite/sub2clash/utils"
 )
 
 func hasPrefix(proxy string, prefixes []string) bool {
@@ -32,8 +33,13 @@ func ParsePort(portStr string) (int, error) {
 	return port, nil
 }
 
+// isLikelyBase64 不严格判断是否是合法的 Base64, 很多分享链接不符合 Base64 规范
 func isLikelyBase64(s string) bool {
-	if len(s)%4 == 0 && strings.HasSuffix(s, "=") && !strings.Contains(strings.TrimSuffix(s, "="), "=") {
+	if strings.TrimSpace(s) == "" {
+		return false
+	}
+
+	if !strings.Contains(strings.TrimSuffix(s, "="), "=") {
 		s = strings.TrimSuffix(s, "=")
 		chars := "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
 		for _, c := range s {
@@ -41,36 +47,31 @@ func isLikelyBase64(s string) bool {
 				return false
 			}
 		}
-		return true
 	}
-	return false
-}
 
-func DecodeBase64(s string) (string, error) {
-	s = strings.TrimSpace(s)
-
-	if strings.Contains(s, "-") || strings.Contains(s, "_") {
-		s = strings.Replace(s, "-", "+", -1)
-		s = strings.Replace(s, "_", "/", -1)
-	}
-	if len(s)%4 != 0 {
-		s += strings.Repeat("=", 4-len(s)%4)
-	}
-	decodeStr, err := base64.StdEncoding.DecodeString(s)
+	decoded, err := utils.DecodeBase64(s, true)
 	if err != nil {
-		return "", err
+		return false
 	}
-	return string(decodeStr), nil
+	if !utf8.ValidString(decoded) {
+		return false
+	}
+
+	return true
 }
 
-func ParseProxies(proxies ...string) ([]P.Proxy, error) {
+type ParseConfig struct {
+	UseUDP bool
+}
+
+func ParseProxies(config ParseConfig, proxies ...string) ([]P.Proxy, error) {
 	var result []P.Proxy
 	for _, proxy := range proxies {
 		if proxy != "" {
 			var proxyItem P.Proxy
 			var err error
 
-			proxyItem, err = ParseProxyWithRegistry(proxy)
+			proxyItem, err = ParseProxyWithRegistry(config, proxy)
 			if err != nil {
 				return nil, err
 			}

parser/hysteria.go

@@ -27,7 +27,7 @@ func (p *HysteriaParser) GetType() string {
 	return "hysteria"
 }
 
-func (p *HysteriaParser) Parse(proxy string) (P.Proxy, error) {
+func (p *HysteriaParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -76,7 +76,7 @@ func (p *HysteriaParser) Parse(proxy string) (P.Proxy, error) {
 		Name: remarks,
 		Hysteria: P.Hysteria{
 			Server:         server,
-			Port:           port,
+			Port:           P.IntOrString(port),
 			Up:             upmbps,
 			Down:           downmbps,
 			Auth:           auth,

parser/hysteria2.go

@@ -26,7 +26,7 @@ func (p *Hysteria2Parser) GetType() string {
 	return "hysteria2"
 }
 
-func (p *Hysteria2Parser) Parse(proxy string) (P.Proxy, error) {
+func (p *Hysteria2Parser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -68,7 +68,7 @@ func (p *Hysteria2Parser) Parse(proxy string) (P.Proxy, error) {
 		Name: remarks,
 		Hysteria2: P.Hysteria2{
 			Server:         server,
-			Port:           port,
+			Port:           P.IntOrString(port),
 			Password:       password,
 			Obfs:           obfs,
 			ObfsPassword:   obfsPassword,

parser/registry.go

@@ -9,7 +9,7 @@ import (
 )
 
 type ProxyParser interface {
-	Parse(proxy string) (P.Proxy, error)
+	Parse(config ParseConfig, proxy string) (P.Proxy, error)
 	GetPrefixes() []string
 	GetType() string
 	SupportClash() bool
@@ -64,7 +64,7 @@ func GetAllPrefixes() []string {
 	return prefixes
 }
 
-func ParseProxyWithRegistry(proxy string) (P.Proxy, error) {
+func ParseProxyWithRegistry(config ParseConfig, proxy string) (P.Proxy, error) {
 	proxy = strings.TrimSpace(proxy)
 	if proxy == "" {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "empty proxy string")
@@ -72,7 +72,7 @@ func ParseProxyWithRegistry(proxy string) (P.Proxy, error) {
 
 	for prefix, parser := range registry.parsers {
 		if strings.HasPrefix(proxy, prefix) {
-			return parser.Parse(proxy)
+			return parser.Parse(config, proxy)
 		}
 	}
 

parser/shadowsocks.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	P "github.com/bestnite/sub2clash/model/proxy"
+	"github.com/bestnite/sub2clash/utils"
 )
 
 // ShadowsocksParser Shadowsocks协议解析器
@@ -30,7 +31,7 @@ func (p *ShadowsocksParser) GetType() string {
 }
 
 // Parse 解析Shadowsocks代理
-func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
+func (p *ShadowsocksParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -43,7 +44,7 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
 				break
 			}
 		}
-		d, err := DecodeBase64(s[0])
+		d, err := utils.DecodeBase64(s[0], true)
 		if err != nil {
 			return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
 		}
@@ -76,7 +77,7 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
 	password, hasPassword := link.User.Password()
 
 	if !hasPassword && isLikelyBase64(method) {
-		decodedStr, err := DecodeBase64(method)
+		decodedStr, err := utils.DecodeBase64(method, true)
 		if err == nil {
 			methodAndPass := strings.SplitN(decodedStr, ":", 2)
 			if len(methodAndPass) == 2 {
@@ -88,7 +89,7 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
 		}
 	}
 	if password != "" && isLikelyBase64(password) {
-		password, err = DecodeBase64(password)
+		password, err = utils.DecodeBase64(password, true)
 		if err != nil {
 			return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
 		}
@@ -107,10 +108,10 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
 			Cipher:   method,
 			Password: password,
 			Server:   server,
-			Port:     port,
+			Port:     P.IntOrString(port),
+			UDP:      config.UseUDP,
 		},
 	}
-
 	return result, nil
 }
 

parser/shadowsocksr.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	P "github.com/bestnite/sub2clash/model/proxy"
+	"github.com/bestnite/sub2clash/utils"
 )
 
 type ShadowsocksRParser struct{}
@@ -27,7 +28,7 @@ func (p *ShadowsocksRParser) GetType() string {
 	return "ssr"
 }
 
-func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
+func (p *ShadowsocksRParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -39,7 +40,7 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
 		}
 	}
 
-	proxy, err := DecodeBase64(proxy)
+	proxy, err := utils.DecodeBase64(proxy, true)
 	if err != nil {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidBase64, err.Error())
 	}
@@ -55,7 +56,7 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
 	protocol := parts[2]
 	method := parts[3]
 	obfs := parts[4]
-	password, err := DecodeBase64(parts[5])
+	password, err := utils.DecodeBase64(parts[5], true)
 	if err != nil {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
 	}
@@ -73,13 +74,13 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
 			return P.Proxy{}, fmt.Errorf("%w: %s", ErrCannotParseParams, err.Error())
 		}
 		if params.Get("obfsparam") != "" {
-			obfsParam, err = DecodeBase64(params.Get("obfsparam"))
+			obfsParam, err = utils.DecodeBase64(params.Get("obfsparam"), true)
 		}
 		if params.Get("protoparam") != "" {
-			protoParam, err = DecodeBase64(params.Get("protoparam"))
+			protoParam, err = utils.DecodeBase64(params.Get("protoparam"), true)
 		}
 		if params.Get("remarks") != "" {
-			remarks, err = DecodeBase64(params.Get("remarks"))
+			remarks, err = utils.DecodeBase64(params.Get("remarks"), true)
 		} else {
 			remarks = server + ":" + strconv.Itoa(port)
 		}
@@ -93,16 +94,16 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
 		Name: remarks,
 		ShadowSocksR: P.ShadowSocksR{
 			Server:        server,
-			Port:          port,
+			Port:          P.IntOrString(port),
 			Protocol:      protocol,
 			Cipher:        method,
 			Obfs:          obfs,
 			Password:      password,
 			ObfsParam:     obfsParam,
 			ProtocolParam: protoParam,
+			UDP:           config.UseUDP,
 		},
 	}
-
 	return result, nil
 }
 

parser/socks.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	P "github.com/bestnite/sub2clash/model/proxy"
+	"github.com/bestnite/sub2clash/utils"
 )
 
 type SocksParser struct{}
@@ -18,14 +19,14 @@ func (p *SocksParser) SupportMeta() bool {
 }
 
 func (p *SocksParser) GetPrefixes() []string {
-	return []string{"socks://"}
+	return []string{"socks://", "socks5://"}
 }
 
 func (p *SocksParser) GetType() string {
 	return "socks5"
 }
 
-func (p *SocksParser) Parse(proxy string) (P.Proxy, error) {
+func (p *SocksParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -59,7 +60,7 @@ func (p *SocksParser) Parse(proxy string) (P.Proxy, error) {
 	password, hasPassword := link.User.Password()
 
 	if !hasPassword && isLikelyBase64(username) {
-		decodedStr, err := DecodeBase64(username)
+		decodedStr, err := utils.DecodeBase64(username, true)
 		if err == nil {
 			usernameAndPassword := strings.SplitN(decodedStr, ":", 2)
 			if len(usernameAndPassword) == 2 {
@@ -78,7 +79,7 @@ func (p *SocksParser) Parse(proxy string) (P.Proxy, error) {
 		Name: remarks,
 		Socks: P.Socks{
 			Server:   server,
-			Port:     port,
+			Port:     P.IntOrString(port),
 			UserName: username,
 			Password: password,
 			TLS:      tls == "true",

parser/trojan.go

@@ -26,7 +26,7 @@ func (p *TrojanParser) GetType() string {
 	return "trojan"
 }
 
-func (p *TrojanParser) Parse(proxy string) (P.Proxy, error) {
+func (p *TrojanParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -58,7 +58,17 @@ func (p *TrojanParser) Parse(proxy string) (P.Proxy, error) {
 	remarks = strings.TrimSpace(remarks)
 
 	query := link.Query()
-	network, security, alpnStr, sni, pbk, sid, fp, path, host, serviceName, udp := query.Get("type"), query.Get("security"), query.Get("alpn"), query.Get("sni"), query.Get("pbk"), query.Get("sid"), query.Get("fp"), query.Get("path"), query.Get("host"), query.Get("serviceName"), query.Get("udp")
+	network, security, alpnStr, sni, pbk, sid, fp, path, host, serviceName, udp, insecure := query.Get("type"), query.Get("security"), query.Get("alpn"), query.Get("sni"), query.Get("pbk"), query.Get("sid"), query.Get("fp"), query.Get("path"), query.Get("host"), query.Get("serviceName"), query.Get("udp"), query.Get("allowInsecure")
+
+	insecureBool := insecure == "1"
+	result := P.Trojan{
+		Server:         server,
+		Port:           P.IntOrString(port),
+		Password:       password,
+		Network:        network,
+		UDP:            udp == "true",
+		SkipCertVerify: insecureBool,
+	}
 
 	var alpn []string
 	if strings.Contains(alpnStr, ",") {
@@ -66,27 +76,23 @@ func (p *TrojanParser) Parse(proxy string) (P.Proxy, error) {
 	} else {
 		alpn = nil
 	}
-
-	result := P.Trojan{
-		Server:   server,
-		Port:     port,
-		Password: password,
-		Network:  network,
-		UDP:      udp == "true",
+	if len(alpn) > 0 {
+		result.ALPN = alpn
 	}
 
-	if security == "xtls" || security == "tls" {
-		result.ALPN = alpn
+	if fp != "" {
+		result.ClientFingerprint = fp
+	}
+
+	if sni != "" {
 		result.SNI = sni
 	}
 
 	if security == "reality" {
-		result.SNI = sni
 		result.RealityOpts = P.RealityOptions{
 			PublicKey: pbk,
 			ShortID:   sid,
 		}
-		result.Fingerprint = fp
 	}
 
 	if network == "ws" {

parser/vless.go

@@ -26,7 +26,7 @@ func (p *VlessParser) GetType() string {
 	return "vless"
 }
 
-func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
+func (p *VlessParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -57,6 +57,7 @@ func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
 	} else {
 		alpn = nil
 	}
+
 	remarks := link.Fragment
 	if remarks == "" {
 		remarks = fmt.Sprintf("%s:%s", server, portStr)
@@ -64,29 +65,36 @@ func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
 	remarks = strings.TrimSpace(remarks)
 
 	result := P.Vless{
-		Server: server,
-		Port:   port,
-		UUID:   uuid,
-		Flow:   flow,
-		UDP:    udp == "true",
+		Server:         server,
+		Port:           P.IntOrString(port),
+		UUID:           uuid,
+		Flow:           flow,
+		UDP:            udp == "true",
+		SkipCertVerify: insecureBool,
+	}
+
+	if len(alpn) > 0 {
+		result.ALPN = alpn
+	}
+
+	if fp != "" {
+		result.ClientFingerprint = fp
+	}
+
+	if sni != "" {
+		result.ServerName = sni
 	}
 
 	if security == "tls" {
 		result.TLS = true
-		result.ALPN = alpn
-		result.SkipCertVerify = insecureBool
-		result.Fingerprint = fp
-		result.ServerName = sni
 	}
 
 	if security == "reality" {
 		result.TLS = true
-		result.ServerName = sni
 		result.RealityOpts = P.RealityOptions{
 			PublicKey: pbk,
 			ShortID:   sid,
 		}
-		result.Fingerprint = fp
 	}
 
 	if _type == "ws" {

parser/vmess.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	P "github.com/bestnite/sub2clash/model/proxy"
+	"github.com/bestnite/sub2clash/utils"
 )
 
 type VmessJson struct {
@@ -46,7 +47,7 @@ func (p *VmessParser) GetType() string {
 	return "vmess"
 }
 
-func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
+func (p *VmessParser) Parse(config ParseConfig, proxy string) (P.Proxy, error) {
 	if !hasPrefix(proxy, p.GetPrefixes()) {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
 	}
@@ -57,7 +58,7 @@ func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
 			break
 		}
 	}
-	base64, err := DecodeBase64(proxy)
+	base64, err := utils.DecodeBase64(proxy, true)
 	if err != nil {
 		return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidBase64, err.Error())
 	}
@@ -99,25 +100,36 @@ func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
 		name = vmess.Ps
 	}
 
+	var alpn []string
+	if strings.Contains(vmess.Alpn, ",") {
+		alpn = strings.Split(vmess.Alpn, ",")
+	} else {
+		alpn = nil
+	}
+
 	result := P.Vmess{
 		Server:  vmess.Add,
-		Port:    port,
+		Port:    P.IntOrString(port),
 		UUID:    vmess.Id,
-		AlterID: aid,
+		AlterID: P.IntOrString(aid),
 		Cipher:  vmess.Scy,
+		UDP:     config.UseUDP,
+	}
+
+	if len(alpn) > 0 {
+		result.ALPN = alpn
+	}
+
+	if vmess.Fp != "" {
+		result.ClientFingerprint = vmess.Fp
+	}
+
+	if vmess.Sni != "" {
+		result.ServerName = vmess.Sni
 	}
 
 	if vmess.Tls == "tls" {
-		var alpn []string
-		if strings.Contains(vmess.Alpn, ",") {
-			alpn = strings.Split(vmess.Alpn, ",")
-		} else {
-			alpn = nil
-		}
 		result.TLS = true
-		result.Fingerprint = vmess.Fp
-		result.ALPN = alpn
-		result.ServerName = vmess.Sni
 	}
 
 	if vmess.Net == "ws" {

server/handler/convert.go

@@ -12,14 +12,14 @@ import (
 	"gopkg.in/yaml.v3"
 )
 
-func SubHandler(model M.ClashType, template string) func(c *gin.Context) {
+func ConvertHandler(template string) func(c *gin.Context) {
 	return func(c *gin.Context) {
-		query, err := M.ParseSubQuery(c)
+		query, err := M.ParseConvertQuery(c)
 		if err != nil {
 			c.String(http.StatusBadRequest, err.Error())
 			return
 		}
-		sub, err := common.BuildSub(model, query, template, config.GlobalConfig.CacheExpire, config.GlobalConfig.RequestRetryTimes)
+		sub, err := common.BuildSub(query.ClashType, query, template, config.GlobalConfig.CacheExpire, config.GlobalConfig.RequestRetryTimes)
 		if err != nil {
 			c.String(http.StatusInternalServerError, err.Error())
 			return

server/handler/short_link.go

@@ -1,6 +1,7 @@
 package handler
 
 import (
+	"fmt"
 	"io"
 	"net/http"
 	"strings"
@@ -141,7 +142,6 @@ func UpdateLinkHandler(c *gin.Context) {
 }
 
 func GetRawConfHandler(c *gin.Context) {
-
 	hash := c.Param("hash")
 	password := c.Query("password")
 
@@ -168,7 +168,19 @@ func GetRawConfHandler(c *gin.Context) {
 		return
 	}
 
-	response, err := http.Get(strings.TrimSuffix(config.GlobalConfig.Address, "/") + "/" + shortLink.Url)
+	scheme := "http"
+	if c.Request.TLS != nil {
+		scheme = "https"
+	}
+	host := c.Request.Host
+	targetPath := strings.TrimPrefix(shortLink.Url, "/")
+	requestURL := fmt.Sprintf("%s://%s/%s", scheme, host, targetPath)
+
+	client := &http.Client{
+		Timeout: 30 * time.Second, // 30秒超时
+	}
+
+	response, err := client.Get(requestURL)
 	if err != nil {
 		respondWithError(c, http.StatusInternalServerError, "请求错误: "+err.Error())
 		return
@@ -185,7 +197,6 @@ func GetRawConfHandler(c *gin.Context) {
 }
 
 func GetRawConfUriHandler(c *gin.Context) {
-
 	hash := c.Query("hash")
 	password := c.Query("password")
 

server/route.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/bestnite/sub2clash/config"
 	"github.com/bestnite/sub2clash/constant"
-	"github.com/bestnite/sub2clash/model"
 	"github.com/bestnite/sub2clash/server/handler"
 	"github.com/bestnite/sub2clash/server/middleware"
 
@@ -40,8 +39,7 @@ func SetRoute(r *gin.Engine) {
 			)
 		},
 	)
-	r.GET("/clash", middleware.ZapLogger(), handler.SubHandler(model.Clash, config.GlobalConfig.ClashTemplate))
-	r.GET("/meta", middleware.ZapLogger(), handler.SubHandler(model.ClashMeta, config.GlobalConfig.MetaTemplate))
+	r.GET("/convert/:config", middleware.ZapLogger(), handler.ConvertHandler(config.GlobalConfig.ClashTemplate))
 	r.GET("/s/:hash", middleware.ZapLogger(), handler.GetRawConfHandler)
 	r.POST("/short", middleware.ZapLogger(), handler.GenerateLinkHandler)
 	r.PUT("/short", middleware.ZapLogger(), handler.UpdateLinkHandler)

server/static/index.html

@@ -1,5 +1,5 @@
 <!DOCTYPE html>
-<html lang="zh-CN">
+<html lang="zh-CN" data-bs-theme="light">
 
 <head>
     <meta charset="UTF-8" />
@@ -28,10 +28,38 @@
             height: 25px;
             width: 25px;
         }
+
+        /* 主题切换按钮样式 */
+        .theme-toggle {
+            position: fixed;
+            top: 20px;
+            right: 20px;
+            z-index: 1000;
+            border: none;
+            border-radius: 50%;
+            width: 50px;
+            height: 50px;
+            font-size: 20px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            transition: all 0.3s ease;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+        }
+
+        .theme-toggle:hover {
+            transform: scale(1.1);
+            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.2);
+        }
     </style>
 </head>
 
-<body class="bg-light">
+<body>
+    <!-- 主题切换按钮 -->
+    <button class="theme-toggle btn btn-outline-secondary" onclick="toggleTheme()" title="切换深色/浅色模式">
+        <span id="theme-icon">🌙</span>
+    </button>
+
     <div class="container mt-5">
         <div class="mb-4">
             <h2>sub2clash</h2>
@@ -54,14 +82,14 @@
         <div class="form-group mb-3">
             <label for="endpoint">客户端类型:</label>
             <select class="form-control" id="endpoint" name="endpoint">
-                <option value="clash">Clash</option>
-                <option value="meta">Clash.Meta</option>
+                <option value="1">Clash</option>
+                <option value="2" selected>Clash.Meta</option>
             </select>
         </div>
         <!-- Template -->
         <div class="form-group mb-3">
             <label for="template">模板链接或名称:</label>
-            <input class="form-control" id="template" name="template" placeholder="输入外部模板链接或内部模板名称（可选）" type="text" />
+            <input class="form-control" id="template" name="template" placeholder="输入模板链接（可选）" type="text" />
         </div>
         <!-- Subscription Link -->
         <div class="form-group mb-3">
@@ -75,9 +103,9 @@
         </div>
         <!-- User Agent -->
         <div class="form-group mb-3">
-            <label for="user-agent">ua标识:</label>
+            <label for="user-agent">UA 标识:</label>
             <textarea class="form-control" id="user-agent" name="user-agent"
-                placeholder="用于获取订阅的http请求中的user-agent标识(可选)" rows="3"></textarea>
+                placeholder="用于获取订阅的 http 请求中的 User-Agent 标识（可选）" rows="3"></textarea>
         </div>
         <!-- Refresh -->
         <div class="form-check mb-3">
@@ -104,6 +132,11 @@
             <input class="form-check-input" id="igcg" name="igcg" type="checkbox" />
             <label class="form-check-label" for="igcg">不输出国家策略组</label>
         </div>
+        <!-- Use UDP -->
+        <div class="form-check mb-3">
+            <input class="form-check-input" id="useUDP" name="useUDP" type="checkbox" />
+            <label class="form-check-label" for="useUDP">使用 UDP</label>
+        </div>
         <!-- Rule Provider -->
         <div class="form-group mb-3" id="ruleProviderGroup">
             <label>Rule Provider:</label>
@@ -145,8 +178,9 @@
         <div class="form-group mb-5">
             <label for="apiLink">配置链接:</label>
             <div class="input-group mb-2">
-                <input class="form-control bg-light" id="apiLink" type="text" placeholder="链接" readonly
+                <input class="form-control" id="apiLink" type="text" placeholder="链接" readonly
                     style="cursor: not-allowed;" />
+                <button class="btn btn-primary" onclick="generateURL()" type="button">生成配置</button>
                 <button class="btn btn-primary" onclick="copyToClipboard('apiLink',this)" type="button">
                     复制链接
                 </button>
@@ -162,7 +196,7 @@
                 </button>
             </div>
             <div class="input-group">
-                <input class="form-control bg-light" id="apiShortLink" type="text" placeholder="短链接" readonly
+                <input class="form-control" id="apiShortLink" type="text" placeholder="短链接" readonly
                     style="cursor: not-allowed;" />
                 <button class="btn btn-primary" onclick="updateShortLink()" type="button">
                     更新短链

server/static/index.js

@@ -1,11 +1,9 @@
 function setInputReadOnly(input, readonly) {
   if (readonly) {
     input.readOnly = true;
-    input.classList.add('bg-light');
     input.style.cursor = 'not-allowed';
   } else {
     input.readOnly = false;
-    input.classList.remove('bg-light');
     input.style.cursor = 'auto';
   }
 }
@@ -19,28 +17,29 @@ function clearExistingValues() {
   document.getElementById("autoTest").checked = false;
   document.getElementById("lazy").checked = false;
   document.getElementById("igcg").checked = false;
+  document.getElementById("useUDP").checked = false;
   document.getElementById("template").value = "";
   document.getElementById("sort").value = "nameasc";
   document.getElementById("remove").value = "";
   document.getElementById("apiLink").value = "";
   document.getElementById("apiShortLink").value = "";
-  
+
   // 恢复短链ID和密码输入框状态
   const customIdInput = document.getElementById("customId");
   const passwordInput = document.getElementById("password");
   const generateButton = document.querySelector('button[onclick="generateShortLink()"]');
-  
+
   customIdInput.value = "";
   setInputReadOnly(customIdInput, false);
-  
+
   passwordInput.value = "";
   setInputReadOnly(passwordInput, false);
-  
+
   // 恢复生成短链按钮状态
   generateButton.disabled = false;
   generateButton.classList.remove('btn-secondary');
   generateButton.classList.add('btn-primary');
-  
+
   document.getElementById("nodeList").checked = false;
 
   // 清除由 createRuleProvider, createReplace, 和 createRule 创建的所有额外输入组
@@ -50,139 +49,138 @@ function clearExistingValues() {
 }
 
 function generateURI() {
-  const queryParams = [];
+  const config = {};
 
-  // 获取 API Endpoint
-  const endpoint = document.getElementById("endpoint").value;
+  config.clashType = parseInt(document.getElementById("endpoint").value);
 
-  // 获取并组合订阅链接
   let subLines = document
     .getElementById("sub")
     .value.split("\n")
     .filter((line) => line.trim() !== "");
-  let noSub = false;
-  // 去除 subLines 中空元素
-  subLines = subLines.map((item) => {
-    if (item !== "") {
-      return item;
-    }
-  });
   if (subLines.length > 0) {
-    queryParams.push(`sub=${encodeURIComponent(subLines.join(","))}`);
-  } else {
-    noSub = true;
+    config.subscriptions = subLines;
   }
 
-  // 获取并组合节点分享链接
   let proxyLines = document
     .getElementById("proxy")
     .value.split("\n")
     .filter((line) => line.trim() !== "");
-  let noProxy = false;
-  // 去除 proxyLines 中空元素
-  proxyLines = proxyLines.map((item) => {
-    if (item !== "") {
-      return item;
-    }
-  });
   if (proxyLines.length > 0) {
-    queryParams.push(`proxy=${encodeURIComponent(proxyLines.join(","))}`);
-  } else {
-    noProxy = true;
+    config.proxies = proxyLines;
   }
-  if (noSub && noProxy) {
-    // alert("订阅链接和节点分享链接不能同时为空！");
+
+  if (
+    (config.subscriptions === undefined || config.subscriptions.length === 0) &&
+    (config.proxies === undefined || config.proxies.length === 0)
+  ) {
     return "";
   }
 
-  // 获取订阅user-agent标识
-  const userAgent = document.getElementById("user-agent").value;
-  queryParams.push(`userAgent=${encodeURIComponent(userAgent)}`);
+  config.userAgent = document.getElementById("user-agent").value;
 
-  // 获取复选框的值
-  const refresh = document.getElementById("refresh").checked;
-  queryParams.push(`refresh=${refresh ? "true" : "false"}`);
-  const autoTest = document.getElementById("autoTest").checked;
-  queryParams.push(`autoTest=${autoTest ? "true" : "false"}`);
-  const lazy = document.getElementById("lazy").checked;
-  queryParams.push(`lazy=${lazy ? "true" : "false"}`);
-  const nodeList = document.getElementById("nodeList").checked;
-  queryParams.push(`nodeList=${nodeList ? "true" : "false"}`);
-  const igcg = document.getElementById("igcg").checked;
-  queryParams.push(`ignoreCountryGroup=${igcg ? "true" : "false"}`);
+  config.refresh = document.getElementById("refresh").checked;
+  config.autoTest = document.getElementById("autoTest").checked;
+  config.lazy = document.getElementById("lazy").checked;
+  config.nodeList = document.getElementById("nodeList").checked;
+  config.ignoreCountryGroup = document.getElementById("igcg").checked;
+  config.useUDP = document.getElementById("useUDP").checked;
 
-  // 获取模板链接或名称（如果存在）
   const template = document.getElementById("template").value;
   if (template.trim() !== "") {
-    queryParams.push(`template=${encodeURIComponent(template)}`);
+    config.template = template;
   }
 
-  // 获取Rule Provider和规则
-  const ruleProviders = document.getElementsByName("ruleProvider");
-  const rules = document.getElementsByName("rule");
-  let providers = [];
-  for (let i = 0; i < ruleProviders.length / 5; i++) {
-    let baseIndex = i * 5;
-    let behavior = ruleProviders[baseIndex].value;
-    let url = ruleProviders[baseIndex + 1].value;
-    let group = ruleProviders[baseIndex + 2].value;
-    let prepend = ruleProviders[baseIndex + 3].value;
-    let name = ruleProviders[baseIndex + 4].value;
-    // 是否存在空值
-    if (
-      behavior.trim() === "" ||
-      url.trim() === "" ||
-      group.trim() === "" ||
-      prepend.trim() === "" ||
-      name.trim() === ""
-    ) {
-      // alert("Rule Provider 中存在空值，请检查后重试！");
-      return "";
-    }
-    providers.push(`[${behavior},${url},${group},${prepend},${name}]`);
-  }
-  queryParams.push(`ruleProvider=${encodeURIComponent(providers.join(","))}`);
-
-  let ruleList = [];
-  for (let i = 0; i < rules.length / 2; i++) {
-    if (rules[i * 2].value.trim() !== "") {
-      let rule = rules[i * 2].value;
-      let prepend = rules[i * 2 + 1].value;
-      // 是否存在空值
-      if (rule.trim() === "" || prepend.trim() === "") {
-        // alert("Rule 中存在空值，请检查后重试！");
+  const ruleProvidersElements = document.getElementsByName("ruleProvider");
+  if (ruleProvidersElements.length > 0) {
+    const ruleProviders = [];
+    for (let i = 0; i < ruleProvidersElements.length / 5; i++) {
+      let baseIndex = i * 5;
+      let behavior = ruleProvidersElements[baseIndex].value;
+      let url = ruleProvidersElements[baseIndex + 1].value;
+      let group = ruleProvidersElements[baseIndex + 2].value;
+      let prepend = ruleProvidersElements[baseIndex + 3].value;
+      let name = ruleProvidersElements[baseIndex + 4].value;
+      if (
+        behavior.trim() === "" ||
+        url.trim() === "" ||
+        group.trim() === "" ||
+        prepend.trim() === "" ||
+        name.trim() === ""
+      ) {
         return "";
       }
-      ruleList.push(`[${rule},${prepend}]`);
+      ruleProviders.push({
+        behavior: behavior,
+        url: url,
+        group: group,
+        prepend: prepend.toLowerCase() === "true",
+        name: name,
+      });
+    }
+    if (ruleProviders.length > 0) {
+      config.ruleProviders = ruleProviders;
     }
   }
-  queryParams.push(`rule=${encodeURIComponent(ruleList.join(","))}`);
 
-  // 获取排序策略
-  const sort = document.getElementById("sort").value;
-  queryParams.push(`sort=${sort}`);
+  const rulesElements = document.getElementsByName("rule");
+  if (rulesElements.length > 0) {
+    const rules = [];
+    for (let i = 0; i < rulesElements.length / 2; i++) {
+      if (rulesElements[i * 2].value.trim() !== "") {
+        let rule = rulesElements[i * 2].value;
+        let prepend = rulesElements[i * 2 + 1].value;
+        if (rule.trim() === "" || prepend.trim() === "") {
+          return "";
+        }
+        rules.push({
+          rule: rule,
+          prepend: prepend.toLowerCase() === "true",
+        });
+      }
+    }
+    if (rules.length > 0) {
+      config.rules = rules;
+    }
+  }
+
+  config.sort = document.getElementById("sort").value;
 
-  // 获取删除节点的正则表达式
   const remove = document.getElementById("remove").value;
   if (remove.trim() !== "") {
-    queryParams.push(`remove=${encodeURIComponent(remove)}`);
+    config.remove = remove;
   }
 
-  // 获取替换节点名称的正则表达式
-  let replaceList = [];
-  const replaces = document.getElementsByName("replace");
-  for (let i = 0; i < replaces.length / 2; i++) {
-    let replaceStr = `<${replaces[i * 2].value}>`;
-    let replaceTo = `<${replaces[i * 2 + 1].value}>`;
-    if (replaceStr.trim() === "") {
-      // alert("重命名设置中存在空值，请检查后重试！");
-      return "";
+  const replacesElements = document.getElementsByName("replace");
+  if (replacesElements.length > 0) {
+    const replace = {};
+    for (let i = 0; i < replacesElements.length / 2; i++) {
+      let replaceStr = replacesElements[i * 2].value;
+      let replaceTo = replacesElements[i * 2 + 1].value;
+      if (replaceStr.trim() === "") {
+        return "";
+      }
+      replace[replaceStr] = replaceTo;
+    }
+    if (Object.keys(replace).length > 0) {
+      config.replace = replace;
     }
-    replaceList.push(`[${replaceStr},${replaceTo}]`);
   }
-  queryParams.push(`replace=${encodeURIComponent(replaceList.join(","))}`);
 
-  return `${endpoint}?${queryParams.join("&")}`;
+  const jsonString = JSON.stringify(config);
+  // 解决 btoa 中文报错，使用 TextEncoder 进行 UTF-8 编码再 base64
+  function base64EncodeUnicode(str) {
+    const bytes = new TextEncoder().encode(str);
+    let binary = '';
+    bytes.forEach((b) => binary += String.fromCharCode(b));
+    return btoa(binary);
+  }
+  const encoded = base64EncodeUnicode(jsonString);
+  const urlSafeBase64 = encoded
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=/g, "");
+
+  return `convert/${urlSafeBase64}`;
 }
 
 // 将输入框中的 URL 解析为参数
@@ -215,29 +213,29 @@ async function parseInputURL() {
     q.append("password", password);
     try {
       const response = await axios.get("./short?" + q.toString());
-      url = new URL(window.location.href + response.data);
-      
+      url = new URL(response.data, window.location.href);
+
       // 回显配置链接
       const apiLinkInput = document.querySelector("#apiLink");
-      apiLinkInput.value = `${window.location.origin}${window.location.pathname}${response.data}`;
+      apiLinkInput.value = url.href;
       setInputReadOnly(apiLinkInput, true);
-      
+
       // 回显短链相关信息
       const apiShortLinkInput = document.querySelector("#apiShortLink");
       apiShortLinkInput.value = inputURL;
       setInputReadOnly(apiShortLinkInput, true);
-      
+
       // 设置短链ID和密码，并设置为只读
       const customIdInput = document.querySelector("#customId");
       const passwordInput = document.querySelector("#password");
       const generateButton = document.querySelector('button[onclick="generateShortLink()"]');
-      
+
       customIdInput.value = hash;
       setInputReadOnly(customIdInput, true);
-      
+
       passwordInput.value = password;
       setInputReadOnly(passwordInput, true);
-      
+
       // 禁用生成短链按钮
       generateButton.disabled = true;
       generateButton.classList.add('btn-secondary');
@@ -247,94 +245,106 @@ async function parseInputURL() {
       alert("获取短链失败，请检查密码！");
     }
   }
-  let params = new URLSearchParams(url.search);
-
-  // 分配值到对应的输入框
   const pathSections = url.pathname.split("/");
-  const lastSection = pathSections[pathSections.length - 1];
-  const clientTypeSelect = document.getElementById("endpoint");
-  switch (lastSection.toLowerCase()) {
-    case "meta":
-      clientTypeSelect.value = "meta";
-      break;
-    case "clash":
-    default:
-      clientTypeSelect.value = "clash";
-      break;
+  const convertIndex = pathSections.findIndex((s) => s === "convert");
+
+  if (convertIndex === -1 || convertIndex + 1 >= pathSections.length) {
+    alert("无效的配置链接，请确认链接为新版格式。");
+    return;
+  }
+  const base64Config = pathSections[convertIndex + 1];
+  let config;
+  try {
+    const regularBase64 = base64Config.replace(/-/g, "+").replace(/_/g, "/");
+    const decodedStr = atob(regularBase64);
+    config = JSON.parse(decodeURIComponent(escape(decodedStr)));
+  } catch (e) {
+    alert("解析配置失败！");
+    console.error(e);
+    return;
   }
 
-  if (params.has("sub")) {
-    document.getElementById("sub").value = decodeURIComponent(params.get("sub"))
-      .split(",")
-      .join("\n");
+  document.getElementById("endpoint").value = config.clashType || "1";
+
+  if (config.subscriptions) {
+    document.getElementById("sub").value = config.subscriptions.join("\n");
   }
 
-  if (params.has("proxy")) {
-    document.getElementById("proxy").value = decodeURIComponent(
-      params.get("proxy")
-    )
-      .split(",")
-      .join("\n");
+  if (config.proxies) {
+    document.getElementById("proxy").value = config.proxies.join("\n");
   }
 
-  if (params.has("refresh")) {
-    document.getElementById("refresh").checked =
-      params.get("refresh") === "true";
+  if (config.refresh) {
+    document.getElementById("refresh").checked = config.refresh;
   }
 
-  if (params.has("autoTest")) {
-    document.getElementById("autoTest").checked =
-      params.get("autoTest") === "true";
+  if (config.autoTest) {
+    document.getElementById("autoTest").checked = config.autoTest;
   }
 
-  if (params.has("lazy")) {
-    document.getElementById("lazy").checked = params.get("lazy") === "true";
+  if (config.lazy) {
+    document.getElementById("lazy").checked = config.lazy;
   }
 
-  if (params.has("template")) {
-    document.getElementById("template").value = decodeURIComponent(
-      params.get("template")
-    );
+  if (config.template) {
+    document.getElementById("template").value = config.template;
   }
 
-  if (params.has("sort")) {
-    document.getElementById("sort").value = params.get("sort");
+  if (config.sort) {
+    document.getElementById("sort").value = config.sort;
   }
 
-  if (params.has("remove")) {
-    document.getElementById("remove").value = decodeURIComponent(
-      params.get("remove")
-    );
+  if (config.remove) {
+    document.getElementById("remove").value = config.remove;
   }
 
-  if (params.has("userAgent")) {
-    document.getElementById("user-agent").value = decodeURIComponent(
-      params.get("userAgent")
-    );
+  if (config.userAgent) {
+    document.getElementById("user-agent").value = config.userAgent;
   }
 
-  if (params.has("ignoreCountryGroup")) {
-    document.getElementById("igcg").checked = 
-      params.get("ignoreCountryGroup") === "true";
+  if (config.ignoreCountryGroup) {
+    document.getElementById("igcg").checked = config.ignoreCountryGroup;
   }
 
-  if (params.has("replace")) {
-    parseAndFillReplaceParams(decodeURIComponent(params.get("replace")));
+  if (config.replace) {
+    const replaceGroup = document.getElementById("replaceGroup");
+    for (const original in config.replace) {
+      const div = createReplace();
+      div.children[0].value = original;
+      div.children[1].value = config.replace[original];
+      replaceGroup.appendChild(div);
+    }
   }
 
-  if (params.has("ruleProvider")) {
-    parseAndFillRuleProviderParams(
-      decodeURIComponent(params.get("ruleProvider"))
-    );
+  if (config.ruleProviders) {
+    const ruleProviderGroup = document.getElementById("ruleProviderGroup");
+    for (const p of config.ruleProviders) {
+      const div = createRuleProvider();
+      div.children[0].value = p.behavior;
+      div.children[1].value = p.url;
+      div.children[2].value = p.group;
+      div.children[3].value = p.prepend;
+      div.children[4].value = p.name;
+      ruleProviderGroup.appendChild(div);
+    }
   }
 
-  if (params.has("rule")) {
-    parseAndFillRuleParams(decodeURIComponent(params.get("rule")));
+  if (config.rules) {
+    const ruleGroup = document.getElementById("ruleGroup");
+    for (const r of config.rules) {
+      const div = createRule();
+      div.children[0].value = r.rule;
+      div.children[1].value = r.prepend;
+      ruleGroup.appendChild(div);
+    }
   }
 
-  if (params.has("nodeList")) {
-    document.getElementById("nodeList").checked =
-      params.get("nodeList") === "true";
+  if (config.nodeList) {
+    document.getElementById("nodeList").checked = config.nodeList;
+  }
+
+  if (config.useUDP) {
+    document.getElementById("useUDP").checked = config.useUDP;
   }
 }
 
@@ -346,51 +356,6 @@ function clearInputGroup(groupId) {
   }
 }
 
-function parseAndFillReplaceParams(replaceParams) {
-  const replaceGroup = document.getElementById("replaceGroup");
-  let matches;
-  const regex = /\[(<.*?>),(<.*?>)\]/g;
-  const str = decodeURIComponent(replaceParams);
-  while ((matches = regex.exec(str)) !== null) {
-    const div = createReplace();
-    const original = matches[1].slice(1, -1); // Remove < and >
-    const replacement = matches[2].slice(1, -1); // Remove < and >
-
-    div.children[0].value = original;
-    div.children[1].value = replacement;
-    replaceGroup.appendChild(div);
-  }
-}
-
-function parseAndFillRuleProviderParams(ruleProviderParams) {
-  const ruleProviderGroup = document.getElementById("ruleProviderGroup");
-  let matches;
-  const regex = /\[(.*?),(.*?),(.*?),(.*?),(.*?)\]/g;
-  const str = decodeURIComponent(ruleProviderParams);
-  while ((matches = regex.exec(str)) !== null) {
-    const div = createRuleProvider();
-    div.children[0].value = matches[1];
-    div.children[1].value = matches[2];
-    div.children[2].value = matches[3];
-    div.children[3].value = matches[4];
-    div.children[4].value = matches[5];
-    ruleProviderGroup.appendChild(div);
-  }
-}
-
-function parseAndFillRuleParams(ruleParams) {
-  const ruleGroup = document.getElementById("ruleGroup");
-  let matches;
-  const regex = /\[(.*?),(.*?)\]/g;
-  const str = decodeURIComponent(ruleParams);
-  while ((matches = regex.exec(str)) !== null) {
-    const div = createRule();
-    div.children[0].value = matches[1];
-    div.children[1].value = matches[2];
-    ruleGroup.appendChild(div);
-  }
-}
-
 async function copyToClipboard(elem, e) {
   const apiLinkInput = document.querySelector(`#${elem}`).value;
   try {
@@ -580,4 +545,53 @@ function updateShortLink() {
     });
 }
 
+
+// 主题切换功能
+function initTheme() {
+  const html = document.querySelector('html');
+  const themeIcon = document.getElementById('theme-icon');
+  let theme;
+
+  // 从localStorage获取用户偏好的主题
+  const savedTheme = localStorage.getItem('theme');
+
+  if (savedTheme) {
+    // 如果用户之前设置过主题，使用保存的主题
+    theme = savedTheme;
+  } else {
+    // 如果没有设置过，检测系统主题偏好
+    const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+    theme = prefersDark ? 'dark' : 'light';
+  }
+
+  // 设置主题
+  html.setAttribute('data-bs-theme', theme);
+
+  // 更新图标
+  if (theme === 'dark') {
+    themeIcon.textContent = '☀️';
+  } else {
+    themeIcon.textContent = '🌙';
+  }
+}
+
+function toggleTheme() {
+  const html = document.querySelector('html');
+  const currentTheme = html.getAttribute('data-bs-theme');
+  // 切换主题
+  const newTheme = currentTheme === 'dark' ? 'light' : 'dark';
+  html.setAttribute('data-bs-theme', newTheme);
+
+  // 更新图标
+  if (newTheme === 'dark') {
+    themeIcon.textContent = '☀️';
+  } else {
+    themeIcon.textContent = '🌙';
+  }
+
+  // 保存用户偏好到localStorage
+  localStorage.setItem('theme', newTheme);
+}
+
 listenInput();
+initTheme();

test/parser/anytls_test.go

@@ -22,7 +22,7 @@ func TestAnytls_Basic_SimpleLink(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -47,7 +47,7 @@ func TestAnytls_Basic_WithSNI(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -72,7 +72,7 @@ func TestAnytls_Basic_WithInsecure(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -96,7 +96,7 @@ func TestAnytls_Basic_IPv6Address(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -121,7 +121,7 @@ func TestAnytls_Basic_ComplexPassword(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -145,7 +145,7 @@ func TestAnytls_Basic_NoPassword(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -169,7 +169,7 @@ func TestAnytls_Basic_UsernameOnly(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -182,7 +182,7 @@ func TestAnytls_Error_MissingServer(t *testing.T) {
 	p := &parser.AnytlsParser{}
 	input := "anytls://password123@:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -192,7 +192,7 @@ func TestAnytls_Error_MissingPort(t *testing.T) {
 	p := &parser.AnytlsParser{}
 	input := "anytls://password123@127.0.0.1"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -202,7 +202,7 @@ func TestAnytls_Error_InvalidPort(t *testing.T) {
 	p := &parser.AnytlsParser{}
 	input := "anytls://password123@127.0.0.1:99999"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -212,7 +212,7 @@ func TestAnytls_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.AnytlsParser{}
 	input := "anyssl://example.com:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}

test/parser/hysteria2_test.go

@@ -22,7 +22,7 @@ func TestHysteria2_Basic_SimpleLink(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -47,7 +47,7 @@ func TestHysteria2_Basic_AltPrefix(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -73,7 +73,7 @@ func TestHysteria2_Basic_WithObfs(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -97,7 +97,7 @@ func TestHysteria2_Basic_IPv6Address(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -124,7 +124,7 @@ func TestHysteria2_Basic_FullConfig(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -148,7 +148,7 @@ func TestHysteria2_Basic_NoPassword(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -161,7 +161,7 @@ func TestHysteria2_Error_MissingServer(t *testing.T) {
 	p := &parser.Hysteria2Parser{}
 	input := "hysteria2://password123@:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -171,7 +171,7 @@ func TestHysteria2_Error_MissingPort(t *testing.T) {
 	p := &parser.Hysteria2Parser{}
 	input := "hysteria2://password123@127.0.0.1"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -181,7 +181,7 @@ func TestHysteria2_Error_InvalidPort(t *testing.T) {
 	p := &parser.Hysteria2Parser{}
 	input := "hysteria2://password123@127.0.0.1:99999"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -191,7 +191,7 @@ func TestHysteria2_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.Hysteria2Parser{}
 	input := "hysteria://example.com:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}

test/parser/hysteria_test.go

@@ -25,7 +25,7 @@ func TestHysteria_Basic_SimpleLink(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -52,7 +52,7 @@ func TestHysteria_Basic_WithAuthString(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -80,7 +80,7 @@ func TestHysteria_Basic_WithObfs(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -106,7 +106,7 @@ func TestHysteria_Basic_IPv6Address(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -133,7 +133,7 @@ func TestHysteria_Basic_MultiALPN(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -146,7 +146,7 @@ func TestHysteria_Error_MissingServer(t *testing.T) {
 	p := &parser.HysteriaParser{}
 	input := "hysteria://:8080?auth=password123"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -156,7 +156,7 @@ func TestHysteria_Error_MissingPort(t *testing.T) {
 	p := &parser.HysteriaParser{}
 	input := "hysteria://127.0.0.1?auth=password123"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -166,7 +166,7 @@ func TestHysteria_Error_InvalidPort(t *testing.T) {
 	p := &parser.HysteriaParser{}
 	input := "hysteria://127.0.0.1:99999?auth=password123"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -176,7 +176,7 @@ func TestHysteria_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.HysteriaParser{}
 	input := "hysteria2://example.com:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}

test/parser/shadowsocks_test.go

@@ -23,7 +23,7 @@ func TestShadowsocks_Basic_SimpleLink(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -47,7 +47,7 @@ func TestShadowsocks_Basic_IPv6Address(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -71,7 +71,7 @@ func TestShadowsocks_Basic_WithRemark(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -95,7 +95,7 @@ func TestShadowsocks_Advanced_Base64FullEncoded(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -119,7 +119,7 @@ func TestShadowsocks_Advanced_PlainUserPassword(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -143,7 +143,7 @@ func TestShadowsocks_Advanced_ChaCha20Cipher(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -157,7 +157,7 @@ func TestShadowsocks_Error_MissingServer(t *testing.T) {
 	p := &parser.ShadowsocksParser{}
 	input := "ss://YWVzLTI1Ni1nY206cGFzc3dvcmQ=@:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if !errors.Is(err, parser.ErrInvalidStruct) {
 		t.Errorf("Error is not expected: %v", err)
 	}
@@ -167,7 +167,7 @@ func TestShadowsocks_Error_MissingPort(t *testing.T) {
 	p := &parser.ShadowsocksParser{}
 	input := "ss://YWVzLTI1Ni1nY206cGFzc3dvcmQ=@127.0.0.1"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if !errors.Is(err, parser.ErrInvalidStruct) {
 		t.Errorf("Error is not expected: %v", err)
 	}
@@ -177,7 +177,7 @@ func TestShadowsocks_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.ShadowsocksParser{}
 	input := "http://example.com:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if !errors.Is(err, parser.ErrInvalidPrefix) {
 		t.Errorf("Error is not expected: %v", err)
 	}

test/parser/shadowsocksr_test.go

@@ -26,7 +26,7 @@ func TestShadowsocksR_Basic_SimpleLink(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -54,7 +54,7 @@ func TestShadowsocksR_Basic_WithParams(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -82,7 +82,7 @@ func TestShadowsocksR_Basic_IPv6Address(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -95,7 +95,7 @@ func TestShadowsocksR_Error_InvalidBase64(t *testing.T) {
 	p := &parser.ShadowsocksRParser{}
 	input := "ssr://invalid_base64"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -105,7 +105,7 @@ func TestShadowsocksR_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.ShadowsocksRParser{}
 	input := "ss://example.com:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}

test/parser/socks_test.go

@@ -22,7 +22,7 @@ func TestSocks_Basic_SimpleLink(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -44,7 +44,7 @@ func TestSocks_Basic_NoAuth(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -68,7 +68,7 @@ func TestSocks_Basic_IPv6Address(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -93,7 +93,7 @@ func TestSocks_Basic_WithTLS(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -118,7 +118,7 @@ func TestSocks_Basic_WithUDP(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -131,7 +131,7 @@ func TestSocks_Error_MissingServer(t *testing.T) {
 	p := &parser.SocksParser{}
 	input := "socks://user:pass@:1080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -141,7 +141,7 @@ func TestSocks_Error_MissingPort(t *testing.T) {
 	p := &parser.SocksParser{}
 	input := "socks://user:pass@127.0.0.1"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -151,7 +151,7 @@ func TestSocks_Error_InvalidPort(t *testing.T) {
 	p := &parser.SocksParser{}
 	input := "socks://user:pass@127.0.0.1:99999"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -161,7 +161,7 @@ func TestSocks_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.SocksParser{}
 	input := "ss://example.com:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}

test/parser/trojan_test.go

@@ -21,7 +21,7 @@ func TestTrojan_Basic_SimpleLink(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -46,7 +46,7 @@ func TestTrojan_Basic_WithTLS(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -75,7 +75,7 @@ func TestTrojan_Basic_WithReality(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -105,7 +105,7 @@ func TestTrojan_Basic_WithWebSocket(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -132,7 +132,7 @@ func TestTrojan_Basic_WithGrpc(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -145,7 +145,7 @@ func TestTrojan_Error_MissingServer(t *testing.T) {
 	p := &parser.TrojanParser{}
 	input := "trojan://password@:443"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -155,7 +155,7 @@ func TestTrojan_Error_MissingPort(t *testing.T) {
 	p := &parser.TrojanParser{}
 	input := "trojan://password@127.0.0.1"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -165,7 +165,7 @@ func TestTrojan_Error_InvalidPort(t *testing.T) {
 	p := &parser.TrojanParser{}
 	input := "trojan://password@127.0.0.1:99999"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -175,7 +175,7 @@ func TestTrojan_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.TrojanParser{}
 	input := "ss://example.com:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}

test/parser/vless_test.go

@@ -21,7 +21,7 @@ func TestVless_Basic_SimpleLink(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -47,7 +47,7 @@ func TestVless_Basic_WithTLS(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -77,7 +77,7 @@ func TestVless_Basic_WithReality(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -107,7 +107,7 @@ func TestVless_Basic_WithWebSocket(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -134,7 +134,7 @@ func TestVless_Basic_WithGrpc(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -164,7 +164,7 @@ func TestVless_Basic_WithHTTP(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -177,7 +177,7 @@ func TestVless_Error_MissingServer(t *testing.T) {
 	p := &parser.VlessParser{}
 	input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -187,7 +187,7 @@ func TestVless_Error_MissingPort(t *testing.T) {
 	p := &parser.VlessParser{}
 	input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@127.0.0.1"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -197,7 +197,7 @@ func TestVless_Error_InvalidPort(t *testing.T) {
 	p := &parser.VlessParser{}
 	input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@127.0.0.1:99999"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -207,7 +207,7 @@ func TestVless_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.VlessParser{}
 	input := "ss://example.com:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}

test/parser/vmess_test.go

@@ -31,7 +31,7 @@ func TestVmess_Basic_SimpleLink(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -64,7 +64,7 @@ func TestVmess_Basic_WithPath(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -97,7 +97,7 @@ func TestVmess_Basic_WithHost(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -131,7 +131,7 @@ func TestVmess_Basic_WithSNI(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -164,7 +164,7 @@ func TestVmess_Basic_WithAlterID(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -192,7 +192,7 @@ func TestVmess_Basic_GRPC(t *testing.T) {
 		},
 	}
 
-	result, err := p.Parse(input)
+	result, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err != nil {
 		t.Errorf("Unexpected error: %v", err)
 		return
@@ -205,7 +205,7 @@ func TestVmess_Error_InvalidBase64(t *testing.T) {
 	p := &parser.VmessParser{}
 	input := "vmess://invalid_base64"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -215,7 +215,7 @@ func TestVmess_Error_InvalidJSON(t *testing.T) {
 	p := &parser.VmessParser{}
 	input := "vmess://eyJpbnZhbGlkIjoianNvbn0="
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}
@@ -225,7 +225,7 @@ func TestVmess_Error_InvalidProtocol(t *testing.T) {
 	p := &parser.VmessParser{}
 	input := "ss://example.com:8080"
 
-	_, err := p.Parse(input)
+	_, err := p.Parse(parser.ParseConfig{UseUDP: false}, input)
 	if err == nil {
 		t.Errorf("Expected error but got none")
 	}

test/yaml_test.go

@@ -0,0 +1,33 @@
+package test
+
+import (
+	"testing"
+
+	"github.com/bestnite/sub2clash/model/proxy"
+	"gopkg.in/yaml.v3"
+)
+
+type testStruct struct {
+	A proxy.IntOrString `yaml:"a"`
+}
+
+func TestUnmarshal(t *testing.T) {
+	yamlData1 := `a: 123`
+	res := testStruct{}
+	err := yaml.Unmarshal([]byte(yamlData1), &res)
+	if err != nil {
+		t.Errorf("failed to unmarshal yaml: %v", err)
+	}
+	if res.A != 123 {
+		t.Errorf("expected 123, but got %v", res.A)
+	}
+
+	yamlData2 := `a: "123"`
+	err = yaml.Unmarshal([]byte(yamlData2), &res)
+	if err != nil {
+		t.Errorf("failed to unmarshal yaml: %v", err)
+	}
+	if res.A != 123 {
+		t.Errorf("expected 123, but got %v", res.A)
+	}
+}

utils/base64.go

@@ -0,0 +1,31 @@
+package utils
+
+import (
+	"encoding/base64"
+	"strings"
+)
+
+func DecodeBase64(s string, urlSafe bool) (string, error) {
+	s = strings.TrimSpace(s)
+	if len(s)%4 != 0 {
+		s += strings.Repeat("=", 4-len(s)%4)
+	}
+	var decodeStr []byte
+	var err error
+	if urlSafe {
+		decodeStr, err = base64.URLEncoding.DecodeString(s)
+	} else {
+		decodeStr, err = base64.StdEncoding.DecodeString(s)
+	}
+	if err != nil {
+		return "", err
+	}
+	return string(decodeStr), nil
+}
+
+func EncodeBase64(s string, urlSafe bool) string {
+	if urlSafe {
+		return base64.URLEncoding.EncodeToString([]byte(s))
+	}
+	return base64.StdEncoding.EncodeToString([]byte(s))
+}