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

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/user.py

@@ -1,19 +1,22 @@
+import user_agents
+import datetime
+import random
+import re
 
-from flask import redirect, render_template, request, Response, g, url_for, jsonify, flash
+from flask import render_template, request, Response, g
 from apiflask import abort
-from hiddifypanel.hutils import auto_ip_selector
-import datetime
-from hiddifypanel.models import *
-from hiddifypanel.panel.database import db
-from hiddifypanel.panel import hiddify
 from . import link_maker
 from flask_classful import FlaskView, route
-import random
 from urllib.parse import urlparse
-import user_agents
 from flask_babelex import gettext as _
-import re
+
+
 from hiddifypanel.panel.auth import login_required
+from hiddifypanel.hutils import auto_ip_selector
+from hiddifypanel.panel.database import db
+from hiddifypanel.panel import hiddify
+from hiddifypanel.models import *
+from hiddifypanel import hutils
 
 
 class UserView(FlaskView):
@@ -129,6 +132,9 @@ class UserView(FlaskView):
     @ route('/report', methods=["POST"])
     @login_required(roles={Role.user})
     def report(self):
+
+        # THE REPORT MODEL IS NOT COMPLETED YET.
+
         data = request.get_json()
         user_ip = auto_ip_selector.get_real_user_ip()
         report = Report()
@@ -217,11 +223,11 @@ class UserView(FlaskView):
         if request.method == 'HEAD':
             resp = ""
         else:
-            # render_template('all_configs.txt', **c, base64=do_base_64)
+            # render_template('all_configs.txt', **c, base64=hutils.encode.do_base_64)
             resp = link_maker.make_v2ray_configs(**c)
 
         if base64:
-            resp = do_base_64(resp)
+            resp = hutils.encode.do_base_64(resp)
         return add_headers(resp, c)
 
     @ route("/offline.html")
@@ -236,10 +242,10 @@ class UserView(FlaskView):
         return ""
 
 
-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_common_data(user_uuid, mode, no_domain=False, filter_domain=None):
@@ -263,7 +269,7 @@ def get_common_data(user_uuid, mode, no_domain=False, filter_domain=None):
 
         if not db_domain:
             db_domain = DB(domain=domain, show_domains=[])
-            flash(_("This domain does not exist in the panel!" + domain))
+            hutils.flask.flash(_("This domain does not exist in the panel!" + domain))
 
         if mode == 'multi':
             domains = Domain.query.all()
@@ -301,7 +307,7 @@ def get_common_data(user_uuid, mode, no_domain=False, filter_domain=None):
                 d.cdn_ip, d.mode == DomainType.auto_cdn_ip, default_asn)
             # print("autocdn ip mode ", d.cdn_ip)
         if "*" in d.domain:
-            d.domain = d.domain.replace("*", hiddify.get_random_string(5, 15))
+            d.domain = d.domain.replace("*", hutils.random.get_random_string(5, 15))
 
     package_mode_dic = {
         UserMode.daily: 1,
@@ -354,7 +360,7 @@ def get_common_data(user_uuid, mode, no_domain=False, filter_domain=None):
         "asn": asn,
         "country": auto_ip_selector.get_country(user_ip),
         'has_auto_cdn': has_auto_cdn,
-        'profile_url': hiddify.get_account_panel_link(g.account if g.get('account') else user, domain)
+        'profile_url': hiddify.get_account_panel_link(user, domain)
     }
 
 
@@ -369,6 +375,6 @@ def add_headers(res, c):
     resp.headers['profile-update-interval'] = 1
     # resp.headers['content-disposition']=f'attachment; filename="{c["db_domain"].alias or c["db_domain"].domain} {c["user"].name}"'
 
-    resp.headers['profile-title'] = 'base64:'+do_base_64(c['profile_title'])
+    resp.headers['profile-title'] = 'base64:'+hutils.encode.do_base_64(c['profile_title'])
 
     return resp