hiddifypanel 10.11.0__py3-none-any.whl → 10.12.0__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-10.11.0
+10.12.0

hiddifypanel/VERSION.py

@@ -1,3 +1,3 @@
-__version__='10.11.0'
+__version__='10.12.0'
 from datetime import datetime
-__release_date__= datetime.strptime('2024-03-15','%Y-%m-%d')
+__release_date__= datetime.strptime('2024-03-19','%Y-%m-%d')

hiddifypanel/auth.py

@@ -143,9 +143,11 @@ def auth_before_request():
         # print(account)
         if not account:
             return logout_redirect()
-
-        next_url = request.url.replace(f'/{g.uuid}/', '/admin/' if is_admin_path else '/client/').replace("/admin/admin/",
-                                                                                                          '/admin/').replace("http://", "https://")
+        if is_admin_path:
+            next_url = request.url
+            next_url = next_url.replace(f'/{g.uuid}/', '/admin/')
+            next_url = next_url.replace("/admin/admin/", '/admin/')
+            next_url = next_url.replace("http://", "https://")
 
     elif apikey := request.headers.get("Hiddify-API-Key"):
         account = get_account_by_api_key(apikey, is_admin_path)
@@ -180,8 +182,16 @@ def auth_before_request():
         g.is_admin = hutils.flask.is_admin_role(account.role)  # type: ignore
         login_user(account, force=True)
         # print("loggining in")
-        if next_url is not None and g.user_agent['is_browser'] and ".webmanifest" not in request.path:
-            return redirect(next_url)
+        if not g.is_admin:
+            return
+        if next_url is None:
+            return
+        if not g.user_agent['is_browser']:
+            return
+        if ".webmanifest" in request.path:
+            return
+
+        return redirect(next_url)
 
 
 def logout_redirect():

hiddifypanel/hutils/encode.py

@@ -1,7 +1,6 @@
 import urllib.parse
 import base64
 import uuid
-import string
 from slugify import slugify
 
 

hiddifypanel/hutils/proxy/__init__.py

@@ -1,4 +1,5 @@
 from .shared import *
 from . import xray
+from . import xrayjson
 from . import singbox
 from . import clash

hiddifypanel/hutils/proxy/shared.py

@@ -259,6 +259,11 @@ def make_proxy(hconfigs: dict, proxy: Proxy, domain_db: Domain, phttp=80, ptls=4
     }
     if proxy.proto in ['tuic', 'hysteria2']:
         base['alpn'] = "h3"
+        if proxy.proto == 'hysteria2':
+            base['hysteria_up_mbps'] = hconfigs.get(ConfigEnum.hysteria_up_mbps)
+            base['hysteria_down_mbps'] = hconfigs.get(ConfigEnum.hysteria_down_mbps)
+            base['hysteria_obfs_enable'] = hconfigs.get(ConfigEnum.hysteria_obfs_enable)
+            base['hysteria_obfs_password'] = hconfigs.get(ConfigEnum.proxy_path)  # TODO: it should not be correct
         return base
     if proxy.proto in ['wireguard']:
         base['wg_pub'] = g.account.wg_pub
@@ -317,6 +322,8 @@ def make_proxy(hconfigs: dict, proxy: Proxy, domain_db: Domain, phttp=80, ptls=4
         base['cipher'] = hconfigs[ConfigEnum.shadowsocks2022_method]
         base['password'] = f'{hutils.encode.do_base_64(hconfigs[ConfigEnum.shared_secret].replace("-",""))}:{hutils.encode.do_base_64(g.account.uuid.replace("-",""))}'
 
+    if base['proto'] == 'trojan':
+        base['password'] = base['uuid']
     if base["proto"] == "ssr":
         base["ssr-obfs"] = "tls1.2_ticket_auth"
         base["ssr-protocol"] = "auth_sha1_v4"
@@ -341,20 +348,18 @@ def make_proxy(hconfigs: dict, proxy: Proxy, domain_db: Domain, phttp=80, ptls=4
 
     if proxy.proto in {'vless', 'trojan', 'vmess'} and hconfigs.get(ConfigEnum.mux_enable):
         if hconfigs[ConfigEnum.mux_enable]:
-            base['mux_enable'] = True
-            base['mux_protocol'] = hconfigs[ConfigEnum.mux_protocol]
-            base['mux_max_connections'] = hconfigs[ConfigEnum.mux_max_connections]
-            base['mux_min_streams'] = hconfigs[ConfigEnum.mux_min_streams]
-            base['mux_max_streams'] = hconfigs[ConfigEnum.mux_max_streams]
-            base['mux_padding_enable'] = hconfigs[ConfigEnum.mux_padding_enable]
+            base['mux_enable'] = hconfigs[ConfigEnum.core_type]
 
-            # the hiddify next client doesn't support mux max streams
-            base['mux_max_streams'] = hconfigs[ConfigEnum.mux_max_streams]
+            base['mux_protocol'] = hconfigs.get(ConfigEnum.mux_protocol, "h2mux")
+            base['mux_max_connections'] = hconfigs.get(ConfigEnum.mux_max_connections, 0)
+            base['mux_min_streams'] = hconfigs.get(ConfigEnum.mux_min_streams, 0)
+            base['mux_max_streams'] = hconfigs.get(ConfigEnum.mux_max_streams, 0)
+            base['mux_padding_enable'] = hconfigs.get(ConfigEnum.mux_padding_enable)
 
             if hconfigs[ConfigEnum.mux_brutal_enable]:
                 base['mux_brutal_enable'] = True
-                base['mux_brutal_up_mbps'] = hconfigs[ConfigEnum.mux_brutal_up_mbps]
-                base['mux_brutal_down_mbps'] = hconfigs[ConfigEnum.mux_brutal_down_mbps]
+                base['mux_brutal_up_mbps'] = hconfigs.get(ConfigEnum.mux_brutal_up_mbps, 10)
+                base['mux_brutal_down_mbps'] = hconfigs.get(ConfigEnum.mux_brutal_down_mbps, 10)
 
     if is_cdn and proxy.proto in {'vless', 'trojan', "vmess"}:
         if hconfigs[ConfigEnum.tls_fragment_enable]:
@@ -364,6 +369,11 @@ def make_proxy(hconfigs: dict, proxy: Proxy, domain_db: Domain, phttp=80, ptls=4
 
         if hconfigs[ConfigEnum.tls_mixed_case]:
             base["tls_mixed_case"] = hconfigs[ConfigEnum.tls_mixed_case]
+            base['host'] = hutils.random.random_case(base['host'])
+            base['sni'] = hutils.random.random_case(base['sni'])
+            base['server'] = hutils.random.random_case(base['server'])
+            if base.get('fakedomain'):
+                base['fakedomain'] = hutils.random.random_case(base['fakedomain'])
 
         if hconfigs[ConfigEnum.tls_padding_enable]:
             base["tls_padding_enable"] = hconfigs[ConfigEnum.tls_padding_enable]

hiddifypanel/hutils/proxy/singbox.py

@@ -2,11 +2,11 @@ from flask import render_template, request, g
 import json
 
 from hiddifypanel import hutils
-from hiddifypanel.models import ProxyProto, ProxyTransport, Domain, ConfigEnum, hconfig
+from hiddifypanel.models import ProxyProto, ProxyTransport, Domain, ConfigEnum
 from hiddifypanel.panel.hiddify import is_hiddify_next_version
 
 
-def make_full_singbox_config(domains: list[Domain], **kwargs) -> str:
+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]
@@ -60,32 +60,32 @@ def to_singbox(proxy: dict) -> list[dict] | dict:
     base["server_port"] = int(proxy["port"])
     # base['alpn'] = proxy['alpn'].split(',')
     if proxy["proto"] == "ssr":
-        add_singbox_ssr(base, proxy)
+        add_ssr(base, proxy)
         return all_base
     if proxy["proto"] == ProxyProto.wireguard:
-        add_singbox_wireguard(base, proxy)
+        add_wireguard(base, proxy)
         return all_base
 
     if proxy["proto"] in ["ss", "v2ray"]:
-        add_singbox_shadowsocks_base(all_base, proxy)
+        add_shadowsocks_base(all_base, proxy)
         return all_base
     if proxy["proto"] == "ssh":
-        add_singbox_ssh(all_base, proxy)
+        add_ssh(all_base, proxy)
         return all_base
 
     if proxy["proto"] == "trojan":
-        base["password"] = proxy["uuid"]
+        base["password"] = proxy["password"]
 
     if proxy['proto'] in ['vmess', 'vless']:
         base["uuid"] = proxy["uuid"]
 
     if proxy['proto'] in ['vmess', 'vless', 'trojan']:
-        add_singbox_multiplex(base)
+        add_multiplex(base, proxy)
 
-    add_singbox_tls(base, proxy)
+    add_tls(base, proxy)
 
     if g.user_agent.get('is_hiddify'):
-        add_singbox_tls_tricks(base, proxy)
+        add_tls_tricks(base, proxy)
 
     if proxy.get('flow'):
         base["flow"] = proxy['flow']
@@ -100,51 +100,52 @@ def to_singbox(proxy: dict) -> list[dict] | dict:
         base["packet_encoding"] = "xudp"  # udp packet encoding
 
     if proxy["proto"] == "tuic":
-        add_singbox_tuic(base, proxy)
+        add_tuic(base, proxy)
     elif proxy["proto"] == "hysteria2":
-        add_singbox_hysteria(base, proxy)
+        add_hysteria(base, proxy)
     else:
-        add_singbox_transport(base, proxy)
+        add_transport(base, proxy)
 
     return all_base
 
 
-def add_singbox_multiplex(base: dict):
-    if not hconfig(ConfigEnum.mux_enable):
+def add_multiplex(base: dict, proxy: dict):
+    if proxy.get('mux_enable') != "singbox":
         return
     base['multiplex'] = {
         "enabled": True,
-        "protocol": hconfig(ConfigEnum.mux_protocol),
-        "padding": hconfig(ConfigEnum.mux_padding_enable)
+        "protocol": proxy['mux_protocol'],
+        "padding": proxy['mux_padding_enable']
     }
     # Conflicts: max_streams with max_connections and min_streams
-    mux_max_streams = int(hconfig(ConfigEnum.mux_max_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'] = int(hconfig(ConfigEnum.mux_max_connections))
-        base['multiplex']['min_streams'] = int(hconfig(ConfigEnum.mux_min_streams))
+        base['multiplex']['max_connections'] = proxy.get('mux_max_connections', 0)
+        base['multiplex']['min_streams'] = proxy.get('mux_min_streams', 0)
 
-    add_singbox_tcp_brutal(base)
+    add_tcp_brutal(base,proxy)
 
 
-def add_singbox_tcp_brutal(base: dict):
+def add_tcp_brutal(base: dict, proxy: dict):
     if 'multiplex' in base:
-        base['multiplex']['brutal'] = {
-            "enabled": hconfig(ConfigEnum.mux_brutal_enable),
-            "up_mbps": int(hconfig(ConfigEnum.mux_brutal_up_mbps)),
-            "down_mbps": int(hconfig(ConfigEnum.mux_brutal_down_mbps))
-        }
+        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_singbox_udp_over_tcp(base: dict):
+def add_udp_over_tcp(base: dict):
     base['udp_over_tcp'] = {
         "enabled": True,
         "version": 2
     }
 
 
-def add_singbox_tls(base: dict, proxy: dict):
+def add_tls(base: dict, proxy: dict):
     if not ("tls" in proxy["l3"] or "reality" in proxy["l3"]):
         return
     base["tls"] = {
@@ -170,7 +171,7 @@ def add_singbox_tls(base: dict, proxy: dict):
     # }
 
 
-def add_singbox_tls_tricks(base: dict, proxy: dict):
+def add_tls_tricks(base: dict, proxy: dict):
     if proxy.get('tls_fragment_enable'):
         base['tls_fragment'] = {
             'enabled': True,
@@ -188,7 +189,7 @@ def add_singbox_tls_tricks(base: dict, proxy: dict):
             base['tls']['tls_tricks']['mixedcase_sni'] = True
 
 
-def add_singbox_transport(base: dict, proxy: dict):
+def add_transport(base: dict, proxy: dict):
     if proxy['l3'] == 'reality' and proxy['transport'] not in ["grpc"]:
         return
     base["transport"] = {}
@@ -213,10 +214,10 @@ def add_singbox_transport(base: dict, proxy: dict):
         base["transport"] = {
             "type": "http",
             "path": proxy.get("path", ""),
-            # "method": "",
-            # "headers": {},
             "idle_timeout": "15s",
             "ping_timeout": "15s"
+            # "method": "",
+            # "headers": {},
         }
 
         if 'host' in proxy:
@@ -232,7 +233,7 @@ def add_singbox_transport(base: dict, proxy: dict):
         }
 
 
-def add_singbox_ssr(base: dict, proxy: dict):
+def add_ssr(base: dict, proxy: dict):
 
     base["method"] = proxy["cipher"]
     base["password"] = proxy["uuid"]
@@ -242,7 +243,7 @@ def add_singbox_ssr(base: dict, proxy: dict):
     base["protocol-param"] = proxy["fakedomain"]
 
 
-def add_singbox_wireguard(base: dict, proxy: dict):
+def add_wireguard(base: dict, proxy: dict):
 
     base["local_address"] = f'{proxy["wg_ipv4"]}/32'
     base["private_key"] = proxy["wg_pk"]
@@ -255,13 +256,13 @@ def add_singbox_wireguard(base: dict, proxy: dict):
         base["fake_packets"] = proxy["wg_noise_trick"]
 
 
-def add_singbox_shadowsocks_base(all_base: list[dict], proxy: dict):
+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_singbox_udp_over_tcp(base)
-    add_singbox_multiplex(base)
+    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"]}'
@@ -290,13 +291,13 @@ def add_singbox_shadowsocks_base(all_base: list[dict], proxy: dict):
                 # "alpn": proxy['alpn'].split(',')
             }
         }
-        # add_singbox_utls(shadowtls_base)
+        # add_utls(shadowtls_base)
         del base['server']
         del base['server_port']
         all_base.append(shadowtls_base)
 
 
-def add_singbox_ssh(all_base: list[dict], proxy: dict):
+def add_ssh(all_base: list[dict], proxy: dict):
     base = all_base[0]
     # base["client_version"]= "{{ssh_client_version}}"
     base["user"] = proxy['uuid']
@@ -317,7 +318,7 @@ def add_singbox_ssh(all_base: list[dict], proxy: dict):
     all_base.append(socks_front)
 
 
-def add_singbox_tuic(base: dict, proxy: dict):
+def add_tuic(base: dict, proxy: dict):
     base['congestion_control'] = "cubic"
     base['udp_relay_mode'] = 'native'
     base['zero_rtt_handshake'] = True
@@ -326,13 +327,13 @@ def add_singbox_tuic(base: dict, proxy: dict):
     base['uuid'] = proxy['uuid']
 
 
-def add_singbox_hysteria(base: dict, proxy: dict):
-    base['up_mbps'] = int(hconfig(ConfigEnum.hysteria_up_mbps))
-    base['down_mbps'] = int(hconfig(ConfigEnum.hysteria_down_mbps))
+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 hconfig(ConfigEnum.hysteria_obfs_enable):
+    if proxy.get('hysteria_obfs_enable'):
         base['obfs'] = {
             "type": "salamander",
-            "password": hconfig(ConfigEnum.proxy_path)
+            "password": proxy.get('hysteria_obfs_password')
         }
     base['password'] = proxy['uuid']

hiddifypanel/hutils/proxy/xray.py

@@ -1,10 +1,23 @@
 import datetime
 import json
-from flask import request, g
+import copy
+from flask import render_template, request, g
 from hiddifypanel import hutils
-from hiddifypanel.models import Proxy, ProxyTransport, ProxyL3, ProxyCDN, ProxyProto, Domain, hconfig, ConfigEnum, DomainType
+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:
@@ -35,6 +48,7 @@ def to_link(proxy: dict) -> str | dict:
                       "sni": proxy["sni"],
                       "fp": proxy["fingerprint"]
                       }
+
         if 'reality' in proxy["l3"]:
             vmess_data['tls'] = "reality"
             vmess_data['pbk'] = proxy['reality_pbk']
@@ -74,7 +88,7 @@ def to_link(proxy: dict) -> str | dict:
             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={hconfig(ConfigEnum.proxy_path)}&sni={proxy["sni"]}'
+        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}"
@@ -180,12 +194,6 @@ def make_v2ray_configs(user, user_activate, domains: list[Domain], expire_days,
     return "\n".join(res)
 
 
-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_tls_tricks_to_dict(d: dict, proxy: dict):
     if proxy.get('tls_fragment_enable'):
         if g.user_agent.get('is_shadowrocket'):
@@ -199,21 +207,29 @@ def add_tls_tricks_to_dict(d: dict, proxy: dict):
         d['padsize'] = proxy["tls_padding_length"]
 
 
-def add_mux_to_link(proxy: dict) -> str:
+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_mux_to_dict(out, proxy)
+    add_tls_tricks_to_dict(out, proxy)
     return hutils.encode.convert_dict_to_url(out)
 
 
-def add_mux_to_dict(d: dict, proxy):
-    if proxy.get('mux_enable'):
-        # 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_mux_to_link(proxy: dict) -> str:
+    out = {}
+    add_mux_to_dict(out, proxy)
+    return hutils.encode.convert_dict_to_url(out)