Fix the conversion of TLS-related issues when Singbox is used as the source. Fix the issue of missing SNI in Trojan.(#4)

This reverts commit 686f6b3517.

.github/workflows/build.yml

@@ -1,7 +1,6 @@
 name: GitHub CI
 on: 
   push:
-    branches: [ master ]
     tags:
       - '**'
   workflow_dispatch:
@@ -64,12 +63,14 @@ jobs:
 
   armv7_build:
     name: Linux armv7 Build
-    runs-on: [self-hosted, linux, ARM]
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
     - name: Add commit id into version
       if: ${{ !startsWith(github.ref, 'refs/tags/') }}
       run: SHA=$(git rev-parse --short HEAD) && sed -i 's/\(v[0-9]\.[0-9]\.[0-9]\)/\1-'"$SHA"'/' src/version.h
+    - name: Set up QEMU
+      uses: docker/setup-qemu-action@v2
     - name: Build
       run: docker run --rm -v $GITHUB_WORKSPACE:/root/workdir multiarch/alpine:armv7-latest-stable /bin/sh -c "apk add bash git nodejs npm && cd /root/workdir && chmod +x scripts/build.alpine.release.sh && bash scripts/build.alpine.release.sh"
     - name: Upload
@@ -89,12 +90,14 @@ jobs:
 
   aarch64_build:
     name: Linux aarch64 Build
-    runs-on: [self-hosted, linux, ARM64]
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
     - name: Add commit id into version
       if: ${{ !startsWith(github.ref, 'refs/tags/') }}
       run: SHA=$(git rev-parse --short HEAD) && sed -i 's/\(v[0-9]\.[0-9]\.[0-9]\)/\1-'"$SHA"'/' src/version.h
+    - name: Set up QEMU
+      uses: docker/setup-qemu-action@v2
     - name: Build
       run: docker run --rm -v $GITHUB_WORKSPACE:/root/workdir multiarch/alpine:aarch64-latest-stable /bin/sh -c "apk add bash git nodejs npm && cd /root/workdir && chmod +x scripts/build.alpine.release.sh && bash scripts/build.alpine.release.sh"
     - name: Upload

.github/workflows/docker.yml

@@ -106,7 +106,7 @@ jobs:
         with:
           platforms: linux/386
           context: scripts/
-          tags: asdlokj1qpi23/subconverter:latest-x86
+          tags: asdlokj1qpi23/subconverter:latest
           build-args: |
             SHA=${{ steps.vars.outputs.sha_short }}
           outputs: type=image,push=true
@@ -127,7 +127,7 @@ jobs:
         with:
           platforms: linux/386
           context: scripts/
-          tags: asdlokj1qpi23/subconverter:${{steps.version.outputs.result}}-x86
+          tags: asdlokj1qpi23/subconverter:${{steps.version.outputs.result}}
           outputs: type=image,push=true
 
       - name: Save digest
@@ -146,13 +146,14 @@ jobs:
 
   armv7_build:
     name: Build ARMv7 Image
-    runs-on: [self-hosted, linux, ARM]
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout base
         uses: actions/checkout@v3
         with:
           fetch-depth: 0
-
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2
 
@@ -173,7 +174,7 @@ jobs:
         with:
           platforms: linux/arm/v7
           context: scripts/
-          tags: asdlokj1qpi23/subconverter:latest-armv7
+          tags: asdlokj1qpi23/subconverter:latest
           build-args: |
             SHA=${{ steps.vars.outputs.sha_short }}
             THREADS=4
@@ -195,7 +196,7 @@ jobs:
         with:
           platforms: linux/arm/v7
           context: scripts/
-          tags: asdlokj1qpi23/subconverter:${{steps.version.outputs.result}}-armv7
+          tags: asdlokj1qpi23/subconverter:${{steps.version.outputs.result}}
           build-args: |
             THREADS=4
           outputs: type=image,push=true
@@ -216,13 +217,14 @@ jobs:
 
   arm64_build:
     name: Build ARM64 Image
-    runs-on: [self-hosted, linux, ARM64]
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout base
         uses: actions/checkout@v3
         with:
           fetch-depth: 0
-
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2
 
@@ -243,7 +245,7 @@ jobs:
         with:
           platforms: linux/arm64
           context: scripts/
-          tags: asdlokj1qpi23/subconverter:latest-arm64
+          tags: asdlokj1qpi23/subconverter:latest
           build-args: |
             SHA=${{ steps.vars.outputs.sha_short }}
             THREADS=4
@@ -265,7 +267,7 @@ jobs:
         with:
           platforms: linux/arm64
           context: scripts/
-          tags: asdlokj1qpi23/subconverter:${{steps.version.outputs.result}}-arm64
+          tags: asdlokj1qpi23/subconverter:${{steps.version.outputs.result}}
           build-args: |
             THREADS=4
           outputs: type=image,push=true
@@ -287,6 +289,7 @@ jobs:
   build:
     name: Build
     needs: [amd64_build, x86_build, armv7_build, arm64_build]
+#    needs: [amd64_build, x86_build]
     runs-on: ubuntu-latest
     steps:
       - name: Checkout base

README-docker.md

@@ -1,11 +1,9 @@
 # subconverter-docker
 
-This is a minimized image to run https://github.com/tindy2013/subconverter.
-
 For running this docker, simply use the following commands:
 ```bash
 # run the container detached, forward internal port 25500 to host port 25500
-docker run -d --restart=always -p 25500:25500 tindy2013/subconverter:latest
+docker run -d --restart=always -p 25500:25500 asdlokj1qpi23/subconverter:latest
 # then check its status
 curl http://localhost:25500/version
 # if you see `subconverter vx.x.x backend` then the container is up and running
@@ -16,7 +14,7 @@ Or run in docker-compose:
 version: '3'
 services:
   subconverter:
-    image: tindy2013/subconverter:latest
+    image: asdlokj1qpi23/subconverter:latest
     container_name: subconverter
     ports:
       - "15051:25500"

README.md

@@ -2,23 +2,46 @@
 
 Utility to convert between various proxy subscription formats.
 
-[![Build Status](https://github.com/tindy2013/subconverter/actions/workflows/build.yml/badge.svg)](https://github.com/tindy2013/subconverter/actions)
-[![GitHub tag (latest SemVer)](https://img.shields.io/github/tag/tindy2013/subconverter.svg)](https://github.com/tindy2013/subconverter/tags)
-[![GitHub release](https://img.shields.io/github/release/tindy2013/subconverter.svg)](https://github.com/tindy2013/subconverter/releases)
-[![GitHub license](https://img.shields.io/github/license/tindy2013/subconverter.svg)](https://github.com/tindy2013/subconverter/blob/master/LICENSE)
+[![Build Status](https://github.com/asdlokj1qpi23/subconverter/actions/workflows/docker.yml/badge.svg)](https://github.com/asdlokj1qpi23/subconverter/actions)
+[![GitHub tag (latest SemVer)](https://img.shields.io/github/tag/asdlokj1qpi23/subconverter.svg)](https://github.com/asdlokj1qpi23/subconverter/tags)
+[![GitHub release](https://img.shields.io/github/release/asdlokj1qpi23/subconverter.svg)](https://github.com/asdlokj1qpi23/subconverter/releases)
+[![GitHub license](https://img.shields.io/github/license/asdlokj1qpi23/subconverter.svg)](https://github.com/tindy2013/subconverter/blob/master/LICENSE)
 
-[Docker README](https://github.com/tindy2013/subconverter/blob/master/README-docker.md)
+[Docker README](https://github.com/asdlokj1qpi23/subconverter/blob/master/README-docker.md)
 
-[中文文档](https://github.com/tindy2013/subconverter/blob/master/README-cn.md)
+[中文文档](https://github.com/asdlokj1qpi23/subconverter/blob/master/README-cn.md)
 
 - [subconverter](#subconverter)
+  - [Docker](#docker)
   - [Supported Types](#supported-types)
   - [Quick Usage](#quick-usage)
     - [Access Interface](#access-interface)
     - [Description](#description)
   - [Advanced Usage](#advanced-usage)
   - [Auto Upload](#auto-upload)
+  
+## Docker
 
+For running this docker, simply use the following commands:
+```bash
+# run the container detached, forward internal port 25500 to host port 25500
+docker run -d --restart=always -p 25500:25500 asdlokj1qpi23/subconverter:latest
+# then check its status
+curl http://localhost:25500/version
+# if you see `subconverter vx.x.x backend` then the container is up and running
+```
+Or run in docker-compose:
+```yaml
+---
+version: '3'
+services:
+  subconverter:
+    image: asdlokj1qpi23/subconverter:latest
+    container_name: subconverter
+    ports:
+      - "15051:25500"
+    restart: always
+```
 ## Supported Types
 
 | Type                              | As Source | As Target    | Target Name    |
@@ -38,7 +61,8 @@ Utility to convert between various proxy subscription formats.
 | Surge 4                           |     ✓     |      ✓       | surge&ver=4    |
 | V2Ray                             |     ✓     |      ✓       | v2ray          |
 | Telegram-liked HTTP/Socks 5 links |     ✓     |      ×       | Only as source |
-| Singbox                           |     ×      |      ✓       | singbox        |
+| Singbox                           |     ✓      |      ✓       | singbox        |
+
 Notice:
 
 1. Shadowrocket users should use `ss`, `ssr` or `v2ray` as target.
@@ -95,7 +119,7 @@ Finally subscribe this link in Clash and you are done!
 
 ## Advanced Usage
 
-Please refer to [中文文档](https://github.com/tindy2013/subconverter/blob/master/README-cn.md#%E8%BF%9B%E9%98%B6%E7%94%A8%E6%B3%95).
+Please refer to [中文文档](https://github.com/asdlokj1qpi23/subconverter/blob/master/README-cn.md#%E8%BF%9B%E9%98%B6%E7%94%A8%E6%B3%95).
 
 ## Auto Upload
 
@@ -110,3 +134,6 @@ Example:
 ;uncomment the following line and enter your token to enable upload function
 token = xxxxxxxxxxxxxxxxxxxxxxxx(Your Personal Access Token)
 ```
+## Thanks
+[tindy2013](https://github.com/tindy2013)
+[https://github.com/tindy2013/subconverter](https://github.com/tindy2013/subconverter)

src/generator/config/subexport.cpp

@@ -382,10 +382,14 @@ proxyToClash(std::vector<Proxy> &nodes, YAML::Node &yamlnode, const ProxyGroupCo
             case ProxyType::Trojan:
                 singleproxy["type"] = "trojan";
                 singleproxy["password"] = x.Password;
-                if (!x.Host.empty())
+                if (!x.ServerName.empty())
+                    singleproxy["sni"] = x.ServerName;
+                else if (!x.Host.empty()) {
                     singleproxy["sni"] = x.Host;
-                if (std::all_of(x.Password.begin(), x.Password.end(), ::isdigit) && !x.Password.empty())
+                }
+                if (std::all_of(x.Password.begin(), x.Password.end(), ::isdigit) && !x.Password.empty()) {
                     singleproxy["password"].SetTag("str");
+                }
                 if (!scv.is_undef())
                     singleproxy["skip-cert-verify"] = scv.get();
                 switch (hash_(x.TransferProtocol)) {
@@ -436,14 +440,19 @@ proxyToClash(std::vector<Proxy> &nodes, YAML::Node &yamlnode, const ProxyGroupCo
             case ProxyType::Hysteria:
                 singleproxy["type"] = "hysteria";
                 singleproxy["auth_str"] = x.Auth;
+                singleproxy["auth-str"] = x.Auth;
                 singleproxy["up"] = x.UpMbps;
                 singleproxy["down"] = x.DownMbps;
-                if (!tfo.is_undef())
+                if (!x.Ports.empty()) {
+                    singleproxy["ports"] = x.Ports;
+                }
+                if (!tfo.is_undef()) {
                     singleproxy["fast-open"] = tfo.get();
+                }
                 if (!x.FakeType.empty())
                     singleproxy["protocol"] = x.FakeType;
-                if (!x.Host.empty())
-                    singleproxy["sni"] = x.Host;
+                if (!x.ServerName.empty())
+                    singleproxy["sni"] = x.ServerName;
                 if (!scv.is_undef())
                     singleproxy["skip-cert-verify"] = scv.get();
                 if (x.Insecure == "1")
@@ -457,12 +466,12 @@ proxyToClash(std::vector<Proxy> &nodes, YAML::Node &yamlnode, const ProxyGroupCo
                 singleproxy["type"] = "hysteria2";
                 singleproxy["password"] = x.Password;
                 singleproxy["auth"] = x.Password;
+                if (!x.ServerName.empty())
+                    singleproxy["sni"] = x.ServerName;
                 if (!x.UpMbps.empty())
                     singleproxy["up"] = x.UpMbps;
                 if (!x.DownMbps.empty())
                     singleproxy["down"] = x.DownMbps;
-                if (!x.Host.empty())
-                    singleproxy["sni"] = x.Host;
                 if (!scv.is_undef())
                     singleproxy["skip-cert-verify"] = scv.get();
                 if (!x.Alpn.empty())
@@ -480,14 +489,24 @@ proxyToClash(std::vector<Proxy> &nodes, YAML::Node &yamlnode, const ProxyGroupCo
                     singleproxy["tfo"] = tfo.get();
                 if (xudp && udp)
                     singleproxy["xudp"] = true;
-                if (!x.Host.empty())
-                    singleproxy["servername"] = x.Host;
                 if (!x.Flow.empty())
                     singleproxy["flow"] = x.Flow;
                 if (!scv.is_undef())
                     singleproxy["skip-cert-verify"] = scv.get();
+                if (!x.PublicKey.empty()) {
+                    singleproxy["reality-opts"]["public-key"] = x.PublicKey;
+                }
+                if (!x.ServerName.empty())
+                    singleproxy["servername"] = x.ServerName;
+                if (!x.ShortId.empty()) {
+                    singleproxy["reality-opts"]["short-id"] = x.ShortId;
+                }
+                if (!x.PublicKey.empty() || x.Flow == "xtls-rprx-vision") {
+                    singleproxy["client-fingerprint"] = "chrome";
+                }
                 switch (hash_(x.TransferProtocol)) {
                     case "tcp"_hash:
+                        singleproxy["network"] = x.TransferProtocol;
                         break;
                     case "ws"_hash:
                         singleproxy["network"] = x.TransferProtocol;
@@ -670,17 +689,18 @@ std::string proxyToClash(std::vector<Proxy> &nodes, const std::string &base_conf
     output_content.insert(0, yamlnode_str);
     //rulesetToClash(yamlnode, ruleset_content_array, ext.overwrite_original_rules, ext.clash_new_field_name);
     //std::string output_content = YAML::Dump(yamlnode);
-    replaceAll(output_content,"!<str> ","");
+    replaceAll(output_content, "!<str> ", "");
     return output_content;
 }
 
-void replaceAll(std::string& input, const std::string& search, const std::string& replace) {
+void replaceAll(std::string &input, const std::string &search, const std::string &replace) {
     size_t pos = 0;
     while ((pos = input.find(search, pos)) != std::string::npos) {
         input.replace(pos, search.length(), replace);
         pos += replace.length();
     }
 }
+
 // peer = (public-key = bmXOC+F1FxEMF9dyiK2H5/1SUtzH0JuVo51h2wPfgyo=, allowed-ips = "0.0.0.0/0, ::/0", endpoint = engage.cloudflareclient.com:2408, client-id = 139/184/125),(public-key = bmXOC+F1FxEMF9dyiK2H5/1SUtzH0JuVo51h2wPfgyo=, endpoint = engage.cloudflareclient.com:2408)
 std::string generatePeer(Proxy &node, bool client_id_as_reserved = false) {
     std::string result;
@@ -733,7 +753,7 @@ std::string proxyToSurge(std::vector<Proxy> &nodes, const std::string &base_conf
 
         processRemark(x.Remark, remarks_list);
 
-        std::string &hostname = x.Hostname, &username = x.Username, &password = x.Password, &method = x.EncryptMethod, &id = x.UserId, &transproto = x.TransferProtocol, &host = x.Host, &edge = x.Edge, &path = x.Path, &protocol = x.Protocol, &protoparam = x.ProtocolParam, &obfs = x.OBFS, &obfsparam = x.OBFSParam, &plugin = x.Plugin, &pluginopts = x.PluginOption;
+        std::string &hostname = x.Hostname, &sni = x.ServerName, &username = x.Username, &password = x.Password, &method = x.EncryptMethod, &id = x.UserId, &transproto = x.TransferProtocol, &host = x.Host, &edge = x.Edge, &path = x.Path, &protocol = x.Protocol, &protoparam = x.ProtocolParam, &obfs = x.OBFS, &obfsparam = x.OBFSParam, &plugin = x.Plugin, &pluginopts = x.PluginOption;
         std::string port = std::to_string(x.Port);
         bool &tlssecure = x.TLSSecure;
 
@@ -849,8 +869,11 @@ std::string proxyToSurge(std::vector<Proxy> &nodes, const std::string &base_conf
                 proxy = "trojan, " + hostname + ", " + port + ", password=" + password;
                 if (x.SnellVersion != 0)
                     proxy += ", version=" + std::to_string(x.SnellVersion);
-                if (!host.empty())
+                if (!sni.empty()) {
+                    proxy += ", sni=" + sni;
+                } else if (!host.empty()) {
                     proxy += ", sni=" + host;
+                }
                 if (!scv.is_undef())
                     proxy += ", skip-cert-verify=" + scv.get_str();
                 break;
@@ -979,7 +1002,7 @@ std::string proxyToSingle(std::vector<Proxy> &nodes, int types, extra_settings &
 
     for (Proxy &x: nodes) {
         std::string remark = x.Remark;
-        std::string &hostname = x.Hostname, &password = x.Password, &method = x.EncryptMethod, &plugin = x.Plugin, &pluginopts = x.PluginOption, &protocol = x.Protocol, &protoparam = x.ProtocolParam, &obfs = x.OBFS, &obfsparam = x.OBFSParam, &id = x.UserId, &transproto = x.TransferProtocol, &host = x.Host, &path = x.Path, &faketype = x.FakeType;
+        std::string &hostname = x.Hostname, &sni = x.ServerName, &password = x.Password, &method = x.EncryptMethod, &plugin = x.Plugin, &pluginopts = x.PluginOption, &protocol = x.Protocol, &protoparam = x.ProtocolParam, &obfs = x.OBFS, &obfsparam = x.OBFSParam, &id = x.UserId, &transproto = x.TransferProtocol, &host = x.Host, &path = x.Path, &faketype = x.FakeType;
         bool &tlssecure = x.TLSSecure;
         std::string port = std::to_string(x.Port);
         std::string aid = std::to_string(x.AlterId);
@@ -1029,8 +1052,11 @@ std::string proxyToSingle(std::vector<Proxy> &nodes, int types, extra_settings &
                     continue;
                 proxyStr = "trojan://" + password + "@" + hostname + ":" + port + "?allowInsecure=" +
                            (x.AllowInsecure.get() ? "1" : "0");
-                if (!host.empty())
+                if (!sni.empty()) {
+                    proxyStr += "&sni=" + sni;
+                } else if (!host.empty()) {
                     proxyStr += "&sni=" + host;
+                }
                 if (transproto == "ws") {
                     proxyStr += "&ws=1";
                     if (!path.empty())
@@ -2102,6 +2128,15 @@ static rapidjson::Value stringArrayToJsonArray(const std::string &array, const s
     return result;
 }
 
+bool isNumeric(const std::string &str) {
+    for (char c: str) {
+        if (!std::isdigit(static_cast<unsigned char>(c))) {
+            return false;
+        }
+    }
+    return true;
+}
+
 void
 proxyToSingBox(std::vector<Proxy> &nodes, rapidjson::Document &json, std::vector<RulesetContent> &ruleset_content_array,
                const ProxyGroupConfigs &extra_proxy_group, extra_settings &ext) {
@@ -2110,6 +2145,7 @@ proxyToSingBox(std::vector<Proxy> &nodes, rapidjson::Document &json, std::vector
     rapidjson::Value outbounds(rapidjson::kArrayType), route(rapidjson::kArrayType);
     std::vector<Proxy> nodelist;
     string_array remarks_list;
+    std::string search = " Mbps";
 
     if (!ext.nodelist) {
         auto direct = buildObject(allocator, "type", "direct", "tag", "DIRECT");
@@ -2142,21 +2178,24 @@ proxyToSingBox(std::vector<Proxy> &nodes, rapidjson::Document &json, std::vector
                 if (!x.Plugin.empty() && !x.PluginOption.empty()) {
                     if (x.Plugin == "simple-obfs")
                         x.Plugin = "obfs-local";
+                    if (x.Plugin != "obfs-local" && x.Plugin != "v2ray-plugin") {
+                        continue;
+                    }
                     proxy.AddMember("plugin", rapidjson::StringRef(x.Plugin.c_str()), allocator);
                     proxy.AddMember("plugin_opts", rapidjson::StringRef(x.PluginOption.c_str()), allocator);
                 }
                 break;
             }
-            case ProxyType::ShadowsocksR: {
-                addSingBoxCommonMembers(proxy, x, "shadowsocksr", allocator);
-                proxy.AddMember("method", rapidjson::StringRef(x.EncryptMethod.c_str()), allocator);
-                proxy.AddMember("password", rapidjson::StringRef(x.Password.c_str()), allocator);
-                proxy.AddMember("protocol", rapidjson::StringRef(x.Protocol.c_str()), allocator);
-                proxy.AddMember("protocol_param", rapidjson::StringRef(x.ProtocolParam.c_str()), allocator);
-                proxy.AddMember("obfs", rapidjson::StringRef(x.OBFS.c_str()), allocator);
-                proxy.AddMember("obfs_param", rapidjson::StringRef(x.OBFSParam.c_str()), allocator);
-                break;
-            }
+//            case ProxyType::ShadowsocksR: {
+//                addSingBoxCommonMembers(proxy, x, "shadowsocksr", allocator);
+//                proxy.AddMember("method", rapidjson::StringRef(x.EncryptMethod.c_str()), allocator);
+//                proxy.AddMember("password", rapidjson::StringRef(x.Password.c_str()), allocator);
+//                proxy.AddMember("protocol", rapidjson::StringRef(x.Protocol.c_str()), allocator);
+//                proxy.AddMember("protocol_param", rapidjson::StringRef(x.ProtocolParam.c_str()), allocator);
+//                proxy.AddMember("obfs", rapidjson::StringRef(x.OBFS.c_str()), allocator);
+//                proxy.AddMember("obfs_param", rapidjson::StringRef(x.OBFSParam.c_str()), allocator);
+//                break;
+//            }
             case ProxyType::VMess: {
                 addSingBoxCommonMembers(proxy, x, "vmess", allocator);
                 proxy.AddMember("uuid", rapidjson::StringRef(x.UserId.c_str()), allocator);
@@ -2168,49 +2207,50 @@ proxyToSingBox(std::vector<Proxy> &nodes, rapidjson::Document &json, std::vector
                     proxy.AddMember("transport", transport, allocator);
                 break;
             }
-                // TODO VLESS后续支持
             case ProxyType::VLESS: {
-                addSingBoxCommonMembers(proxy, x, "vmess", allocator);
+                addSingBoxCommonMembers(proxy, x, "vless", allocator);
                 proxy.AddMember("uuid", rapidjson::StringRef(x.UserId.c_str()), allocator);
                 if (xudp && udp)
                     proxy.AddMember("packet_encoding", rapidjson::StringRef("xudp"), allocator);
-                if (!x.Host.empty())
-                    proxy.AddMember("server", rapidjson::StringRef(x.Host.c_str()), allocator);
                 if (!x.Flow.empty())
                     proxy.AddMember("flow", rapidjson::StringRef(x.Flow.c_str()), allocator);
-                rapidjson::Value transport(rapidjson::kObjectType);
+                rapidjson::Value vlesstransport(rapidjson::kObjectType);
+                rapidjson::Value vlessheaders(rapidjson::kObjectType);
                 switch (hash_(x.TransferProtocol)) {
                     case "tcp"_hash:
-                        proxy.AddMember("network", rapidjson::StringRef("ws"), allocator);
                         break;
                     case "ws"_hash:
-                        transport.AddMember("type", rapidjson::StringRef("ws"), allocator);
-                        transport.AddMember("host", rapidjson::StringRef(x.Host.c_str()), allocator);
-                        transport.AddMember("path", rapidjson::StringRef(x.Path.c_str()), allocator);
-                        addHeaders(transport, x, allocator);
-                        proxy.AddMember("transport", transport, allocator);
+                        if (x.Path.empty())
+                            vlesstransport.AddMember("path", "/", allocator);
+                        else
+                            vlesstransport.AddMember("path", rapidjson::StringRef(x.Path.c_str()), allocator);
+                        if (!x.Host.empty())
+                            vlessheaders.AddMember("Host", rapidjson::StringRef(x.Host.c_str()), allocator);
+                        if (!x.Edge.empty())
+                            vlessheaders.AddMember("Edge", rapidjson::StringRef(x.Edge.c_str()), allocator);
+                        vlesstransport.AddMember("type", rapidjson::StringRef("ws"), allocator);
+                        addHeaders(vlesstransport, x, allocator);
+                        proxy.AddMember("transport", vlesstransport, allocator);
                         break;
                     case "http"_hash:
-                        transport.AddMember("type", rapidjson::StringRef("http"), allocator);
-                        transport.AddMember("host", rapidjson::StringRef(x.Host.c_str()), allocator);
-                        transport.AddMember("method", rapidjson::StringRef("GET"), allocator);
-                        transport.AddMember("path", rapidjson::StringRef(x.Path.c_str()), allocator);
-                        addHeaders(transport, x, allocator);
-                        proxy.AddMember("transport", transport, allocator);
+                        vlesstransport.AddMember("type", rapidjson::StringRef("http"), allocator);
+                        vlesstransport.AddMember("host", rapidjson::StringRef(x.Host.c_str()), allocator);
+                        vlesstransport.AddMember("method", rapidjson::StringRef("GET"), allocator);
+                        vlesstransport.AddMember("path", rapidjson::StringRef(x.Path.c_str()), allocator);
+                        addHeaders(vlesstransport, x, allocator);
+                        proxy.AddMember("transport", vlesstransport, allocator);
                         break;
                     case "h2"_hash:
-                        transport.AddMember("type", rapidjson::StringRef("httpupgrade"), allocator);
-                        transport.AddMember("host", rapidjson::StringRef(x.Host.c_str()), allocator);
-                        transport.AddMember("path", rapidjson::StringRef(x.Path.c_str()), allocator);
-                        proxy.AddMember("transport", transport, allocator);
+                        vlesstransport.AddMember("type", rapidjson::StringRef("httpupgrade"), allocator);
+                        vlesstransport.AddMember("host", rapidjson::StringRef(x.Host.c_str()), allocator);
+                        vlesstransport.AddMember("path", rapidjson::StringRef(x.Path.c_str()), allocator);
+                        proxy.AddMember("transport", vlesstransport, allocator);
                         break;
                     case "grpc"_hash:
-                        transport.AddMember("type", rapidjson::StringRef("grpc"), allocator);
-                        transport.AddMember("service_name", rapidjson::StringRef(x.GRPCServiceName.c_str()), allocator);
-                        if (!x.GRPCMode.empty()) {
-                            transport.AddMember("permit_without_stream", rapidjson::StringRef("true"), allocator);
-                        }
-                        proxy.AddMember("transport", transport, allocator);
+                        vlesstransport.AddMember("type", rapidjson::StringRef("grpc"), allocator);
+                        vlesstransport.AddMember("service_name", rapidjson::StringRef(x.GRPCServiceName.c_str()),
+                                                 allocator);
+                        proxy.AddMember("transport", vlesstransport, allocator);
                         break;
                     default:
                         continue;
@@ -2229,13 +2269,15 @@ proxyToSingBox(std::vector<Proxy> &nodes, rapidjson::Document &json, std::vector
             case ProxyType::WireGuard: {
                 proxy.AddMember("type", "wireguard", allocator);
                 proxy.AddMember("tag", rapidjson::StringRef(x.Remark.c_str()), allocator);
+                proxy.AddMember("inet4_bind_address", rapidjson::StringRef(x.SelfIP.c_str()), allocator);
                 rapidjson::Value addresses(rapidjson::kArrayType);
-                addresses.PushBack(rapidjson::StringRef(x.SelfIP.c_str()), allocator);
-                if (!x.SelfIPv6.empty())
-                    addresses.PushBack(rapidjson::StringRef(x.SelfIPv6.c_str()), allocator);
+                addresses.PushBack(rapidjson::StringRef(x.SelfIP.append("/32").c_str()), allocator);
+//                if (!x.SelfIPv6.empty())
+//                    addresses.PushBack(rapidjson::StringRef(x.SelfIPv6.c_str()), allocator);
                 proxy.AddMember("local_address", addresses, allocator);
+                if (!x.SelfIPv6.empty())
+                    proxy.AddMember("inet6_bind_address", rapidjson::StringRef(x.SelfIPv6.c_str()), allocator);
                 proxy.AddMember("private_key", rapidjson::StringRef(x.PrivateKey.c_str()), allocator);
-
                 rapidjson::Value peer(rapidjson::kObjectType);
                 peer.AddMember("server", rapidjson::StringRef(x.Hostname.c_str()), allocator);
                 peer.AddMember("server_port", x.Port, allocator);
@@ -2252,7 +2294,9 @@ proxyToSingBox(std::vector<Proxy> &nodes, rapidjson::Document &json, std::vector
                     auto reserved = stringArrayToJsonArray(x.ClientId, ",", allocator);
                     peer.AddMember("reserved", reserved, allocator);
                 }
-
+                if (!x.Password.empty()) {
+                    proxy.AddMember("pre_shared_key", rapidjson::StringRef(x.Password.c_str()), allocator);
+                }
                 rapidjson::Value peers(rapidjson::kArrayType);
                 peers.PushBack(peer, allocator);
                 proxy.AddMember("peers", peers, allocator);
@@ -2276,19 +2320,39 @@ proxyToSingBox(std::vector<Proxy> &nodes, rapidjson::Document &json, std::vector
             case ProxyType::Hysteria: {
                 addSingBoxCommonMembers(proxy, x, "hysteria", allocator);
                 proxy.AddMember("auth_str", rapidjson::StringRef(x.Auth.c_str()), allocator);
-                proxy.AddMember("up", rapidjson::StringRef(x.UpMbps.c_str()), allocator);
-                proxy.AddMember("down", rapidjson::StringRef(x.DownMbps.c_str()), allocator);
-                rapidjson::Value tls(rapidjson::kObjectType);
-                tls.AddMember("enabled", true, allocator);
-                proxy.AddMember("tls", tls, allocator);
-                if (!tfo.is_undef())
-                    proxy.AddMember("tcp_fast_open",
-                                    rapidjson::StringRef(std::string(tfo.get() ? "true" : "false").c_str()), allocator);
+                if (isNumeric(x.UpMbps)) {
+                    proxy.AddMember("up_mbps", std::stoi(x.UpMbps), allocator);
+                } else {
+                    size_t pos = x.UpMbps.find(search);
+                    if (pos != std::string::npos) {
+                        x.UpMbps.replace(pos, search.length(), "");
+                    }
+                    proxy.AddMember("up_mbps", std::stoi(x.UpMbps), allocator);
+                }
+                if (isNumeric(x.DownMbps)) {
+                    proxy.AddMember("down_mbps", std::stoi(x.DownMbps), allocator);
+                } else {
+                    size_t pos = x.DownMbps.find(search);
+                    if (pos != std::string::npos) {
+                        x.DownMbps.replace(pos, search.length(), "");
+                    }
+                    proxy.AddMember("down_mbps", std::stoi(x.DownMbps), allocator);
+                }
+                if (!x.TLSSecure) {
+                    rapidjson::Value tls(rapidjson::kObjectType);
+                    tls.AddMember("enabled", true, allocator);
+                    if (!x.Alpn.empty()) {
+                        auto alpns = stringArrayToJsonArray(x.Alpn, ",", allocator);
+                        tls.AddMember("alpn", alpns, allocator);
+                    }
+                    if (!x.ServerName.empty()) {
+                        tls.AddMember("server_name", rapidjson::StringRef(x.ServerName.c_str()), allocator);
+                    }
+                    tls.AddMember("insecure", buildBooleanValue(scv), allocator);
+                    proxy.AddMember("tls", tls, allocator);
+                }
                 if (!x.FakeType.empty())
                     proxy.AddMember("network", rapidjson::StringRef(x.FakeType.c_str()), allocator);
-                if (!x.Alpn.empty())
-                    proxy.AddMember("tls", rapidjson::StringRef(
-                            std::string(R"({ "enabled": true,"alpn": [)" + x.Alpn + "],}").c_str()), allocator);
                 if (!x.OBFSParam.empty())
                     proxy.AddMember("obfs", rapidjson::StringRef(x.OBFSParam.c_str()), allocator);
                 break;
@@ -2296,26 +2360,44 @@ proxyToSingBox(std::vector<Proxy> &nodes, rapidjson::Document &json, std::vector
             case ProxyType::Hysteria2: {
                 addSingBoxCommonMembers(proxy, x, "hysteria2", allocator);
                 proxy.AddMember("password", rapidjson::StringRef(x.Password.c_str()), allocator);
-                rapidjson::Value tls(rapidjson::kObjectType);
-                tls.AddMember("enabled", true, allocator);
-                proxy.AddMember("tls", tls, allocator);
-                if (!x.UpMbps.empty())
-                    proxy.AddMember("up_mbps", rapidjson::StringRef(x.UpMbps.c_str()), allocator);
-                if (!x.DownMbps.empty())
-                    proxy.AddMember("down_mbps", rapidjson::StringRef(x.DownMbps.c_str()), allocator);
-                if (!x.Alpn.empty())
-                    proxy.AddMember("tls", rapidjson::StringRef(
-                            std::string(R"({ "enabled": true,"alpn": [)" + x.Alpn + "],}").c_str()), allocator);
-                if (!x.OBFSParam.empty()) {
-                    if (!x.OBFSPassword.empty()) {
-                        proxy.AddMember("obfs", rapidjson::StringRef(std::string(
-                                                R"({ "type": )" + x.OBFSParam + ",password: \"" + x.OBFSPassword + "\"}").c_str()),
-                                        allocator);
-                    } else {
-                        proxy.AddMember("obfs",
-                                        rapidjson::StringRef(std::string(R"({ "type": )" + x.OBFSParam + "}").c_str()),
-                                        allocator);
+                if (!x.TLSSecure) {
+                    rapidjson::Value tls(rapidjson::kObjectType);
+                    tls.AddMember("enabled", true, allocator);
+                    if (!x.ServerName.empty())
+                        tls.AddMember("server_name", rapidjson::StringRef(x.ServerName.c_str()), allocator);
+                    if (!x.Alpn.empty()) {
+                        auto alpns = stringArrayToJsonArray(x.Alpn, ",", allocator);
+                        tls.AddMember("alpn", alpns, allocator);
                     }
+                    tls.AddMember("insecure", buildBooleanValue(scv), allocator);
+                    proxy.AddMember("tls", tls, allocator);
+                }
+                if (!x.UpMbps.empty()) {
+                    if (!isNumeric(x.UpMbps)) {
+                        size_t pos = x.UpMbps.find(search);
+                        if (pos != std::string::npos) {
+                            x.UpMbps.replace(pos, search.length(), "");
+                        }
+                    }
+                    proxy.AddMember("up_mbps", std::stoi(x.UpMbps), allocator);
+                }
+                if (!x.DownMbps.empty()) {
+                    if (!isNumeric(x.DownMbps)) {
+                        size_t pos = x.DownMbps.find(search);
+                        if (pos != std::string::npos) {
+                            x.DownMbps.replace(pos, search.length(), "");
+                        }
+                    }
+                    proxy.AddMember("down_mbps", std::stoi(x.DownMbps), allocator);
+                }
+                if (!x.OBFSParam.empty()) {
+                    rapidjson::Value obfs(rapidjson::kObjectType);
+                    obfs.AddMember("type", rapidjson::StringRef(x.OBFSParam.c_str()), allocator);
+                    if (!x.OBFSPassword.empty()) {
+                        obfs.AddMember("password", rapidjson::StringRef(x.OBFSPassword.c_str()), allocator);
+                    }
+                    proxy.AddMember("obfs", obfs, allocator);
+
                 }
                 break;
             }
@@ -2327,9 +2409,31 @@ proxyToSingBox(std::vector<Proxy> &nodes, rapidjson::Document &json, std::vector
             tls.AddMember("enabled", true, allocator);
             if (!x.ServerName.empty())
                 tls.AddMember("server_name", rapidjson::StringRef(x.ServerName.c_str()), allocator);
-            if (!x.Alpn.empty())
-                tls.AddMember("alpn", rapidjson::StringRef(("[" + x.Alpn + "]").c_str()), allocator);
+            if (!x.Alpn.empty()) {
+                auto alpns = stringArrayToJsonArray(x.Alpn, ",", allocator);
+                tls.AddMember("alpn", alpns, allocator);
+            }
             tls.AddMember("insecure", buildBooleanValue(scv), allocator);
+            if (x.Type == ProxyType::VLESS) {
+                rapidjson::Value reality(rapidjson::kObjectType);
+                if (!x.PublicKey.empty() || !x.ShortId.empty()) {
+                    rapidjson::Value utls(rapidjson::kObjectType);
+                    utls.AddMember("enabled", true, allocator);
+                    utls.AddMember("fingerprint", rapidjson::StringRef("chrome"), allocator);
+                    tls.AddMember("utls", utls, allocator);
+                    reality.AddMember("enabled", true, allocator);
+                    if (!x.PublicKey.empty()) {
+                        reality.AddMember("public_key", rapidjson::StringRef(x.PublicKey.c_str()), allocator);
+                    }
+//                    auto shortIds = stringArrayToJsonArray(x.ShortId, ",", allocator);
+                    if (!x.ShortId.empty()) {
+                        reality.AddMember("short_id", rapidjson::StringRef(x.ShortId.c_str()), allocator);
+                    } else {
+                        reality.AddMember("short_id", rapidjson::StringRef(""), allocator);
+                    }
+                    tls.AddMember("reality", reality, allocator);
+                }
+            }
             proxy.AddMember("tls", tls, allocator);
         }
         if (!udp.is_undef() && !udp) {

src/parser/config/proxy.h

@@ -78,6 +78,8 @@ struct Proxy {
     uint16_t AlterId = 0;
     String TransferProtocol;
     String FakeType;
+    String AuthStr;
+
     bool TLSSecure = false;
 
     String Host;
@@ -107,7 +109,7 @@ struct Proxy {
     uint16_t KeepAlive = 0;
     String TestUrl;
     String ClientId;
-
+    String Ports;
     String Auth;
     String Alpn;
     String UpMbps;

src/parser/subparser.cpp

@@ -12,6 +12,7 @@
 #include "utils/yamlcpp_extra.h"
 #include "config/proxy.h"
 #include "subparser.h"
+#include "utils/logger.h"
 
 using namespace rapidjson;
 using namespace rapidjson_ext;
@@ -115,7 +116,9 @@ void httpConstruct(Proxy &node, const std::string &group, const std::string &rem
 
 void trojanConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &server,
                      const std::string &port, const std::string &password, const std::string &network,
-                     const std::string &host, const std::string &path, bool tlssecure, tribool udp, tribool tfo,
+                     const std::string &host, const std::string &path, const std::string &fp, const std::string &sni,
+                     bool tlssecure,
+                     tribool udp, tribool tfo,
                      tribool scv, tribool tls13) {
     commonConstruct(node, ProxyType::Trojan, group, remarks, server, port, udp, tfo, scv, tls13);
     node.Password = password;
@@ -123,6 +126,8 @@ void trojanConstruct(Proxy &node, const std::string &group, const std::string &r
     node.TLSSecure = tlssecure;
     node.TransferProtocol = network.empty() ? "tcp" : network;
     node.Path = path;
+    node.Fingerprint = fp;
+    node.ServerName = sni;
 }
 
 void snellConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &server,
@@ -155,8 +160,11 @@ void wireguardConstruct(Proxy &node, const std::string &group, const std::string
 
 void hysteriaConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &add,
                        const std::string &port, const std::string &type, const std::string &auth,
+                       const std::string &auth_str,
                        const std::string &host, const std::string &up, const std::string &down, const std::string &alpn,
-                       const std::string &obfsParam, const std::string &insecure, tribool udp, tribool tfo, tribool scv,
+                       const std::string &obfsParam, const std::string &insecure, const std::string &ports,
+                       const std::string &sni, tribool udp,
+                       tribool tfo, tribool scv,
                        tribool tls13) {
     commonConstruct(node, ProxyType::Hysteria, group, remarks, add, port, udp, tfo, scv, tls13);
     node.Auth = auth;
@@ -167,6 +175,9 @@ void hysteriaConstruct(Proxy &node, const std::string &group, const std::string
     node.OBFSParam = obfsParam;
     node.Insecure = insecure;
     node.FakeType = type;
+    node.AuthStr = auth_str;
+    node.Ports = ports;
+    node.ServerName = sni;
 }
 
 
@@ -174,7 +185,8 @@ void vlessConstruct(Proxy &node, const std::string &group, const std::string &re
                     const std::string &port, const std::string &type, const std::string &id, const std::string &aid,
                     const std::string &net, const std::string &cipher, const std::string &flow, const std::string &mode,
                     const std::string &path, const std::string &host, const std::string &edge, const std::string &tls,
-                    const std::string &pbk, const std::string &sid, const std::string &fp, tribool udp, tribool tfo,
+                    const std::string &pbk, const std::string &sid, const std::string &fp, const std::string &sni,
+                    tribool udp, tribool tfo,
                     tribool scv, tribool tls13) {
     commonConstruct(node, ProxyType::VLESS, group, remarks, add, port, udp, tfo, scv, tls13);
     node.UserId = id.empty() ? "00000000-0000-0000-0000-000000000000" : id;
@@ -188,7 +200,7 @@ void vlessConstruct(Proxy &node, const std::string &group, const std::string &re
     node.PublicKey = pbk;
     node.ShortId = sid;
     node.Fingerprint = fp;
-
+    node.ServerName = sni;
     switch (hash_(net)) {
         case "grpc"_hash:
             node.Host = host;
@@ -210,7 +222,8 @@ void vlessConstruct(Proxy &node, const std::string &group, const std::string &re
 void hysteria2Construct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &add,
                         const std::string &port, const std::string &password, const std::string &host,
                         const std::string &up, const std::string &down, const std::string &alpn,
-                        const std::string &obfsParam, const std::string &obfsPassword, tribool udp, tribool tfo,
+                        const std::string &obfsParam, const std::string &obfsPassword, const std::string &sni,
+                        tribool udp, tribool tfo,
                         tribool scv) {
     commonConstruct(node, ProxyType::Hysteria2, group, remarks, add, port, udp, tfo, scv, tribool());
     node.Password = password;
@@ -220,6 +233,7 @@ void hysteria2Construct(Proxy &node, const std::string &group, const std::string
     node.Alpn = alpn;
     node.OBFSParam = obfsParam;
     node.OBFSPassword = obfsPassword;
+    node.ServerName = sni;
 }
 
 void explodeVmess(std::string vmess, Proxy &node) {
@@ -793,11 +807,15 @@ void explodeHTTPSub(std::string link, Proxy &node) {
 }
 
 void explodeTrojan(std::string trojan, Proxy &node) {
-    std::string server, port, psk, addition, group, remark, host, path, network;
+    std::string server, port, psk, addition, group, remark, host, path, network, fp, sni;
     tribool tfo, scv;
-    trojan.erase(0, 9);
+    if (startsWith(trojan, "trojan://")) {
+        trojan.erase(0, 9);
+    }
+    if (startsWith(trojan, "trojan-go://")) {
+        trojan.erase(0, 12);
+    }
     string_size pos = trojan.rfind('#');
-
     if (pos != std::string::npos) {
         remark = urlDecode(trojan.substr(pos + 1));
         trojan.erase(pos);
@@ -814,9 +832,11 @@ void explodeTrojan(std::string trojan, Proxy &node) {
         return;
 
     host = getUrlArg(addition, "sni");
+    sni = getUrlArg(addition, "sni");
     if (host.empty())
         host = getUrlArg(addition, "peer");
     tfo = getUrlArg(addition, "tfo");
+    fp = getUrlArg(addition, "fp");
     scv = getUrlArg(addition, "allowInsecure");
     group = urlDecode(getUrlArg(addition, "group"));
 
@@ -838,7 +858,7 @@ void explodeTrojan(std::string trojan, Proxy &node) {
     if (group.empty())
         group = TROJAN_DEFAULT_GROUP;
 
-    trojanConstruct(node, group, remark, server, port, psk, network, host, path, true, tribool(), tfo, scv);
+    trojanConstruct(node, group, remark, server, port, psk, network, host, path, fp, sni, true, tribool(), tfo, scv);
 }
 
 void explodeVless(std::string vless, Proxy &node) {
@@ -850,6 +870,7 @@ void explodeVless(std::string vless, Proxy &node) {
 
 void explodeHysteria(std::string hysteria, Proxy &node) {
     printf("explodeHysteria\n");
+    hysteria = regReplace(hysteria, "(hysteria|hy)://", "hysteria://");
     if (regMatch(hysteria, "hysteria://(.*?)[:](.*)")) {
         explodeStdHysteria(hysteria, node);
         return;
@@ -932,7 +953,7 @@ void explodeQuan(const std::string &quan, Proxy &node) {
 void explodeNetch(std::string netch, Proxy &node) {
     Document json;
     std::string type, group, remark, address, port, username, password, method, plugin, pluginopts;
-    std::string protocol, protoparam, obfs, obfsparam, id, aid, transprot, faketype, host, edge, path, tls, sni;
+    std::string protocol, protoparam, obfs, obfsparam, id, aid, transprot, faketype, host, edge, path, tls, sni, fp;
     tribool udp, tfo, scv;
     netch = urlSafeBase64Decode(netch.substr(8));
 
@@ -947,6 +968,7 @@ void explodeNetch(std::string netch, Proxy &node) {
     tfo = GetMember(json, "EnableTFO");
     scv = GetMember(json, "AllowInsecure");
     port = GetMember(json, "Port");
+    fp = GetMember(json, "FingerPrint");
     if (port == "0")
         return;
     method = GetMember(json, "EncryptMethod");
@@ -1012,9 +1034,11 @@ void explodeNetch(std::string netch, Proxy &node) {
             path = GetMember(json, "Path");
             transprot = GetMember(json, "TransferProtocol");
             tls = GetMember(json, "TLSSecure");
+            sni = host;
             if (group.empty())
                 group = TROJAN_DEFAULT_GROUP;
-            trojanConstruct(node, group, remark, address, port, password, transprot, host, path, tls == "true", udp,
+            trojanConstruct(node, group, remark, address, port, password, transprot, host, path, fp, sni, tls == "true",
+                            udp,
                             tfo, scv);
             break;
         case "Snell"_hash:
@@ -1031,22 +1055,22 @@ void explodeNetch(std::string netch, Proxy &node) {
 }
 
 void explodeClash(Node yamlnode, std::vector<Proxy> &nodes) {
-    std::string proxytype, ps, server, port, cipher, group, password,tempPassword; //common
-    std::string type = "none", id, aid = "0", net = "tcp", path, host, edge, tls, sni; //vmess
-    std::string fp = "chrome", pbk, sid; //vless
-    std::string plugin, pluginopts, pluginopts_mode, pluginopts_host, pluginopts_mux; //ss
-    std::string protocol, protoparam, obfs, obfsparam; //ssr
-    std::string flow, mode; //trojan
-    std::string user; //socks
-    std::string ip, ipv6, private_key, public_key, mtu; //wireguard
-    std::string auth, up, down, obfsParam, insecure,alpn;//hysteria
-    std::string obfsPassword;//hysteria2
-    string_array dns_server;
-    tribool udp, tfo, scv;
     Node singleproxy;
     uint32_t index = nodes.size();
     const std::string section = yamlnode["proxies"].IsDefined() ? "proxies" : "Proxy";
     for (uint32_t i = 0; i < yamlnode[section].size(); i++) {
+        std::string proxytype, ps, server, port, cipher, group, password = "", ports, tempPassword; //common
+        std::string type = "none", id, aid = "0", net = "tcp", path, host, edge, tls, sni; //vmess
+        std::string fp = "chrome", pbk, sid; //vless
+        std::string plugin, pluginopts, pluginopts_mode, pluginopts_host, pluginopts_mux; //ss
+        std::string protocol, protoparam, obfs, obfsparam; //ssr
+        std::string flow, mode; //trojan
+        std::string user; //socks
+        std::string ip, ipv6, private_key, public_key, mtu; //wireguard
+        std::string auth, up, down, obfsParam, insecure, alpn;//hysteria
+        std::string obfsPassword;//hysteria2
+        string_array dns_server;
+        tribool udp, tfo, scv;
         Proxy node;
         singleproxy = yamlnode[section][i];
         singleproxy["type"] >>= proxytype;
@@ -1059,9 +1083,11 @@ void explodeClash(Node yamlnode, std::vector<Proxy> &nodes) {
         scv = safe_as<std::string>(singleproxy["skip-cert-verify"]);
         switch (hash_(proxytype)) {
             case "vmess"_hash:
-                group = V2RAY_DEFAULT_GROUP;
-
                 singleproxy["uuid"] >>= id;
+                if (id.length() < 36) {
+                    break;
+                }
+                group = V2RAY_DEFAULT_GROUP;
                 singleproxy["alterId"] >>= aid;
                 singleproxy["cipher"] >>= cipher;
                 net = singleproxy["network"].IsDefined() ? safe_as<std::string>(singleproxy["network"]) : "tcp";
@@ -1203,6 +1229,7 @@ void explodeClash(Node yamlnode, std::vector<Proxy> &nodes) {
                 group = TROJAN_DEFAULT_GROUP;
                 singleproxy["password"] >>= password;
                 singleproxy["sni"] >>= host;
+                singleproxy["sni"] >>= sni;
                 singleproxy["network"] >>= net;
                 switch (hash_(net)) {
                     case "grpc"_hash:
@@ -1217,7 +1244,7 @@ void explodeClash(Node yamlnode, std::vector<Proxy> &nodes) {
                         break;
                 }
 
-                trojanConstruct(node, group, ps, server, port, password, net, host, path, true, udp, tfo, scv);
+                trojanConstruct(node, group, ps, server, port, password, net, host, path, fp, sni, true, udp, tfo, scv);
                 break;
             case "snell"_hash:
                 group = SNELL_DEFAULT_GROUP;
@@ -1291,11 +1318,17 @@ void explodeClash(Node yamlnode, std::vector<Proxy> &nodes) {
                 singleproxy["flow"] >>= flow;
 
                 vlessConstruct(node, XRAY_DEFAULT_GROUP, ps, server, port, type, id, aid, net, "auto", flow, mode, path,
-                               host, "", tls, pbk, sid, fp);
+                               host, "", tls, pbk, sid, fp, sni);
                 break;
             case "hysteria"_hash:
                 group = HYSTERIA_DEFAULT_GROUP;
                 singleproxy["auth_str"] >> auth;
+                if (auth.empty()) {
+                    singleproxy["auth-str"] >> auth;
+                    if (auth.empty()) {
+                        singleproxy["password"] >> auth;
+                    }
+                }
                 singleproxy["up"] >> up;
                 singleproxy["down"] >> down;
                 singleproxy["obfs"] >> obfsParam;
@@ -1303,23 +1336,26 @@ void explodeClash(Node yamlnode, std::vector<Proxy> &nodes) {
                 singleproxy["sni"] >> host;
                 singleproxy["alpn"][0] >> alpn;
                 singleproxy["protocol"] >> insecure;
-
-                hysteriaConstruct(node, group, ps, server, port, type, auth, host, up, down, alpn, obfsParam, insecure,
+                singleproxy["ports"] >> ports;
+                sni = host;
+                hysteriaConstruct(node, group, ps, server, port, type, auth, "", host, up, down, alpn, obfsParam,
+                                  insecure, ports, sni,
                                   udp, tfo, scv);
                 break;
             case "hysteria2"_hash:
                 group = HYSTERIA2_DEFAULT_GROUP;
                 singleproxy["password"] >>= password;
-                singleproxy["auth"] >>= password;
+                if (password.empty())
+                    singleproxy["auth"] >>= password;
                 singleproxy["up"] >>= up;
                 singleproxy["down"] >>= down;
                 singleproxy["obfs"] >>= obfsParam;
                 singleproxy["obfs-password"] >>= obfsPassword;
                 singleproxy["sni"] >>= host;
                 singleproxy["alpn"][0] >>= alpn;
-
+                sni = host;
                 hysteria2Construct(node, group, ps, server, port, password, host, up, down, alpn, obfsParam,
-                                   obfsPassword, udp, tfo, scv);
+                                   obfsPassword, sni, udp, tfo, scv);
                 break;
             default:
                 continue;
@@ -1373,7 +1409,7 @@ void explodeStdVMess(std::string vmess, Proxy &node) {
 
 
 void explodeStdHysteria(std::string hysteria, Proxy &node) {
-    std::string add, port, type, auth, host, insecure, up, down, alpn, obfsParam, remarks;
+    std::string add, port, type, auth, host, insecure, up, down, alpn, obfsParam, remarks, auth_str, sni;
     std::string addition;
     hysteria = hysteria.substr(11);
     string_size pos;
@@ -1388,23 +1424,26 @@ void explodeStdHysteria(std::string hysteria, Proxy &node) {
         return;
     type = getUrlArg(addition, "protocol");
     auth = getUrlArg(addition, "auth");
+    auth_str = getUrlArg(addition, "auth_str");
     host = getUrlArg(addition, "peer");
     insecure = getUrlArg(addition, "insecure");
     up = getUrlArg(addition, "upmbps");
     down = getUrlArg(addition, "downmbps");
     alpn = getUrlArg(addition, "alpn");
     obfsParam = getUrlArg(addition, "obfsParam");
+    sni = getUrlArg(addition, "peer");
 
     if (remarks.empty())
         remarks = add + ":" + port;
 
-    hysteriaConstruct(node, HYSTERIA_DEFAULT_GROUP, remarks, add, port, type, auth, host, up, down, alpn, obfsParam,
-                      insecure);
+    hysteriaConstruct(node, HYSTERIA_DEFAULT_GROUP, remarks, add, port, type, auth, auth_str, host, up, down, alpn,
+                      obfsParam,
+                      insecure, "", sni);
     return;
 }
 
 void explodeStdHysteria2(std::string hysteria2, Proxy &node) {
-    std::string add, port, password, host, insecure, up, down, alpn, obfsParam, obfsPassword, remarks;
+    std::string add, port, password, host, insecure, up, down, alpn, obfsParam, obfsPassword, remarks, sni;
     std::string addition;
     tribool scv;
     hysteria2 = hysteria2.substr(12);
@@ -1444,18 +1483,18 @@ void explodeStdHysteria2(std::string hysteria2, Proxy &node) {
     obfsParam = getUrlArg(addition, "obfs");
     obfsPassword = getUrlArg(addition, "obfs-password");
     host = getUrlArg(addition, "sni");
-
+    sni = getUrlArg(addition, "sni");
     if (remarks.empty())
         remarks = add + ":" + port;
 
     hysteria2Construct(node, HYSTERIA2_DEFAULT_GROUP, remarks, add, port, password, host, up, down, alpn, obfsParam,
-                       obfsPassword, tribool(), tribool(), scv);
+                       obfsPassword, host, tribool(), tribool(), scv);
     return;
 }
 
 
 void explodeStdVless(std::string vless, Proxy &node) {
-    std::string add, port, type, id, aid, net, flow, pbk, sid, fp, mode, path, host, tls, remarks;
+    std::string add, port, type, id, aid, net, flow, pbk, sid, fp, mode, path, host, tls, remarks, sni;
     std::string addition;
     vless = vless.substr(8);
     string_size pos;
@@ -1500,9 +1539,9 @@ void explodeStdVless(std::string vless, Proxy &node) {
 
     if (remarks.empty())
         remarks = add + ":" + port;
-
+    sni = getUrlArg(addition, "sni");
     vlessConstruct(node, XRAY_DEFAULT_GROUP, remarks, add, port, type, id, aid, net, "auto", flow, mode, path, host, "",
-                   tls, pbk, sid, fp);
+                   tls, pbk, sid, fp, sni);
     return;
 }
 
@@ -1639,9 +1678,9 @@ bool explodeSurge(std::string surge, std::vector<Proxy> &nodes) {
     const std::string proxystr = "(.*?)\\s*=\\s*(.*)";
 
     for (auto &x: proxies) {
-        std::string remarks, server, port, method, username, password; //common
+        std::string remarks, server, port, method, username, password, sni; //common
         std::string plugin, pluginopts, pluginopts_mode, pluginopts_host, mod_url, mod_md5; //ss
-        std::string id, net, tls, host, edge, path; //v2
+        std::string id, net, tls, host, edge, path, fp; //v2
         std::string protocol, protoparam; //ssr
         std::string section, ip, ipv6, private_key, public_key, mtu, test_url, client_id, peer, keepalive; //wireguard
         string_array dns_servers;
@@ -1910,6 +1949,7 @@ bool explodeSurge(std::string surge, std::vector<Proxy> &nodes) {
                             break;
                         case "sni"_hash:
                             host = itemVal;
+                            sni = itemVal;
                             break;
                         case "udp-relay"_hash:
                             udp = itemVal;
@@ -1920,12 +1960,17 @@ bool explodeSurge(std::string surge, std::vector<Proxy> &nodes) {
                         case "skip-cert-verify"_hash:
                             scv = itemVal;
                             break;
+                        case "fingerprint"_hash:
+                            fp = itemVal;
+                            break;
                         default:
                             continue;
                     }
                 }
 
-                trojanConstruct(node, TROJAN_DEFAULT_GROUP, remarks, server, port, password, "", host, "", true, udp,
+                trojanConstruct(node, TROJAN_DEFAULT_GROUP, remarks, server, port, password, "", host, "", fp, sni,
+                                true,
+                                udp,
                                 tfo, scv);
                 break;
             case "snell"_hash:
@@ -2213,6 +2258,7 @@ bool explodeSurge(std::string surge, std::vector<Proxy> &nodes) {
                                     break;
                                 case "tls-host"_hash:
                                     host = itemVal;
+                                    sni = itemVal;
                                     break;
                                 case "udp-relay"_hash:
                                     udp = itemVal;
@@ -2226,6 +2272,9 @@ bool explodeSurge(std::string surge, std::vector<Proxy> &nodes) {
                                 case "tls13"_hash:
                                     tls13 = itemVal;
                                     break;
+                                case "fp"_hash:
+                                    fp = itemVal;
+                                    break;
                                 default:
                                     continue;
                             }
@@ -2233,7 +2282,8 @@ bool explodeSurge(std::string surge, std::vector<Proxy> &nodes) {
                         if (remarks.empty())
                             remarks = server + ":" + port;
 
-                        trojanConstruct(node, TROJAN_DEFAULT_GROUP, remarks, server, port, password, "", host, "",
+                        trojanConstruct(node, TROJAN_DEFAULT_GROUP, remarks, server, port, password, "", host, "", fp,
+                                        sni,
                                         tls == "true", udp, tfo, scv, tls13);
                         break;
                     case "http"_hash: //quantumult x style http links
@@ -2420,6 +2470,234 @@ int explodeConfContent(const std::string &content, std::vector<Proxy> &nodes) {
     return !nodes.empty();
 }
 
+void explodeSingboxTransport(rapidjson::Value &singboxNode, std::string &net, std::string &host, std::string &path,
+                             std::string edge) {
+    if (singboxNode.HasMember("transport") && singboxNode["transport"].IsObject()) {
+        rapidjson::Value transport = singboxNode["transport"].GetObject();
+        net = GetMember(transport, "type");
+        switch (hash_(net)) {
+            case "http"_hash: {
+                host = GetMember(transport, "host");
+                break;
+            }
+            case "ws"_hash: {
+                path = GetMember(transport, "path");
+                if (transport.HasMember("headers") && transport["headers"].IsObject()) {
+                    rapidjson::Value headers = transport["headers"].GetObject();
+                    host = GetMember(headers, "Host");
+                    edge = GetMember(headers, "Edge");
+                }
+                break;
+            }
+            case "grpc"_hash: {
+                path = GetMember(transport, "service_name");
+                break;
+            }
+            default:
+                net = "tcp";
+                path.clear();
+                break;
+        }
+    } else {
+        net = "tcp";
+        host.clear();
+        edge.clear();
+        path.clear();
+    }
+}
+
+void explodeSingbox(rapidjson::Value &outbounds, std::vector<Proxy> &nodes) {
+    uint32_t index = nodes.size();
+    for (rapidjson::SizeType i = 0; i < outbounds.Size(); ++i) {
+        if (outbounds[i].IsObject()) {
+            std::string proxytype, ps, server, port, cipher, group, password, ports, tempPassword; //common
+            std::string type = "none", id, aid = "0", net = "tcp", path, host, edge, tls, sni; //vmess
+            std::string fp = "chrome", pbk, sid; //vless
+            std::string plugin, pluginopts, pluginopts_mode, pluginopts_host, pluginopts_mux; //ss
+            std::string protocol, protoparam, obfs, obfsparam; //ssr
+            std::string flow, mode; //trojan
+            std::string user; //socks
+            std::string ip, ipv6, private_key, public_key, mtu; //wireguard
+            std::string auth, up, down, obfsParam, insecure, alpn;//hysteria
+            std::string obfsPassword;//hysteria2
+            string_array dns_server;
+            tribool udp, tfo, scv;
+            rapidjson::Value singboxNode = outbounds[i].GetObject();
+            if (singboxNode.HasMember("type") && singboxNode["type"].IsString()) {
+                Proxy node;
+                proxytype = singboxNode["type"].GetString();
+                ps = GetMember(singboxNode, "tag");
+                server = GetMember(singboxNode, "server");
+                port = GetMember(singboxNode, "server_port");
+                tfo = GetMember(singboxNode, "tcp_fast_open");
+                if (singboxNode.HasMember("tls") && singboxNode["tls"].IsObject()) {
+                    rapidjson::Value tlsObj = singboxNode["tls"].GetObject();
+                    if (tlsObj.HasMember("enabled") && tlsObj["enabled"].IsBool() && tlsObj["enabled"].GetBool()) {
+                        tls = "tls";
+                    }
+                    sni = GetMember(tlsObj, "server_name");
+                    if (tlsObj.HasMember("alpn") && tlsObj["alpn"].IsArray() && !tlsObj["alpn"].Empty()) {
+                        rapidjson::Value alpns = tlsObj["alpn"].GetArray();
+                        if (alpns.Size() > 0) {
+                            alpn = alpns[0].GetString();
+                        }
+                    }
+                    if (tlsObj.HasMember("insecure") && tlsObj["insecure"].IsBool()) {
+                        scv = tlsObj["insecure"].GetBool();
+                    }
+                    if (tlsObj.HasMember("reality") && tlsObj["reality"].IsObject()) {
+                        tls = "reality";
+                        rapidjson::Value reality = tlsObj["reality"].GetObject();
+                        if (reality.HasMember("server_name") && reality["server_name"].IsString()) {
+                            host = reality["server_name"].GetString();
+                        }
+                        if (reality.HasMember("public_key") && reality["public_key"].IsString()) {
+                            pbk = reality["public_key"].GetString();
+                        }
+                        if (reality.HasMember("short_id") && reality["short_id"].IsString()) {
+                            sid = reality["short_id"].GetString();
+                        }
+                    }
+                } else {
+                    tls = "false";
+                }
+                switch (hash_(proxytype)) {
+                    case "vmess"_hash:
+                        group = V2RAY_DEFAULT_GROUP;
+                        id = GetMember(singboxNode, "uuid");
+                        if (id.length() < 36) {
+                            break;
+                        }
+                        aid = GetMember(singboxNode, "alter_id");
+                        cipher = GetMember(singboxNode, "security");
+                        explodeSingboxTransport(singboxNode, net, host, path, edge);
+                        vmessConstruct(node, group, ps, server, port, "", id, aid, net, cipher, path, host, edge, tls,
+                                       sni, udp,
+                                       tfo, scv);
+                        break;
+                    case "shadowsocks"_hash:
+                        group = SS_DEFAULT_GROUP;
+                        cipher = GetMember(singboxNode, "method");
+                        password = GetMember(singboxNode, "password");
+                        plugin = GetMember(singboxNode, "plugin");
+                        pluginopts = GetMember(singboxNode, "plugin_opts");
+                        ssConstruct(node, group, ps, server, port, password, cipher, plugin, pluginopts, udp, tfo, scv);
+                        break;
+                    case "trojan"_hash:
+                        group = TROJAN_DEFAULT_GROUP;
+                        password = GetMember(singboxNode, "password");
+                        explodeSingboxTransport(singboxNode, net, host, path, edge);
+                        trojanConstruct(node, group, ps, server, port, password, net, host, path, fp, sni, true, udp,
+                                        tfo,
+                                        scv);
+                        break;
+                    case "vless"_hash:
+                        group = XRAY_DEFAULT_GROUP;
+                        id = GetMember(singboxNode, "uuid");
+                        flow = GetMember(singboxNode, "flow");
+                        if (singboxNode.HasMember("transport") && singboxNode["transport"].IsObject()) {
+                            rapidjson::Value transport = singboxNode["transport"].GetObject();
+                            net = GetMember(transport, "type");
+                            switch (hash_(net)) {
+                                case "tcp"_hash: {
+                                    break;
+                                }
+                                case "ws"_hash: {
+                                    path = GetMember(transport, "path");
+                                    if (transport.HasMember("headers") && transport["headers"].IsObject()) {
+                                        rapidjson::Value headers = transport["headers"].GetObject();
+                                        host = GetMember(headers, "Host");
+                                        edge = GetMember(headers, "Edge");
+                                    }
+                                    break;
+                                }
+                                case "http"_hash: {
+                                    host = GetMember(transport, "host");
+                                    path = GetMember(transport, "path");
+                                    edge.clear();
+                                    break;
+                                }
+                                case "httpupgrade"_hash: {
+                                    net = "h2";
+                                    host = GetMember(transport, "host");
+                                    path = GetMember(transport, "path");
+                                    edge.clear();
+                                    break;
+                                }
+                                case "grpc"_hash: {
+                                    host = server;
+                                    path = GetMember(transport, "service_name");
+                                    break;
+                                }
+                            }
+                        }
+                        vlessConstruct(node, group, ps, server, port, type, id, aid, net, "auto", flow, mode, path,
+                                       host, "", tls, pbk, sid, fp, sni);
+                        break;
+                    case "http"_hash:
+                        password = GetMember(singboxNode, "password");
+                        user = GetMember(singboxNode, "username");
+                        httpConstruct(node, group, ps, server, port, user, password, tls == "tls", tfo, scv);
+                        break;
+                    case "wireguard"_hash:
+                        group = WG_DEFAULT_GROUP;
+                        ip = GetMember(singboxNode, "inet4_bind_address");
+                        ipv6 = GetMember(singboxNode, "inet6_bind_address");
+                        public_key = GetMember(singboxNode, "private_key");
+                        private_key = GetMember(singboxNode, "public_key");
+                        mtu = GetMember(singboxNode, "mtu");
+                        password = GetMember(singboxNode, "pre_shared_key");
+                        dns_server = {"8.8.8.8"};
+                        wireguardConstruct(node, group, ps, server, port, ip, ipv6, private_key, public_key, password,
+                                           dns_server, mtu, "0", "", "", udp);
+                        break;
+                    case "socks"_hash:
+                        group = SOCKS_DEFAULT_GROUP;
+                        user = GetMember(singboxNode, "username");
+                        password = GetMember(singboxNode, "password");
+                        socksConstruct(node, group, ps, server, port, user, password);
+                        break;
+                    case "hysteria"_hash:
+                        group = HYSTERIA_DEFAULT_GROUP;
+                        up = GetMember(singboxNode, "up");
+                        if (up.empty()) {
+                            up = GetMember(singboxNode, "up_mbps");
+                        }
+                        down = GetMember(singboxNode, "down");
+                        if (down.empty()) {
+                            down = GetMember(singboxNode, "down_mbps");
+                        }
+                        auth = GetMember(singboxNode, "auth_str");
+                        type = GetMember(singboxNode, "network");
+                        obfsParam = GetMember(singboxNode, "obfs");
+                        hysteriaConstruct(node, group, ps, server, port, type, auth, "", host, up, down, alpn,
+                                          obfsParam, insecure, ports, sni,
+                                          udp, tfo, scv);
+                        break;
+                    case "hysteria2"_hash:
+                        group = HYSTERIA2_DEFAULT_GROUP;
+                        password = GetMember(singboxNode, "password");
+                        up = GetMember(singboxNode, "up");
+                        down = GetMember(singboxNode, "down");
+                        if (singboxNode.HasMember("obfs") && singboxNode["obfs"].IsObject()) {
+                            rapidjson::Value obfsOpt = singboxNode["obfs"].GetObject();
+                            obfsParam = GetMember(obfsOpt, "type");
+                            obfsPassword = GetMember(obfsOpt, "password");
+                        }
+                        hysteria2Construct(node, group, ps, server, port, password, host, up, down, alpn, obfsParam,
+                                           obfsPassword, sni, udp, tfo, scv);
+                        break;
+                    default:
+                        continue;
+                }
+                node.Id = index;
+                nodes.emplace_back(std::move(node));
+                index++;
+            }
+        }
+    }
+}
+
 void explode(const std::string &link, Proxy &node) {
     if (startsWith(link, "ssr://"))
         explodeSSR(link, node);
@@ -2433,11 +2711,11 @@ void explode(const std::string &link, Proxy &node) {
         explodeHTTP(link, node);
     else if (startsWith(link, "Netch://"))
         explodeNetch(link, node);
-    else if (startsWith(link, "trojan://"))
+    else if (startsWith(link, "trojan://") || startsWith(link, "trojan-go://"))
         explodeTrojan(link, node);
     else if (strFind(link, "vless://") || strFind(link, "vless1://"))
         explodeVless(link, node);
-    else if (strFind(link, "hysteria://"))
+    else if (strFind(link, "hysteria://") || strFind(link, "hy://"))
         explodeHysteria(link, node);
     else if (strFind(link, "hysteria2://") || strFind(link, "hy2://"))
         explodeHysteria2(link, node);
@@ -2472,7 +2750,33 @@ void explodeSub(std::string sub, std::vector<Proxy> &nodes) {
         //ignore
         throw;
     }
-
+    try {
+        std::string pattern = "\"?(inbounds)\"?:";
+        if (!processed &&
+            regFind(sub, pattern)) {
+            pattern = "\"?(outbounds)\"?:";
+            if (regFind(sub, pattern)) {
+                pattern = "\"?(route)\"?:";
+                if (regFind(sub, pattern)) {
+                    rapidjson::Document document;
+                    document.Parse(sub.c_str());
+                    if (!document.HasParseError() || document.IsObject()) {
+                        rapidjson::Value &value = document["outbounds"];
+                        if (value.IsArray() && !value.Empty()) {
+                            explodeSingbox(value, nodes);
+                            processed = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (std::exception &e) {
+        writeLog(LOG_TYPE_ERROR, e.what(), LOG_LEVEL_ERROR);
+        //writeLog(0, e.what(), LOG_LEVEL_DEBUG);
+        //ignore
+        throw;
+    }
     //try to parse as surge configuration
     if (!processed && explodeSurge(sub, nodes)) {
         processed = true;

src/parser/subparser.h

@@ -19,15 +19,15 @@ enum class ConfType
     SUB,
     Local
 };
-void hysteriaConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &add, const std::string &port, const std::string &type, const std::string &auth, const std::string &host, const std::string &up, const std::string &down, const std::string &alpn, const std::string &obfsParam, const std::string &insecure ,tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool(), tribool tls13 = tribool());
-void hysteria2Construct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &add, const std::string &port, const std::string &password, const std::string &host, const std::string &up, const std::string &down, const std::string &alpn, const std::string &obfsParam, const std::string &obfsPassword, const std::string &insecure ,tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool(), tribool tls13 = tribool());
-void vlessConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &add, const std::string &port, const std::string &type, const std::string &id, const std::string &aid, const std::string &net, const std::string &cipher, const std::string &flow, const std::string &mode, const std::string &path, const std::string &host, const std::string &edge, const std::string &tls,const std::string &pkd, const std::string &sid, const std::string &fp, tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool(), tribool tls13 = tribool());
+void hysteriaConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &add, const std::string &port, const std::string &type, const std::string &auth, const std::string &auth_str, const std::string &host, const std::string &up, const std::string &down, const std::string &alpn, const std::string &obfsParam, const std::string &insecure,const std::string &ports,const std::string &sni,tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool(), tribool tls13 = tribool());
+void hysteria2Construct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &add, const std::string &port, const std::string &password, const std::string &host, const std::string &up, const std::string &down, const std::string &alpn, const std::string &obfsParam, const std::string &obfsPassword, const std::string &sni, const std::string &insecure ,tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool(), tribool tls13 = tribool());
+void vlessConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &add, const std::string &port, const std::string &type, const std::string &id, const std::string &aid, const std::string &net, const std::string &cipher, const std::string &flow, const std::string &mode, const std::string &path, const std::string &host, const std::string &edge, const std::string &tls,const std::string &pkd, const std::string &sid, const std::string &fp,const std::string &sni, tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool(), tribool tls13 = tribool());
 void vmessConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &add, const std::string &port, const std::string &type, const std::string &id, const std::string &aid, const std::string &net, const std::string &cipher, const std::string &path, const std::string &host, const std::string &edge, const std::string &tls, const std::string &sni, tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool(), tribool tls13 = tribool());
 void ssrConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &server, const std::string &port, const std::string &protocol, const std::string &method, const std::string &obfs, const std::string &password, const std::string &obfsparam, const std::string &protoparam, tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool());
 void ssConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &server, const std::string &port, const std::string &password, const std::string &method, const std::string &plugin, const std::string &pluginopts, tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool(), tribool tls13 = tribool());
 void socksConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &server, const std::string &port, const std::string &username, const std::string &password, tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool());
 void httpConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &server, const std::string &port, const std::string &username, const std::string &password, bool tls, tribool tfo = tribool(), tribool scv = tribool(), tribool tls13 = tribool());
-void trojanConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &server, const std::string &port, const std::string &password, const std::string &network, const std::string &host, const std::string &path, bool tlssecure, tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool(), tribool tls13 = tribool());
+void trojanConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &server, const std::string &port, const std::string &password, const std::string &network, const std::string &host, const std::string &path,const std::string &fp,const std::string &sni, bool tlssecure, tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool(),  tribool tls13 = tribool());
 void snellConstruct(Proxy &node, const std::string &group, const std::string &remarks, const std::string &server, const std::string &port, const std::string &password, const std::string &obfs, const std::string &host, uint16_t version = 0, tribool udp = tribool(), tribool tfo = tribool(), tribool scv = tribool());
 void explodeVmess(std::string vmess, Proxy &node);
 void explodeSSR(std::string ssr, Proxy &node);

src/version.h

@@ -1,6 +1,6 @@
 #ifndef VERSION_H_INCLUDED
 #define VERSION_H_INCLUDED
 
-#define VERSION "v0.8.2"
+#define VERSION "v0.9.2"
 
 #endif // VERSION_H_INCLUDED