hiddifypanel 9.0.0.dev54__py3-none-any.whl → 9.0.0.dev61__py3-none-any.whl

hiddifypanel/panel/hiddify.py

@@ -1,17 +1,22 @@
 import glob
+import random
+import socket
+import ssl
+import time
+import uuid
 import user_agents
 import json
 import subprocess
 import psutil
+from datetime import datetime
 from typing import Tuple
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.primitives.asymmetric import x25519
-from flask import current_app, g, jsonify, request
+from flask import current_app, g, request, Markup  # type: ignore
 from flask_babelex import gettext as __
 from flask_babelex import lazy_gettext as _
 from wtforms.validators import ValidationError
 from apiflask import abort as apiflask_abort
-from apiflask import abort
 
 from datetime import timedelta
 from babel.dates import format_timedelta as babel_format_timedelta
@@ -56,7 +61,7 @@ def add_short_link_imp(link: str, period_min: int = 5) -> Tuple[str, datetime]:
             if link in line:
                 return re.search(pattern, line).group(1), datetime.now() + timedelta(minutes=period_min)
 
-    short_code = get_random_string(6, 10).lower()
+    short_code = hutils.random.get_random_string(6, 10).lower()
     # exec_command(
     #     f'sudo /opt/hiddify-manager/nginx/add2shortlink.sh {link} {short_code} {period_min} &')
 
@@ -171,6 +176,8 @@ def is_login_call() -> bool:
 
 
 def is_admin_role(role: Role):
+    if not role:
+        return False
     if role in {Role.super_admin, Role.admin, Role.agent}:
         return True
     return False
@@ -201,18 +208,18 @@ def proxy_path_validator(proxy_path):
         return
 
     if proxy_path not in [admin_proxy_path, deprecated_path, client_proxy_path]:
-        abort(400, 'invalid request')
+        apiflask_abort(400, 'invalid request')
 
     if is_admin_panel_call() and proxy_path != admin_proxy_path:
-        abort(400, 'invalid request')
+        apiflask_abort(400, 'invalid request')
     if is_user_panel_call() and proxy_path != client_proxy_path:
-        abort(400, 'invalid request')
+        apiflask_abort(400, 'invalid request')
 
     if is_api_call(request.path):
         if is_admin_api_call() and proxy_path != admin_proxy_path:
-            return apiflask_abort(400, Markup(f"Invalid Proxy Path <a href=/{admin_proxy_path}/admin>Admin Panel</a>")) if dbg_mode else abort(400, 'invalid request')
+            return apiflask_abort(400, Markup(f"Invalid Proxy Path <a href=/{admin_proxy_path}/admin>Admin Panel</a>")) if dbg_mode else apiflask_abort(400, 'invalid request')
         if is_user_api_call() and proxy_path != client_proxy_path:
-            return apiflask_abort(400, Markup(f"Invalid Proxy Path <a href=/{client_proxy_path}/admin>User Panel</a>")) if dbg_mode else abort(400, 'invalid request')
+            return apiflask_abort(400, Markup(f"Invalid Proxy Path <a href=/{client_proxy_path}/admin>User Panel</a>")) if dbg_mode else apiflask_abort(400, 'invalid request')
 
 
 def asset_url(path) -> str:
@@ -270,17 +277,6 @@ def quick_apply_users():
     return {"status": 'success'}
 
 
-def flash_config_success(restart_mode='', domain_changed=True):
-    if restart_mode:
-        url = url_for('admin.Actions:reinstall', complete_install=restart_mode ==
-                      'reinstall', domain_changed=domain_changed)
-        apply_btn = f"<a href='{url}' class='btn btn-primary form_post'>" + \
-            _("admin.config.apply_configs")+"</a>"
-        flash((_('config.validation-success', link=apply_btn)), 'success')
-    else:
-        flash((_('config.validation-success-no-reset')), 'success')
-
-
 # Importing socket library
 
 # Function to display hostname and
@@ -332,7 +328,7 @@ def get_html_user_link(model: BaseAccount, domain: Domain):
     res = ""
     d = domain.domain
     if "*" in d:
-        d = d.replace("*", get_random_string(5, 15))
+        d = d.replace("*", hutils.random.get_random_string(5, 15))
 
     link = get_account_panel_link(model, d)+f"#{model.name}"
 
@@ -379,7 +375,7 @@ def check_need_reset(old_configs, do=False):
     if old_configs[ConfigEnum.package_mode] != hconfig(ConfigEnum.package_mode):
         return reinstall_action(do_update=True)
     if not (do and restart_mode == 'reinstall'):
-        return flash_config_success(restart_mode=restart_mode, domain_changed=False)
+        return hutils.flask.flash_config_success(restart_mode=restart_mode, domain_changed=False)
 
     return reinstall_action(complete_install=True, domain_changed=domain_changed)
 
@@ -648,9 +644,12 @@ def get_random_domains(count=1, retry=3):
             return random.sample(defdomains, count)
         return get_random_domains(count, retry-1)
 
+# not used
+
 
 def is_domain_support_tls_13(domain):
     context = ssl.create_default_context()
+    port = 433
     with socket.create_connection((domain, port)) as sock:
         with context.wrap_socket(sock, server_hostname=domain) as ssock:
             return ssock.version() == "TLSv1.3"
@@ -693,8 +692,8 @@ def debug_flash_if_not_in_the_same_asn(domain):
             # country_ipv4= ipcountry.get(ipv4)
             # country_dip= ipcountry.get(dip)
             if asn_ipv4.get('autonomous_system_organization') != asn_dip.get('autonomous_system_organization'):
-                flash(_("selected domain for REALITY is not in the same ASN. To better use of the protocol, it is better to find a domain in the same ASN.") +
-                      f"<br> Server ASN={asn_ipv4.get('autonomous_system_organization','unknown')}<br>{domain}_ASN={asn_dip.get('autonomous_system_organization','unknown')}", "warning")
+                hutils.flask.flash(_("selected domain for REALITY is not in the same ASN. To better use of the protocol, it is better to find a domain in the same ASN.") +
+                                   f"<br> Server ASN={asn_ipv4.get('autonomous_system_organization','unknown')}<br>{domain}_ASN={asn_dip.get('autonomous_system_organization','unknown')}", "warning")
     except:
         pass
 
@@ -788,10 +787,10 @@ def get_ed25519_private_public_pair():
     return priv_bytes.decode(), pub_bytes.decode()
 
 
-def do_base_64(str):
-    import base64
-    resp = base64.b64encode(f'{str}'.encode("utf-8"))
-    return resp.decode()
+# def do_base_64(str):
+#     import base64
+#     resp = base64.b64encode(f'{str}'.encode("utf-8"))
+#     return resp.decode()
 
 
 def get_user_agent():
@@ -854,7 +853,6 @@ def __parse_user_agent(ua):
 
 def is_ssh_password_authentication_enabled():
     if os.path.isfile('/etc/ssh/sshd_config'):
-        content = ''
         with open('/etc/ssh/sshd_config', 'r') as f:
             for line in f.readlines():
                 line = line.strip()
@@ -876,7 +874,7 @@ def get_direct_host_or_ip(prefer_version: int):
     else:
         direct = hutils.ip.get_ip(prefer_version)
     if not direct:
-        direct = hutils.ip.get_ip(socket.AF_INET if prefer_version == socket.AF_INET6 else socket.AF_INET6)
+        direct = hutils.ip.get_ip(4 if prefer_version == 6 else 6)
     return direct
 
 

hiddifypanel/panel/importer/xui.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, List, Tuple
 import uuid as uuid_mod
 from datetime import datetime
 from dateutil.relativedelta import relativedelta
-import hiddifypanel.hutils.utils as utils
+from hiddifypanel import hutils
 from hiddifypanel.models.admin import AdminUser
 from hiddifypanel.models.user import User, UserMode
 from hiddifypanel.models.domain import Domain, DomainType
@@ -63,7 +63,7 @@ def __get_users(db, x_ui_inbounds):
 def __create_hiddify_user_from_xui_values(id: str, values: Dict[str, Any]) -> User:
     user = User()
     user.name = values['name']
-    user.uuid = id if utils.is_uuid_valid(id, 4) else uuid_mod.uuid4()
+    user.uuid = id if hutils.auth.is_uuid_valid(id, 4) else uuid_mod.uuid4()
 
     if str(values['expiry_time']) == '0':
         user.expiry_time = datetime.now() + relativedelta(years=10)

hiddifypanel/panel/init_db.py

@@ -12,7 +12,7 @@ from hiddifypanel import Events, hutils
 from hiddifypanel.models import *
 from hiddifypanel.panel import hiddify
 from hiddifypanel.panel.database import db
-from hiddifypanel.panel.hiddify import get_random_domains, get_random_string
+from hiddifypanel.panel.hiddify import get_random_domains
 import hiddifypanel.models.utils as model_utils
 
 MAX_DB_VERSION = 70
@@ -26,7 +26,12 @@ def init_db():
     hconfig.invalidate_all()
     get_hconfigs.invalidate_all()
     db_version = int(hconfig(ConfigEnum.db_version) or 0)
+    if db_version == latest_db_version():
+        return
+    execute("alter table user alter column telegram_id int;")
+    execute("alter table admin_user alter column telegram_id int;")
     add_column(User.lang)
+    add_column(AdminUser.lang)
     add_column(User.username)
     add_column(User.password)
     add_column(AdminUser.username)
@@ -34,8 +39,6 @@ def init_db():
 
     add_column(Domain.extra_params)
 
-    if db_version == latest_db_version():
-        return
     Events.db_prehook.notify()
     if db_version < 52:
         execute(f'update domain set mode="sub_link_only", sub_link_only=false where sub_link_only = true or mode=1  or mode="1"')
@@ -148,6 +151,22 @@ def init_db():
 #     add_config_if_not_exist(ConfigEnum.hysteria_enable, True)
 #     add_config_if_not_exist(ConfigEnum.hysteria_port, random.randint(5000, 20000))
 
+def _v67():
+    pass
+
+
+def _v65():
+    add_config_if_not_exist(ConfigEnum.mux_enable, False)
+    add_config_if_not_exist(ConfigEnum.mux_protocol, 'smux')
+    add_config_if_not_exist(ConfigEnum.mux_max_connections, '4')
+    add_config_if_not_exist(ConfigEnum.mux_min_streams, '4')
+    add_config_if_not_exist(ConfigEnum.mux_max_streams, '0')
+    add_config_if_not_exist(ConfigEnum.mux_padding_enable, False)
+    add_config_if_not_exist(ConfigEnum.mux_brutal_enable, True)
+    add_config_if_not_exist(ConfigEnum.mux_brutal_up_mbps, '100')
+    add_config_if_not_exist(ConfigEnum.mux_brutal_down_mbps, '100')
+
+
 def _v64():
     set_hconfig(ConfigEnum.ssh_server_redis_url, "unix:///opt/hiddify-manager/other/redis/run.sock?db=1")
 
@@ -175,8 +194,8 @@ def _v61():
 
 
 def _v60():
-    add_config_if_not_exist(ConfigEnum.proxy_path_admin, get_random_string())
-    add_config_if_not_exist(ConfigEnum.proxy_path_client, get_random_string())
+    add_config_if_not_exist(ConfigEnum.proxy_path_admin, hutils.random.get_random_string())
+    add_config_if_not_exist(ConfigEnum.proxy_path_client, hutils.random.get_random_string())
 
 
 def _v59():
@@ -342,13 +361,13 @@ def _v20():
 
 
 def _v19():
-    set_hconfig(ConfigEnum.path_trojan, get_random_string(7, 15))
-    set_hconfig(ConfigEnum.path_vless, get_random_string(7, 15))
-    set_hconfig(ConfigEnum.path_vmess, get_random_string(7, 15))
-    set_hconfig(ConfigEnum.path_ss, get_random_string(7, 15))
-    set_hconfig(ConfigEnum.path_grpc, get_random_string(7, 15))
-    set_hconfig(ConfigEnum.path_tcp, get_random_string(7, 15))
-    set_hconfig(ConfigEnum.path_ws, get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_trojan, hutils.random.get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_vless, hutils.random.get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_vmess, hutils.random.get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_ss, hutils.random.get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_grpc, hutils.random.get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_tcp, hutils.random.get_random_string(7, 15))
+    set_hconfig(ConfigEnum.path_ws, hutils.random.get_random_string(7, 15))
     add_config_if_not_exist(ConfigEnum.tuic_enable, False)
     add_config_if_not_exist(ConfigEnum.shadowtls_enable, False)
     add_config_if_not_exist(ConfigEnum.shadowtls_fakedomain, "en.wikipedia.org")
@@ -383,7 +402,7 @@ def _v1():
         StrConfig(key=ConfigEnum.tls_ports, value="443"),
         BoolConfig(key=ConfigEnum.first_setup, value=True),
         StrConfig(key=ConfigEnum.decoy_domain, value=hiddify.get_random_decoy_domain()),
-        StrConfig(key=ConfigEnum.proxy_path, value=get_random_string()),
+        StrConfig(key=ConfigEnum.proxy_path, value=hutils.random.get_random_string()),
         BoolConfig(key=ConfigEnum.firewall, value=False),
         BoolConfig(key=ConfigEnum.netdata, value=True),
         StrConfig(key=ConfigEnum.lang, value='en'),

hiddifypanel/panel/usage.py

@@ -19,6 +19,7 @@ def update_local_usage():
 
 
 def add_users_usage_uuid(uuids_bytes, child_id):
+    # WHAT IS THE "keys" function WHY ?????
     users = User.query.filter(User.uuid.in_(keys(uuids_bytes)))
     dbusers_bytes = {u: uuids_bytes.get(u.uuid, 0) for u in users}
     add_users_usage(dbusers_bytes, child_id)
@@ -100,6 +101,6 @@ def send_bot_message(user):
     try:
         msg = Usage.get_usage_msg(user.uuid)
         msg = _("User activated!") if user.is_active else _("Package ended!")+"\n"+msg
-        bot.send_message(user.telegram_id, msg, reply_markup=Usage.user_keyboard(uuid))
+        bot.send_message(user.telegram_id, msg, reply_markup=Usage.user_keyboard(user.uuid))
     except:
         pass

hiddifypanel/panel/user/link_maker.py

@@ -1,5 +1,5 @@
 from flask import g, request, render_template
-from ipaddress import IPv4Address, IPv4Address
+from ipaddress import IPv4Address, IPv6Address
 import enum
 from hiddifypanel import hutils
 from hiddifypanel.models import *
@@ -235,7 +235,7 @@ def to_link(proxy):
     if 'error' in proxy:
         return proxy
     orig_name_link = (proxy['extra_info'] + " " + proxy["name"]).strip()
-    name_link = hiddify.url_encode(orig_name_link)
+    name_link = hutils.encode.url_encode(orig_name_link)
     if proxy['proto'] == 'vmess':
         # print(proxy)
         vmess_type = None
@@ -264,12 +264,18 @@ def to_link(proxy):
             vmess_data['pbk'] = proxy['reality_pbk']
             vmess_data['sid'] = proxy['reality_short_id']
 
-        return "vmess://" + hiddify.do_base_64(f'{json.dumps(vmess_data,cls=CustomEncoder)}')
+        if proxy['cdn'] and g.user_agent.get('is_hiddify'):
+            add_tls_tricks_to_dict(vmess_data)
+        add_mux_to_dict(vmess_data)
+
+        return "vmess://" + hutils.encode.do_base_64(f'{json.dumps(vmess_data,cls=CustomEncoder)}')
         # return pbase64(f'vmess://{json.dumps(vmess_data)}')
     if proxy['proto'] == 'ssh':
-        strenssh = hiddify.do_base_64(f'{proxy["uuid"]}:0:{proxy["private_key"]}::@{proxy["server"]}:{proxy["port"]}')
+        strenssh = hutils.encode.do_base_64(f'{proxy["uuid"]}:0:{proxy["private_key"]}::@{proxy["server"]}:{proxy["port"]}')
         baseurl = f'ssh://{strenssh}#{name_link}'
-        baseurl += f'\nssh://{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}/?pk='+hiddify.do_base_64(proxy["private_key"])+f"&hk={hiddify.get_hostkeys(True)}#{name_link}"
+        hk = hutils.encode.do_base_64(",".join(proxy["host_key"]))
+        pk = hutils.encode.do_base_64(proxy["private_key"])
+        baseurl += f'\nssh://{proxy["uuid"]}@{proxy["server"]}:{proxy["port"]}/?pk={pk}&hk={hk}#{name_link}'
 
         return baseurl
     if proxy['proto'] == "ssr":
@@ -298,6 +304,14 @@ def to_link(proxy):
     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
+
+    if proxy['proto'] in {'vless', 'trojan'}:
+        baseurl = add_mux_to_link(baseurl)
+        if proxy['cdn'] and g.user_agent.get('is_hiddify'):
+            baseurl = add_tls_tricks_to_link(baseurl)
+
     # 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 ""
@@ -329,6 +343,54 @@ def to_link(proxy):
         return f'{baseurl}&security=none{infos}'
     return proxy
 
+# region tls tricks & mux
+# notice: combining the functions into two function would make code less readable and difficult to maintain
+
+
+def add_tls_tricks_to_link(link: str) -> str:
+    if hconfig(ConfigEnum.tls_fragment_enable):
+        link += f'&fgsize={hconfig(ConfigEnum.tls_fragment_size)}&fgsleep={hconfig(ConfigEnum.tls_fragment_sleep)}'
+    if hconfig(ConfigEnum.tls_mixed_case):
+        link += '&mc=1'
+    if hconfig(ConfigEnum.tls_padding_enable):
+        link += f'&padsize={hconfig(ConfigEnum.tls_padding_length)}'
+    return link
+
+
+def add_mux_to_link(link: str) -> str:
+    if hconfig(ConfigEnum.mux_enable):
+        link += f'&mux={hconfig(ConfigEnum.mux_protocol)}&mux_max={hconfig(ConfigEnum.mux_max_connections)}&mux_min={hconfig(ConfigEnum.mux_min_streams)}&mux_pad={hconfig(ConfigEnum.mux_padding_enable)}'
+    if hconfig(ConfigEnum.mux_brutal_enable):
+        link += f'&mux_up={hconfig(ConfigEnum.mux_brutal_up_mbps)}&mux_down={hconfig(ConfigEnum.mux_brutal_down_mbps)}'
+    return link
+
+
+def add_tls_tricks_to_dict(d: dict):
+    if hconfig(ConfigEnum.tls_fragment_enable):
+        d['fgsize'] = hconfig(ConfigEnum.tls_fragment_size)
+        d['fgsleep'] = hconfig(ConfigEnum.tls_fragment_sleep)
+    if hconfig(ConfigEnum.tls_mixed_case):
+        d['mc'] = 1
+    if hconfig(ConfigEnum.tls_padding_enable):
+        d['padsize'] = hconfig(ConfigEnum.tls_padding_length)
+
+
+def add_mux_to_dict(d: dict):
+    if hconfig(ConfigEnum.mux_enable):
+        d['mux'] = hconfig(ConfigEnum.mux_protocol)
+        d['mux_max'] = hconfig(ConfigEnum.mux_max_connections)
+        d['mux_min'] = hconfig(ConfigEnum.mux_min_streams)
+        d['mux_pad'] = hconfig(ConfigEnum.mux_padding_enable)
+        # the hiddify next client doesn't support mux max streams
+        # vmess_data['mux_max_streams'] = hconfig(ConfigEnum.mux_max_streams)
+
+        # handle brutal tcp
+        if hconfig(ConfigEnum.mux_brutal_enable):
+            d['mux_up'] = hconfig(ConfigEnum.mux_brutal_up_mbps)
+            d['mux_down'] = hconfig(ConfigEnum.mux_brutal_down_mbps)
+
+# endregion
+
 
 def to_clash_yml(proxy):
     return yaml.dump(to_clash(proxy))
@@ -523,6 +585,9 @@ def to_singbox(proxy):
 
     add_singbox_tls(base, proxy)
 
+    if proxy['cdn'] and g.user_agent.get('is_hiddify') and proxy["proto"] in ['vmess', 'vless', 'trojan']:
+        add_singbox_tls_tricks(base)
+
     if proxy.get('flow'):
         base["flow"] = proxy['flow']
         # base["flow-show"] = True
@@ -567,15 +632,31 @@ def add_hysteria(base, proxy):
 
 
 def add_singbox_multiplex(base):
-    return
+    if not hconfig(ConfigEnum.mux_enable):
+        return
     base['multiplex'] = {
         "enabled": True,
-        "protocol": "h2mux",
-        "max_connections": 4,
-        "min_streams": 4,
-        "max_streams": 0,
-        "padding": false
+        "protocol": hconfig(ConfigEnum.mux_protocol),
+        "padding": hconfig(ConfigEnum.mux_padding_enable)
     }
+    # Conflicts: max_streams with max_connections and min_streams
+    mux_max_streams = int(hconfig(ConfigEnum.mux_max_streams))
+    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))
+
+    add_singbox_tcp_brutal(base)
+
+
+def add_singbox_tcp_brutal(base):
+    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))
+        }
 
 
 def add_singbox_udp_over_tcp(base):
@@ -611,6 +692,28 @@ def add_singbox_tls(base, proxy):
     # }
 
 
+def add_singbox_tls_tricks(base):
+    if hconfig(ConfigEnum.tls_fragment_enable):
+        base['tls_fragment'] = {
+            # 'enable': True,
+            'size': hconfig(ConfigEnum.tls_fragment_size),
+            'sleep': hconfig(ConfigEnum.tls_fragment_sleep)
+        }
+
+    tls_padding_enable = hconfig(ConfigEnum.tls_padding_enable)
+    tls_mixed_case = hconfig(ConfigEnum.tls_mixed_case)
+    if (tls_padding_enable or tls_mixed_case) and 'tls' not in base:
+        base['tls'] = {
+            'tls_tricks': {}
+        }
+    if hconfig(ConfigEnum.tls_padding_enable):
+        base['tls']['tls_tricks'] = {
+            'padding_size': hconfig(ConfigEnum.tls_padding_length)
+        }
+    if hconfig(ConfigEnum.tls_mixed_case):
+        base['tls']['tls_tricks']['mixedcase_sni'] = True
+
+
 def add_singbox_transport(base, proxy):
     if proxy['l3'] == 'reality' and proxy['transport'] not in ["grpc"]:
         return
@@ -769,7 +872,7 @@ def make_v2ray_configs(user, user_activate, domains, expire_days, ip_debug, db_d
             #     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#{hiddify.url_encode(profile_title)}')
+            # 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:
@@ -785,7 +888,7 @@ def make_v2ray_configs(user, user_activate, domains, expire_days, ip_debug, db_d
 
             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#{hiddify.url_encode(name)}')
+                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}')
@@ -793,9 +896,9 @@ def make_v2ray_configs(user, user_activate, domains, expire_days, ip_debug, db_d
     if not user_activate:
 
         if hconfig(ConfigEnum.lang) == 'fa':
-            res.append('trojan://1@1.1.1.1#'+hiddify.url_encode('✖بسته شما به پایان رسید'))
+            res.append('trojan://1@1.1.1.1#'+hutils.encode.url_encode('✖بسته شما به پایان رسید'))
         else:
-            res.append('trojan://1@1.1.1.1#'+hiddify.url_encode('✖Package_Ended'))
+            res.append('trojan://1@1.1.1.1#'+hutils.encode.url_encode('✖Package_Ended'))
         return "\n".join(res)
 
     for pinfo in get_all_validated_proxies(domains):

hiddifypanel/panel/user/templates/new.html

@@ -9,9 +9,11 @@
     <link rel="stylesheet" href="node_modules/smartbanner.js/dist/smartbanner.min.css">
     <link href="https://cdn.jsdelivr.net/gh/rastikerdar/vazirmatn@v33.003/Vazirmatn-font-face.css" rel="stylesheet" type="text/css" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-
+    <link rel="icon" type="image/x-icon" href="{{ static_url_for( filename='images/favicon.ico')}}">
+    <link rel="manifest" href="{{ url_for('common_bp.LoginView:create_pwa_manifest',secret_uuid=g.account.uuid or '')}}">
+    
     <title>Hiddify | Panel</title>
-    <script type="module" crossorigin src="../static/new/assets/index-bd9ba5e9.js"></script>
+    <script type="module" crossorigin src="../static/new/assets/index-2cd90979.js"></script>
     <link rel="stylesheet" href="../static/new/assets/index-d9bbf489.css">
   </head>
   <body>