hiddifypanel 9.0.0.dev90__py3-none-any.whl → 10.5.0.dev0__py3-none-any.whl

hiddifypanel/hutils/proxy/singbox.py

@@ -0,0 +1,339 @@
+from flask import render_template, request, g
+import json
+
+from hiddifypanel import hutils
+from hiddifypanel.models import ProxyProto, ProxyTransport, Domain, ConfigEnum
+from hiddifypanel.panel.hiddify import is_hiddify_next_version
+
+
+def configs_as_json(domains: list[Domain], **kwargs) -> str:
+    ua = hutils.flask.get_user_agent()
+    base_config = json.loads(render_template('base_singbox_config.json.j2'))
+    allphttp = [p for p in request.args.get("phttp", "").split(',') if p]
+    allptls = [p for p in request.args.get("ptls", "").split(',') if p]
+
+    allp = []
+    for d in domains:
+        base_config['dns']['rules'][0]['domain'].append(d.domain)
+    for pinfo in hutils.proxy.get_valid_proxies(domains):
+        sing = to_singbox(pinfo)
+        if 'msg' not in sing:
+            allp += sing
+    base_config['outbounds'] += allp
+
+    select = {
+        "type": "selector",
+        "tag": "Select",
+        "outbounds": [p['tag'] for p in allp if 'shadowtls-out' not in p['tag']],
+        "default": "Auto"
+    }
+    select['outbounds'].insert(0, "Auto")
+    base_config['outbounds'].insert(0, select)
+    smart = {
+        "type": "urltest",
+        "tag": "Auto",
+        "outbounds": [p['tag'] for p in allp if 'shadowtls-out' not in p],
+        "url": "https://www.gstatic.com/generate_204",
+        "interval": "10m",
+        "tolerance": 200
+    }
+    base_config['outbounds'].insert(1, smart)
+    res = json.dumps(base_config, indent=4, cls=hutils.proxy.ProxyJsonEncoder)
+    # if ua['is_hiddify']:
+    #     res = res[:-1]+',"experimental": {}}'
+    return res
+
+
+def to_singbox(proxy: dict) -> list[dict] | dict:
+    name = proxy['name']
+
+    all_base = []
+    if proxy['l3'] == "kcp":
+        return {'name': name, 'msg': "clash does not support kcp", 'type': 'debug'}
+
+    base = {}
+    all_base.append(base)
+    # vmess ws
+    base["tag"] = f"""{proxy['extra_info']} {proxy["name"]} § {proxy['port']} {proxy["dbdomain"].id}"""
+    base["type"] = str(proxy["proto"])
+    base["server"] = proxy["server"]
+    base["server_port"] = int(proxy["port"])
+    # base['alpn'] = proxy['alpn'].split(',')
+    if proxy["proto"] == "ssr":
+        add_ssr(base, proxy)
+        return all_base
+    if proxy["proto"] == ProxyProto.wireguard:
+        add_wireguard(base, proxy)
+        return all_base
+
+    if proxy["proto"] in ["ss", "v2ray"]:
+        add_shadowsocks_base(all_base, proxy)
+        return all_base
+    if proxy["proto"] == "ssh":
+        add_ssh(all_base, proxy)
+        return all_base
+
+    if proxy["proto"] == "trojan":
+        base["password"] = proxy["password"]
+
+    if proxy['proto'] in ['vmess', 'vless']:
+        base["uuid"] = proxy["uuid"]
+
+    if proxy['proto'] in ['vmess', 'vless', 'trojan']:
+        add_multiplex(base, proxy)
+
+    add_tls(base, proxy)
+
+    if g.user_agent.get('is_hiddify'):
+        add_tls_tricks(base, proxy)
+
+    if proxy.get('flow'):
+        base["flow"] = proxy['flow']
+        # base["flow-show"] = True
+
+    if proxy["proto"] == "vmess":
+        base["alter_id"] = 0
+        base["security"] = proxy["cipher"]
+
+    # base["udp"] = True
+    if proxy["proto"] in ["vmess", "vless"]:
+        base["packet_encoding"] = "xudp"  # udp packet encoding
+
+    if proxy["proto"] == "tuic":
+        add_tuic(base, proxy)
+    elif proxy["proto"] == "hysteria2":
+        add_hysteria(base, proxy)
+    else:
+        add_transport(base, proxy)
+
+    return all_base
+
+
+def add_multiplex(base: dict, proxy: dict):
+    if proxy.get('mux_enable') != "singbox":
+        return
+    base['multiplex'] = {
+        "enabled": True,
+        "protocol": proxy['mux_protocol'],
+        "padding": proxy['mux_padding_enable']
+    }
+    # Conflicts: max_streams with max_connections and min_streams
+    mux_max_streams = proxy.get('mux_max_streams', 0)
+    if mux_max_streams and mux_max_streams != 0:
+        base['multiplex']['max_streams'] = mux_max_streams
+    else:
+        base['multiplex']['max_connections'] = proxy.get('mux_max_connections', 0)
+        base['multiplex']['min_streams'] = proxy.get('mux_min_streams', 0)
+
+    add_tcp_brutal(base,proxy)
+
+
+def add_tcp_brutal(base: dict, proxy: dict):
+    if 'multiplex' in base:
+        if proxy.get('mux_brutal_enable'):
+            base['multiplex']['brutal'] = {
+                "enabled": proxy.get('mux_brutal_enable', False),
+                "up_mbps": proxy.get('mux_brutal_up_mbps', 10),
+                "down_mbps": proxy.get('mux_brutal_down_mbps', 10)
+            }
+
+
+def add_udp_over_tcp(base: dict):
+    base['udp_over_tcp'] = {
+        "enabled": True,
+        "version": 2
+    }
+
+
+def add_tls(base: dict, proxy: dict):
+    if not ("tls" in proxy["l3"] or "reality" in proxy["l3"]):
+        return
+    base["tls"] = {
+        "enabled": True,
+        "server_name": proxy["sni"]
+    }
+    if proxy['proto'] not in ["tuic", "hysteria2"]:
+        base["tls"]["utls"] = {
+            "enabled": True,
+            "fingerprint": proxy.get('fingerprint', 'none')
+        }
+
+    if "reality" in proxy["l3"]:
+        base["tls"]["reality"] = {
+            "enabled": True,
+            "public_key": proxy['reality_pbk'],
+            "short_id": proxy['reality_short_id']
+        }
+    base["tls"]['insecure'] = proxy['allow_insecure'] or (proxy["mode"] == "Fake")
+    base["tls"]["alpn"] = proxy['alpn'].split(',')
+    # base['ech'] = {
+    #     "enabled": True,
+    # }
+
+
+def add_tls_tricks(base: dict, proxy: dict):
+    if proxy.get('tls_fragment_enable'):
+        base['tls_fragment'] = {
+            'enabled': True,
+            'size': proxy["tls_fragment_size"],
+            'sleep': proxy["tls_fragment_sleep"]
+        }
+
+    if 'tls' in base:
+        if proxy.get("tls_padding_enable") or proxy.get("tls_mixed_case"):
+            base['tls']['tls_tricks'] = {}
+        if proxy.get("tls_padding_enable"):
+            base['tls']['tls_tricks']['padding_size'] = proxy["tls_padding_length"]
+
+        if proxy.get("tls_mixed_case"):
+            base['tls']['tls_tricks']['mixedcase_sni'] = True
+
+
+def add_transport(base: dict, proxy: dict):
+    if proxy['l3'] == 'reality' and proxy['transport'] not in ["grpc"]:
+        return
+    base["transport"] = {}
+    if proxy['transport'] in ["ws", "WS"]:
+        base["transport"] = {
+            "type": "ws",
+            "path": proxy["path"],
+            "early_data_header_name": "Sec-WebSocket-Protocol"
+        }
+        if "host" in proxy:
+            base["transport"]["headers"] = {"Host": proxy["host"]}
+
+    if proxy['transport'] in [ProxyTransport.httpupgrade]:
+        base["transport"] = {
+            "type": "httpupgrade",
+            "path": proxy["path"]
+        }
+        if "host" in proxy:
+            base["transport"]["headers"] = {"Host": proxy["host"]}
+
+    if proxy["transport"] in ["tcp", "h2"]:
+        base["transport"] = {
+            "type": "http",
+            "path": proxy.get("path", ""),
+            "idle_timeout": "15s",
+            "ping_timeout": "15s"
+            # "method": "",
+            # "headers": {},
+        }
+
+        if 'host' in proxy:
+            base["transport"]["host"] = [proxy["host"]]
+
+    if proxy["transport"] == "grpc":
+        base["transport"] = {
+            "type": "grpc",
+            "service_name": proxy["grpc_service_name"],
+            "idle_timeout": "115s",
+            "ping_timeout": "15s",
+            # "permit_without_stream": false
+        }
+
+
+def add_ssr(base: dict, proxy: dict):
+
+    base["method"] = proxy["cipher"]
+    base["password"] = proxy["uuid"]
+    # base["udp"] = True
+    base["obfs"] = proxy["ssr-obfs"]
+    base["protocol"] = proxy["ssr-protocol"]
+    base["protocol-param"] = proxy["fakedomain"]
+
+
+def add_wireguard(base: dict, proxy: dict):
+
+    base["local_address"] = f'{proxy["wg_ipv4"]}/32'
+    base["private_key"] = proxy["wg_pk"]
+    base["peer_public_key"] = proxy["wg_server_pub"]
+
+    base["pre_shared_key"] = proxy["wg_psk"]
+
+    base["mtu"] = 1380
+    if g.user_agent.get('is_hiddify') and is_hiddify_next_version(0, 15, 0):
+        base["fake_packets"] = proxy["wg_noise_trick"]
+
+
+def add_shadowsocks_base(all_base: list[dict], proxy: dict):
+    base = all_base[0]
+    base["type"] = "shadowsocks"
+    base["method"] = proxy["cipher"]
+    base["password"] = proxy["password"]
+    add_udp_over_tcp(base)
+    add_multiplex(base, proxy)
+    if proxy["transport"] == "faketls":
+        base["plugin"] = "obfs-local"
+        base["plugin_opts"] = f'obfs=tls;obfs-host={proxy["fakedomain"]}'
+    if proxy['proto'] == 'v2ray':
+        base["plugin"] = "v2ray-plugin"
+        # "skip-cert-verify": proxy["mode"] == "Fake" or proxy['allow_insecure'],
+        base["plugin_opts"] = f'mode=websocket;path={proxy["path"]};host={proxy["host"]};tls'
+
+    if proxy["transport"] == "shadowtls":
+        base['detour'] = base['tag'] + "_shadowtls-out §hide§"
+
+        shadowtls_base = {
+            "type": "shadowtls",
+            "tag": base['detour'],
+            "server": base['server'],
+            "server_port": base['server_port'],
+            "version": 3,
+            "password": proxy["shared_secret"],
+            "tls": {
+                "enabled": True,
+                "server_name": proxy["fakedomain"],
+                "utls": {
+                    "enabled": True,
+                    "fingerprint": proxy.get('fingerprint', 'none')
+                },
+                # "alpn": proxy['alpn'].split(',')
+            }
+        }
+        # add_utls(shadowtls_base)
+        del base['server']
+        del base['server_port']
+        all_base.append(shadowtls_base)
+
+
+def add_ssh(all_base: list[dict], proxy: dict):
+    base = all_base[0]
+    # base["client_version"]= "{{ssh_client_version}}"
+    base["user"] = proxy['uuid']
+    base["private_key"] = proxy['private_key']  # .replace('\n', '\\n')
+
+    base["host_key"] = proxy.get('host_key', [])
+
+    socks_front = {
+        "type": "socks",
+        "tag": base['tag'] + "+UDP",
+        "server": "127.0.0.1",
+        "server_port": 2000,
+        "version": "5",
+        "udp_over_tcp": True,
+        "network": "tcp",
+        "detour": base['tag']
+    }
+    all_base.append(socks_front)
+
+
+def add_tuic(base: dict, proxy: dict):
+    base['congestion_control'] = "cubic"
+    base['udp_relay_mode'] = 'native'
+    base['zero_rtt_handshake'] = True
+    base['heartbeat'] = "10s"
+    base['password'] = proxy['uuid']
+    base['uuid'] = proxy['uuid']
+
+
+def add_hysteria(base: dict, proxy: dict):
+    base['up_mbps'] = proxy.get(ConfigEnum.hysteria_up_mbps)
+    base['down_mbps'] = proxy.get(ConfigEnum.hysteria_down_mbps)
+    # TODO: check the obfs should be empty or not exists at all
+    if proxy.get('hysteria_obfs_enable'):
+        base['obfs'] = {
+            "type": "salamander",
+            "password": proxy.get('hysteria_obfs_password')
+        }
+    base['password'] = proxy['uuid']

hiddifypanel/hutils/proxy/xray.py

@@ -0,0 +1,235 @@
+import datetime
+import json
+import copy
+from flask import render_template, request, g
+from hiddifypanel import hutils
+from hiddifypanel.models import Proxy, ProxyTransport, ProxyL3, ProxyCDN, ProxyProto, Domain, ConfigEnum, DomainType, hconfig
+from flask_babel import gettext as _
+
+OUTBOUND_LEVEL = 8
+
+
+def is_muxable_agent(proxy: dict) -> bool:
+    if not proxy.get('mux_enable'):
+        return False
+    if proxy.get('mux_enable') == "xray" and g.user_agent.get('is_singbox'):
+        return False
+    if proxy.get('mux_enable') == "singbox" and not g.user_agent.get('is_singbox'):
+        return False
+    return True
+
+
+def to_link(proxy: dict) -> str | dict:
+    if 'error' in proxy:
+        return proxy
+
+    orig_name_link = (proxy['extra_info'] + " " + proxy["name"]).strip()
+    name_link = hutils.encode.url_encode(orig_name_link)
+    if proxy['proto'] == 'vmess':
+        # print(proxy)
+        vmess_type = None
+        if proxy["transport"] == 'tcp':
+            vmess_type = 'http'
+        if 'grpc_mode' in proxy:
+            vmess_type = proxy['grpc_mode']
+        vmess_data = {"v": "2",
+                      "ps": orig_name_link,
+                      "add": proxy['server'],
+                      "port": proxy['port'],
+                      "id": proxy["uuid"],
+                      "aid": 0,
+                      "scy": proxy['cipher'],
+                      "net": proxy["transport"],
+                      "type": vmess_type or "none",
+                      "host": proxy.get("host", ""),
+                      "alpn": proxy.get("alpn", "h2,http/1.1"),
+                      "path": proxy["path"] if "path" in proxy else "",
+                      "tls": "tls" if "tls" in proxy["l3"] else "",
+                      "sni": proxy["sni"],
+                      "fp": proxy["fingerprint"]
+                      }
+
+        if 'reality' in proxy["l3"]:
+            vmess_data['tls'] = "reality"
+            vmess_data['pbk'] = proxy['reality_pbk']
+            vmess_data['sid'] = proxy['reality_short_id']
+
+        add_tls_tricks_to_dict(vmess_data, proxy)
+        add_mux_to_dict(vmess_data, proxy)
+
+        return "vmess://" + hutils.encode.do_base_64(f'{json.dumps(vmess_data,cls=hutils.proxy.ProxyJsonEncoder)}')
+    if proxy['proto'] == 'ssh':
+        baseurl = 'ssh://'
+        if g.user_agent.get('is_streisand'):
+            streisand_ssh = hutils.encode.do_base_64(f'{proxy["uuid"]}:0:{proxy["private_key"]}::@{proxy["server"]}:{proxy["port"]}')
+            baseurl += f'{streisand_ssh}#{name_link}'
+        else:
+            hk = ",".join(proxy["host_key"])
+            pk = proxy["private_key"].replace('\n', '')
+            baseurl += f'{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}/?file=ssh&pk={pk}&hk={hk}#{name_link}'
+
+        return baseurl
+    if proxy['proto'] == "ssr":
+        baseurl = f'ssr://{proxy["cipher"]}:{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}'
+        return baseurl
+    if proxy['proto'] in ['ss', 'v2ray']:
+        baseurl = f'ss://{proxy["cipher"]}:{proxy["password"]}@{proxy["server"]}:{proxy["port"]}'
+        if proxy['mode'] == 'faketls':
+            return f'{baseurl}?plugin=obfs-local%3Bobfs%3Dtls%3Bobfs-host%3D{proxy["fakedomain"]}%3Budp-over-tcp=true#{name_link}'
+        # if proxy['mode'] == 'shadowtls':
+        #     return f'{baseurl}?plugin=shadow-tls%3Bpassword%3D{proxy["proxy_path"]}%3Bhost%3D{proxy["fakedomain"]}%3Budp-over-tcp=true#{name_link}'
+        if proxy['proto'] == 'v2ray':
+            return f'{baseurl}?plugin=v2ray-plugin%3Bmode%3Dwebsocket%3Bpath%3D{proxy["path"]}%3Bhost%3D{proxy["host"]}%3Btls%3Budp-over-tcp=true#{name_link}'
+        if proxy['transport'] == 'shadowsocks':
+            return baseurl
+    if proxy['proto'] == 'tuic':
+        baseurl = f'tuic://{proxy["uuid"]}:{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}?congestion_control=cubic&udp_relay_mode=native&sni={proxy["sni"]}&alpn=h3'
+        if proxy['mode'] == 'Fake' or proxy['allow_insecure']:
+            baseurl += "&allow_insecure=1"
+        return f"{baseurl}#{name_link}"
+    if proxy['proto'] == 'hysteria2':
+        baseurl = f'hysteria2://{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}?hiddify=1&obfs=salamander&obfs-password={proxy["hysteria_obfs_password"]}&sni={proxy["sni"]}'
+        if proxy['mode'] == 'Fake' or proxy['allow_insecure']:
+            baseurl += "&insecure=1"
+        return f"{baseurl}#{name_link}"
+    if proxy['proto'] == ProxyProto.wireguard:
+        if g.user_agent.get('is_streisand'):
+            return f'wireguard://{proxy["server"]}:{proxy["port"]}?private_key={proxy["wg_pk"]}&peer_public_key={proxy["wg_server_pub"]}&pre_shared_key={proxy["wg_psk"]}&reserved=0,0,0#{name_link}'
+        else:
+            # hiddify_format =
+            # f'wg://{proxy["server"]}:{proxy["port"]}/?pk={proxy["wg_pk"]}&local_address={proxy["wg_ipv4"]}/32&peer_pk={proxy["wg_server_pub"]}&pre_shared_key={proxy["wg_psk"]}&workers=4&mtu=1380&reserved=0,0,0&ifp={proxy["wg_noise_trick"]}#{name_link}'
+            return f'wg://{proxy["server"]}:{proxy["port"]}?publicKey={proxy["wg_pub"]}&privateKey={proxy["wg_pk"]}=&presharedKey={proxy["wg_psk"]}&ip=10.0.0.1&mtu=1380&keepalive=30&udp=1&reserved=0,0,0&ifp={proxy["wg_noise_trick"]}#{name_link}'
+
+    baseurl = f'{proxy["proto"]}://{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}?hiddify=1'
+    baseurl += f'&sni={proxy["sni"]}&type={proxy["transport"]}'
+    baseurl += f"&alpn={proxy['alpn']}"
+
+    # the ray2sing supports vless, vmess and trojan tls tricks and mux
+    # the vmess handled already
+
+    baseurl += add_mux_to_link(proxy)
+    baseurl += add_tls_tricks_to_link(proxy)
+
+    # infos+=f'&alpn={proxy["alpn"]}'
+    baseurl += f'&path={proxy["path"]}' if "path" in proxy else ""
+    baseurl += f'&host={proxy["host"]}' if "host" in proxy else ""
+    if "grpc" == proxy["transport"]:
+        baseurl += f'&serviceName={proxy["grpc_service_name"]}&mode={proxy["grpc_mode"]}'
+    # print(proxy['cdn'],proxy["transport"])
+    if request.args.get("fragment"):
+        baseurl += f'&fragment=' + request.args.get("fragment")  # type: ignore
+    if "ws" == proxy["transport"] and proxy['cdn'] and request.args.get("fragment_v1"):
+        baseurl += f'&fragment_v1=' + request.args.get("fragment_v1")  # type: ignore
+    if 'vless' == proxy['proto']:
+        baseurl += "&encryption=none"
+    if proxy.get('fingerprint', 'none') != 'none':
+        baseurl += "&fp=" + proxy['fingerprint']
+    if proxy['l3'] != 'quic':
+        if proxy.get('l3') != ProxyL3.reality and (proxy.get('transport') == ProxyTransport.tcp or proxy.get('transport') == ProxyTransport.httpupgrade) and proxy['proto'] in [ProxyProto.vless, ProxyProto.trojan]:
+            baseurl += '&headerType=http'
+        else:
+            baseurl += '&headerType=None'
+    if proxy['mode'] == 'Fake' or proxy['allow_insecure']:
+        baseurl += "&allowInsecure=true"
+    if proxy.get('flow'):
+        baseurl += f'&flow={proxy["flow"]}'
+
+    infos = f'#{name_link}'
+
+    if 'reality' in proxy["l3"]:
+        return f"{baseurl}&security=reality&pbk={proxy['reality_pbk']}&sid={proxy['reality_short_id']}{infos}"
+    if 'tls' in proxy['l3']:
+        return f'{baseurl}&security=tls{infos}'
+    if proxy['l3'] == 'http':
+        return f'{baseurl}&security=none{infos}'
+    return proxy
+
+
+def make_v2ray_configs(user, user_activate, domains: list[Domain], expire_days, ip_debug, db_domain, has_auto_cdn, asn, profile_title, **kwargs) -> str:
+    res = []
+
+    ua = hutils.flask.get_user_agent()
+    if hconfig(ConfigEnum.show_usage_in_sublink):
+
+        if not ua['is_hiddify']:
+
+            fake_ip_for_sub_link = datetime.datetime.now().strftime(f"%H.%M--%Y.%m.%d.time:%H%M")
+            # if ua['app'] == "Fair1":
+            #     res.append(f'trojan://1@{fake_ip_for_sub_link}?sni=fake_ip_for_sub_link&security=tls#{round(user.current_usage_GB,3)}/{user.usage_limit_GB}GB_Remain:{expire_days}days')
+            # else:
+
+            # res.append(f'trojan://1@{fake_ip_for_sub_link}?sni=fake_ip_for_sub_link&security=tls#{hutils.encode.url_encode(profile_title)}')
+
+            name = '⏳' if user_activate else '✖'
+            if user.usage_limit_GB < 1000:
+                name += f'{round(user.current_usage_GB,3)}/{str(user.usage_limit_GB).replace(".0","")}GB'
+            elif user.usage_limit_GB < 100000:
+                name += f'{round(user.current_usage_GB/1000,3)}/{str(round(user.usage_limit_GB/1000,1)).replace(".0","")}TB'
+            else:
+                res.append("#No Usage Limit")
+            if expire_days < 1000:
+                name += " " + _(f'📅%(expire_days)s days', expire_days=expire_days)
+            else:
+                res.append("#No Time Limit")
+
+            name = name.strip()
+            if len(name) > 3:
+                res.append(f'trojan://1@{fake_ip_for_sub_link}?sni=fake_ip_for_sub_link&security=tls#{hutils.encode.url_encode(name)}')
+
+    if ua['is_browser']:
+        res.append(f'#Hiddify auto ip: {ip_debug}')
+
+    if not user_activate:
+
+        if hconfig(ConfigEnum.lang) == 'fa':
+            res.append('trojan://1@1.1.1.1#' + hutils.encode.url_encode('✖بسته شما به پایان رسید'))
+        else:
+            res.append('trojan://1@1.1.1.1#' + hutils.encode.url_encode('✖Package_Ended'))
+        return "\n".join(res)
+
+    for pinfo in hutils.proxy.get_valid_proxies(domains):
+        link = to_link(pinfo)
+        if 'msg' not in link:
+            res.append(link)
+    return "\n".join(res)
+
+
+def add_tls_tricks_to_dict(d: dict, proxy: dict):
+    if proxy.get('tls_fragment_enable'):
+        if g.user_agent.get('is_shadowrocket'):
+            d['fragment'] = f'1,{proxy["tls_fragment_size"]},{proxy["tls_fragment_sleep"]}'
+        else:
+            d['fragment'] = f'{proxy["tls_fragment_size"]},{proxy["tls_fragment_sleep"]},tlshello'
+
+    if proxy.get("tls_mixed_case"):
+        d['mc'] = 1
+    if proxy.get("tls_padding_enable"):
+        d['padsize'] = proxy["tls_padding_length"]
+
+
+def add_mux_to_dict(d: dict, proxy):
+    if not is_muxable_agent(proxy):
+        return
+
+    # according to github.com/hiddify/ray2sing/
+    d['muxtype'] = proxy["mux_protocol"]
+    d['muxmaxc'] = proxy["mux_max_connections"]
+    d['mux'] = proxy['mux_min_streams']
+    d['muxsmax'] = proxy["mux_max_streams"]
+    d['muxpad'] = proxy["mux_padding_enable"]
+
+    if proxy.get('mux_brutal_enable'):
+        d['muxup'] = proxy["mux_brutal_up_mbps"]
+        d['muxdown'] = proxy["mux_brutal_down_mbps"]
+
+
+def add_tls_tricks_to_link(proxy: dict) -> str:
+    out = {}
+    add_tls_tricks_to_dict(out, proxy)
+    return hutils.encode.convert_dict_to_url(out)
+
+
+def add_mux_to_link(proxy: dict) -> str:
+    out = {}
+    add_mux_to_dict(out, proxy)
+    return hutils.encode.convert_dict_to_url(out)