hiddifypanel 10.30.8.dev1__py3-none-any.whl → 10.30.9.dev1__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-10.30.8.dev1
+10.30.9.dev1

hiddifypanel/VERSION.py

@@ -1,3 +1,3 @@
-__version__='10.30.8.dev1'
+__version__='10.30.9.dev1'
 from datetime import datetime
-__release_date__= datetime.strptime('2024-07-10','%Y-%m-%d')
+__release_date__= datetime.strptime('2024-07-13','%Y-%m-%d')

hiddifypanel/cache.py

@@ -1,4 +1,4 @@
-from redis_cache import RedisCache, chunks
+from redis_cache import RedisCache, chunks, compact_dump
 import redis
 from pickle import dumps, loads
 from loguru import logger
@@ -7,11 +7,21 @@ redis_client = redis.from_url('unix:///opt/hiddify-manager/other/redis/run.sock?
 
 
 class CustomRedisCache(RedisCache):
+    def __init__(self, redis_client, prefix="rc", serializer=compact_dump, deserializer=loads, key_serializer=None, support_cluster=True, exception_handler=None):
+        super().__init__(redis_client, prefix, serializer, deserializer, key_serializer, support_cluster, exception_handler)
+        self.cached_functions = set()
+
+    def cache(self, ttl=0, limit=0, namespace=None, exception_handler=None):
+        res = super().cache(ttl, limit, namespace, exception_handler)
+        self.cached_functions.add(res)
+        return res
 
     def invalidate_all_cached_functions(self):
         try:
+            for f in self.cached_functions:
+                f.invalidate_all()
             logger.trace("Invalidating all cached functions")
-            chunks_gen = chunks(f'{self.prefix}*', 500)
+            chunks_gen = chunks(f'{self.prefix}*', 5000)
             for keys in chunks_gen:
                 self.client.delete(*keys)
             logger.trace("Successfully invalidated all cached functions")
@@ -22,4 +32,4 @@ class CustomRedisCache(RedisCache):
             return False
 
 
-cache = CustomRedisCache(redis_client=redis_client, prefix="h", serializer=dumps, deserializer=loads)
+cache = CustomRedisCache(redis_client=redis_client, prefix="h", serializer=dumps, deserializer=loads)

hiddifypanel/hutils/network/net.py

@@ -1,4 +1,4 @@
-from typing import List, Literal, Union
+from typing import List, Literal, Set, Union
 from urllib.parse import urlparse
 import urllib.request
 import ipaddress
@@ -33,17 +33,43 @@ def get_domain_ip(domain: str, retry: int = 3, version: Literal[4, 6] | None = N
 
     if not res and version != 4:
         try:
-            res = f"[{socket.getaddrinfo(domain, None, socket.AF_INET6)[0][4][0]}]"
-
-            res = res[1:-1]
+            res = f"{socket.getaddrinfo(domain, None, socket.AF_INET6)[0][4][0]}"
 
         except BaseException:
             pass
 
-    if retry <= 0 or not res:
+    if retry <= 0:
         return None
+    if not res:
+        return get_domain_ip(domain, retry=retry - 1, version=version)
+
+    return ipaddress.ip_address(res)
+
+
+def get_domain_ips(domain: str, retry: int = 3) -> Set[Union[ipaddress.IPv4Address, ipaddress.IPv6Address]]:
+    res = set()
+    if retry < 0:
+        return res
+    try:
+        _, _, ips = socket.gethostbyname_ex(domain)
+        for ip in ips:
+            res.add(ipaddress.ip_address(ip))
+    except Exception:
+        pass
+
+    try:
+        for ip in socket.getaddrinfo(domain, None, socket.AF_INET):
+            res.add(ipaddress.ip_address(ip[4][0]))
+    except BaseException:
+        pass
+
+    try:
+        for ip in socket.getaddrinfo(domain, None, socket.AF_INET6):
+            res.add(ipaddress.ip_address(ip[4][0]))
+    except BaseException:
+        pass
 
-    return ipaddress.ip_address(res) or get_domain_ip(domain, retry=retry - 1) if res else None
+    return res or get_domain_ips(domain, retry=retry - 1)
 
 
 def get_socket_public_ip(version: Literal[4, 6]) -> Union[ipaddress.IPv4Address, ipaddress.IPv6Address, None]:
@@ -85,8 +111,11 @@ def get_interface_public_ip(version: Literal[4, 6]) -> List[Union[ipaddress.IPv4
 
 
 @cache.cache(ttl=600)
-def get_ips(version: Literal[4, 6]) -> List[Union[ipaddress.IPv4Address, ipaddress.IPv6Address]]:
+def get_ips(version: Literal[4, 6] | None = None) -> List[Union[ipaddress.IPv4Address, ipaddress.IPv6Address]]:
+    if not version:
+        return [*get_ips(4), *get_ips(6)]
     addrs = []
+
     i_ips = get_interface_public_ip(version)
     if i_ips:
         addrs = i_ips
@@ -136,6 +165,7 @@ def get_ip(version: Literal[4, 6], retry: int = 5) -> ipaddress.IPv4Address | ip
         ip = get_ip(version, retry=retry - 1)
     return ip
 
+
 def get_random_domains(count: int = 1, retry: int = 3) -> List[str]:
     try:
         irurl = "https://api.ooni.io/api/v1/measurements?probe_cc=IR&test_name=web_connectivity&anomaly=false&confirmed=false&failure=false&order_by=test_start_time&limit=1000"
@@ -310,7 +340,7 @@ def is_in_same_asn(domain_or_ip: str, domain_or_ip_target: str) -> bool:
         print(f"An error occurred: {e}")
         return False
 
-        # 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.") +
+        # hutils.flask.flash(_("domain.reality.asn_issue") +
         #                    f"<br> Server ASN={asn_ipv4.get('autonomous_system_organization','unknown')}<br>{domain}_ASN={asn_dip.get('autonomous_system_organization','unknown')}", "warning")
 
 
@@ -342,8 +372,9 @@ def is_ip(input: str):
     except:
         return False
 
-def resolve_domain_with_api(domain:str) -> str:
+
+def resolve_domain_with_api(domain: str) -> str:
     if not domain:
         return ''
     endpoint = f'http://ip-api.com/json/{domain}?fields=query'
-    return str(requests.get(endpoint).json().get('query'))
+    return str(requests.get(endpoint).json().get('query'))

hiddifypanel/hutils/proxy/shared.py

@@ -130,7 +130,7 @@ def get_proxies(child_id: int = 0, only_enabled=False) -> list['Proxy']:
     if not hconfig(ConfigEnum.vmess_enable, child_id):
         proxies = [c for c in proxies if 'vmess' not in c.proto]
     if not hconfig(ConfigEnum.vless_enable, child_id):
-        proxies = [c for c in proxies if 'vless' not in c.proto]
+        proxies = [c for c in proxies if 'vless' not in c.proto or 'reality' in c.l3]
     if not hconfig(ConfigEnum.trojan_enable, child_id):
         proxies = [c for c in proxies if 'trojan' not in c.proto]
     if not hconfig(ConfigEnum.httpupgrade_enable, child_id):

hiddifypanel/hutils/proxy/xrayjson.py

@@ -223,8 +223,10 @@ def add_stream_settings(base: dict, proxy: dict):
     # THE CURRENT CODE WORKS BUT THE CORRECT CONDITINO SHOULD BE THIS:
     # ss['security'] == 'tls' or 'xtls' -----> ss['security'] in ['tls','xtls']
     # TODO: FIX THE CONDITION AND TEST CONFIGS ON THE CLIENT SIDE
-
-    if ss['security'] == 'tls' or 'xtls' and proxy['proto'] != ProxyProto.ss:
+    if ss['security'] == 'reality':
+        ss['network'] = proxy['transport']
+        add_reality_stream(ss, proxy)
+    elif ss['security'] == 'tls' or 'xtls' and proxy['proto'] != ProxyProto.ss:
         ss['tlsSettings'] = {
             'serverName': proxy['sni'],
             'allowInsecure': proxy['allow_insecure'],
@@ -239,9 +241,7 @@ def add_stream_settings(base: dict, proxy: dict):
             # 'cipherSuites': '', # Go lang sets
             # 'rejectUnknownSni': '', # default is false
         }
-    if ss['security'] == 'reality':
-        ss['network'] = proxy['transport']
-        add_reality_stream(ss, proxy)
+
     if proxy['l3'] == ProxyL3.kcp:
         ss['network'] = 'kcp'
         add_kcp_stream(ss, proxy)
@@ -249,7 +249,7 @@ def add_stream_settings(base: dict, proxy: dict):
     if proxy['l3'] == ProxyL3.h3_quic:
         add_quic_stream(ss, proxy)
 
-    if proxy['transport'] == 'tcp' or ss['security'] == 'reality' or (ss['security'] == 'none' and proxy['transport'] not in [ProxyTransport.httpupgrade, ProxyTransport.WS] and proxy['proto'] != ProxyProto.ss):
+    if (proxy['transport'] == 'tcp' and ss['security'] != 'reality') or (ss['security'] == 'none' and proxy['transport'] not in [ProxyTransport.httpupgrade, ProxyTransport.WS] and proxy['proto'] != ProxyProto.ss):
         ss['network'] = proxy['transport']
         add_tcp_stream(ss, proxy)
     if proxy['transport'] == ProxyTransport.h2 and ss['security'] == 'none' and ss['security'] != 'reality':

hiddifypanel/models/config_enum.py

@@ -243,8 +243,8 @@ class ConfigEnum(metaclass=FastEnum):
     trojan_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
     reality_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
     tcp_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
-    quic_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
-    xtls_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
+    quic_enable = _BoolConfigDscr(ConfigCategory.hidden, ApplyMode.apply)
+    xtls_enable = _BoolConfigDscr(ConfigCategory.hidden, ApplyMode.apply)
     h2_enable = _BoolConfigDscr(ConfigCategory.proxies, ApplyMode.apply)
 
     db_version = _StrConfigDscr(ConfigCategory.hidden, ApplyMode.apply)

hiddifypanel/models/domain.py

@@ -38,7 +38,7 @@ ShowDomain = db.Table('show_domain',
 class Domain(db.Model, SerializerMixin):
     id = db.Column(db.Integer, primary_key=True, autoincrement=True)
     child_id = db.Column(db.Integer, db.ForeignKey('child.id'), default=0)
-    domain = db.Column(db.String(200), nullable=False, unique=False)
+    domain = db.Column(db.String(200), nullable=True, unique=False)
     alias = db.Column(db.String(200))
     sub_link_only = db.Column(db.Boolean, nullable=False, default=False)
     mode = db.Column(db.Enum(DomainType), nullable=False, default=DomainType.direct)

hiddifypanel/models/user.py

@@ -290,7 +290,7 @@ class User(BaseAccount, SerializerMixin):
         return schema.dump(User())
 
     def to_schema(self):
-        user_dict = self.to_dict()
+        user_dict = self.to_dict(dump_id=True)
         from hiddifypanel.panel.commercial.restapi.v2.admin.user_api import UserSchema
         return UserSchema().load(user_dict)
 
@@ -317,7 +317,8 @@ class User(BaseAccount, SerializerMixin):
                 'wg_pk': self.wg_pk,
                 'wg_pub': self.wg_pub,
                 'wg_psk': self.wg_psk,
-                'is_active': self.is_active
+                'is_active': self.is_active,
+                'enable': self.enable
                 }
 
     # @staticmethod

hiddifypanel/panel/admin/Actions.py

@@ -65,7 +65,7 @@ class Actions(FlaskView):
         domain_changed = request.args.get("domain_changed", str(domain_changed)).lower() == "true"
         complete_install = request.args.get("complete_install", str(complete_install)).lower() == "true"
         if domain_changed:
-            hutils.flask.flash((_('Your domains changed. Please do not forget to copy admin links, otherwise you can not access to the panel anymore.')), 'info')
+            hutils.flask.flash((_('domain.changed_in_domain_warning')), 'info')
         # hutils.flask.flash(f'complete_install={complete_install} domain_changed={domain_changed} ', 'info')
         # return render_template("result.html")
         # hiddify.add_temporary_access()
@@ -87,7 +87,7 @@ class Actions(FlaskView):
 
         resp = render_template("result.html",
                                out_type="info",
-                               out_msg=_("Success! Please wait around 4 minutes to make sure everything is updated. During this time, please save your proxy links which are:") +
+                               out_msg=_("admin.waiting_for_update") +
                                admin_links,
                                log_file_url=get_log_api_url(),
                                log_file="0-install.log",

hiddifypanel/panel/admin/AdminstratorAdmin.py

@@ -72,7 +72,7 @@ class AdminstratorAdmin(AdminLTEModelView):
 
     column_descriptions = dict(
         comment=_("Add some text that is only visible to super_admin."),
-        mode=_("Define the admin mode. "),
+        mode=_("admin.define_mode"),
     )
     # create_modal = True
     can_export = False

hiddifypanel/panel/admin/Dashboard.py

@@ -22,7 +22,7 @@ class Dashboard(FlaskView):
             return redirect(hurl_for("admin.QuickSetup:index"))
 
         if hutils.utils.is_panel_outdated():
-            hutils.flask.flash(_('This version of hiddify panel is outdated. Please update it from admin area.'), "danger")  # type: ignore
+            hutils.flask.flash(_('outdated_panel'), "danger")  # type: ignore
 
         childs = None
         admin_id = request.args.get("admin_id") or g.account.id
@@ -48,8 +48,7 @@ class Dashboard(FlaskView):
 
         if def_user and sslip_domains:
             quick_setup = hurl_for("admin.QuickSetup:index")
-            hutils.flask.flash((_('It seems that you have not setup the system completely. <a class="btn btn-success" href="%(quick_setup)s">Click here</a> to complete setup.',
-                                  quick_setup=quick_setup)), 'warning')  # type: ignore
+            hutils.flask.flash((_('admin.incomplete_setup_warning', quick_setup=quick_setup)), 'warning')  # type: ignore
             if hutils.node.is_parent():
                 hutils.flask.flash(
                     _("Please understand that parent panel is under test and the plan and the condition of use maybe change at anytime."), "danger")  # type: ignore
@@ -61,7 +60,7 @@ class Dashboard(FlaskView):
                     _("Please understand that parent panel is under test and the plan and the condition of use maybe change at anytime."), "danger")  # type: ignore
         elif def_user:
             d = domains[0]
-            hutils.flask.flash((_('It seems that you have not created any users yet. Default user link: %(default_link)s',
+            hutils.flask.flash((_("admin.no_user_warning",
                                default_link=hiddify.get_html_user_link(def_user, d))), 'secondary')  # type: ignore
         if hutils.network.is_ssh_password_authentication_enabled():
             hutils.flask.flash(_('serverssh.password-login.warning'), "warning")  # type: ignore

hiddifypanel/panel/admin/DomainAdmin.py

@@ -46,11 +46,11 @@ class DomainAdmin(AdminLTEModelView):
         mode=_("Direct mode means you want to use your server directly (for usual use), CDN means that you use your server on behind of a CDN provider."),
         cdn_ip=_("config.cdn_forced_host.description"),
         show_domains=_(
-            'You can select the configs with which domains show be shown in the user area. If you select all, automatically, all the new domains will be added for each users.'),
+            'domain.show_domains_description'),
         alias=_('The name shown in the configs for this domain.'),
         servernames=_('config.reality_server_names.description'),
         sub_link_only=_('This can be used for giving your users a permanent non blockable links.'),
-        grpc=_('gRPC is a H2 based protocol. Maybe it is faster for you!'))
+        grpc=_('grpc-proxy.description'))
 
     # create_modal = True
     can_export = False
@@ -65,7 +65,7 @@ class DomainAdmin(AdminLTEModelView):
         'domain': {
             'validators': [
                 Regexp(
-                    r'^(\*\.)?([A-Za-z0-9\-\.]+\.[a-zA-Z]{2,})$',
+                    r'^(\*\.)?([A-Za-z0-9\-\.]+\.[a-zA-Z]{2,})$|^$',
                     message=__("Should be a valid domain"))]},
         "cdn_ip": {
             'validators': [
@@ -109,21 +109,24 @@ class DomainAdmin(AdminLTEModelView):
             f'</a><a href="{admin_link}" class="btn btn-xs btn-info ltr" target="_blank">{model.domain}</a></div>')
 
     def _domain_ip(view, context, model, name):
-        dip = hutils.network.get_domain_ip(model.domain)
+        dips = hutils.network.get_domain_ips(model.domain)
         # The get_domain_ip function uses the socket library, which relies on the system DNS resolver. So it may sometimes use cached data, which is not desirable
-        if not dip:
-            dip = hutils.network.resolve_domain_with_api(model.domain)
-        myip = hutils.network.get_ip(4)
-        if myip == dip and model.mode in [DomainType.direct, DomainType.sub_link_only]:
-            badge_type = ''
-        elif dip and model.mode != DomainType.direct and myip != dip:
-            badge_type = 'warning'
-        else:
-            badge_type = 'danger'
-        res = f'<span class="badge badge-{badge_type}">{dip}</span>'
-        if model.sub_link_only:
-            res += f'<span class="badge badge-success">{_("SubLink")}</span>'
-        return Markup(res)
+        # if not dips:
+        #     dip = hutils.network.resolve_domain_with_api(model.domain)
+        myips = set(hutils.network.get_ips())
+        all_res = ""
+        for dip in dips:
+            if dip in myips and model.mode in [DomainType.direct, DomainType.sub_link_only]:
+                badge_type = ''
+            elif dip and dip not in myips and model.mode != DomainType.direct:
+                badge_type = 'warning'
+            else:
+                badge_type = 'danger'
+            res = f'<span class="badge badge-{badge_type}">{dip}</span>'
+            if model.sub_link_only:
+                res += f'<span class="badge badge-success">{_("SubLink")}</span>'
+            all_res += res
+        return Markup(all_res)
 
     def _show_domains_formater(view, context, model, name):
         if not len(model.show_domains):
@@ -149,8 +152,9 @@ class DomainAdmin(AdminLTEModelView):
 
     # TODO: refactor this function
     def on_model_change(self, form, model, is_created):
-        model.domain = model.domain.lower()
-
+        model.domain = (model.domain or '').lower()
+        if model.domain == '' and model.mode != DomainType.fake:
+            raise ValidationError(_("domain.empty.allowed_for_fake_only"))
         configs = get_hconfigs()
         for c in configs:
             if "domain" in c and c not in [ConfigEnum.decoy_domain, ConfigEnum.reality_fallback_domain] and c.category != 'hidden':
@@ -174,7 +178,7 @@ class DomainAdmin(AdminLTEModelView):
         if "*" in model.domain and model.mode not in [DomainType.cdn, DomainType.auto_cdn_ip]:
             raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))
 
-        skip_check = "*" in model.domain
+        skip_check = "*" in model.domain or model.domain == ""
         if hconfig(ConfigEnum.cloudflare) and model.mode not in [DomainType.fake, DomainType.relay, DomainType.reality]:
             try:
                 proxied = model.mode in [DomainType.cdn, DomainType.auto_cdn_ip]
@@ -190,28 +194,30 @@ class DomainAdmin(AdminLTEModelView):
         #     hutils.flask.flash(__("Using alias with special charachters may cause problem in some clients like FairVPN."), 'warning')
             # raise ValidationError(_("You have to add your cloudflare api key to use this feature: "))
 
-        dip = hutils.network.get_domain_ip(model.domain)
+        dips = hutils.network.get_domain_ips(model.domain)
         if model.sub_link_only:
-            if dip is None:
+            if not dips:
                 raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))  # type: ignore
         elif not skip_check:
-            if dip is None:
+            if not dips:
                 raise ValidationError(_("Domain can not be resolved! there is a problem in your domain"))  # type: ignore
 
             domain_ip_is_same_as_panel = False
-            domain_ip_is_same_as_panel |= dip in ipv4_list
-            for ipv6 in ipv6_list:
-                domain_ip_is_same_as_panel |= ipaddress.ip_address(dip) == ipaddress.ip_address(ipv6)
+            server_ips = [*ipv4_list, *ipv6_list]
+            for mip in server_ips:
+                domain_ip_is_same_as_panel |= mip in dips
+            server_ips_str = ', '.join(list(map(str, server_ips)))
+            dips_str = ', '.join(list(map(str, dips)))
 
             if model.mode == DomainType.direct and not domain_ip_is_same_as_panel:
                 # hutils.flask.flash(__(f"Domain IP={dip} is not matched with your ip={', '.join(list(map(str, ipv4_list)))} which is required in direct mode"),category='error')
                 raise ValidationError(
-                    __("Domain IP=%(domain_ip)s is not matched with your ip=%(server_ip)s which is required in direct mode", server_ip=', '.join(list(map(str, ipv4_list))), domain_ip=dip))  # type: ignore
+                    __("Domain IP=%(domain_ip)s is not matched with your ip=%(server_ip)s which is required in direct mode", server_ip=server_ips_str, domain_ip=dips_str))  # type: ignore
 
             if domain_ip_is_same_as_panel and model.mode in [DomainType.cdn, DomainType.relay, DomainType.fake, DomainType.auto_cdn_ip]:
                 #     # hutils.flask.flash(__(f"In CDN mode, Domain IP={dip} should be different to your ip={', '.join(list(map(str, ipv4_list)))}"), 'warning')
                 raise ValidationError(__("In CDN mode, Domain IP=%(domain_ip)s should be different to your ip=%(server_ip)s",
-                                      server_ip=', '.join(list(map(str, ipv4_list))), domain_ip=dip))  # type: ignore
+                                      server_ip=server_ips_str, domain_ip=dips_str))  # type: ignore
 
             # if model.mode in [DomainType.ss_faketls, DomainType.telegram_faketls]:
             #     if len(Domain.query.filter(Domain.mode==model.mode and Domain.id!=model.id).all())>0:
@@ -219,10 +225,11 @@ class DomainAdmin(AdminLTEModelView):
 
         model.domain = model.domain.lower()
         if model.mode == DomainType.direct and model.cdn_ip:
+            model.cdn_ip = ""
             raise ValidationError(f"Specifying CDN IP is only valid for CDN mode")
 
         if model.mode == DomainType.fake and not model.cdn_ip:
-            model.cdn_ip = str(ipv4_list[0])
+            model.cdn_ip = str(server_ips[0])
 
         # if model.mode==DomainType.fake and model.cdn_ip!=myip:
         #     raise ValidationError(f"Specifying CDN IP is only valid for CDN mode")
@@ -230,8 +237,14 @@ class DomainAdmin(AdminLTEModelView):
         # # Update the many-to-many relationship
         if len(model.show_domains) == Domain.query.count():
             model.show_domains = []
-
-        if model.mode == DomainType.reality:
+        if model.mode == DomainType.old_xtls_direct:
+            if not hconfig(ConfigEnum.xtls_enable):
+                set_hconfig(ConfigEnum.xtls_enable, True)
+                hutils.proxy.get_proxies().invalidate_all()
+        elif model.mode == DomainType.reality:
+            if not hconfig(ConfigEnum.reality_enable):
+                set_hconfig(ConfigEnum.reality_enable, True)
+                hutils.proxy.get_proxies().invalidate_all()
             model.servernames = (model.servernames or model.domain).lower()
             for v in set([model.domain, model.servernames]):
                 for d in v.split(","):
@@ -240,10 +253,10 @@ class DomainAdmin(AdminLTEModelView):
                     if not hutils.network.is_domain_reality_friendly(d):  # the minimum requirement for the REALITY protocol is to have tls1.3 and h2
                         raise ValidationError(_("Domain is not REALITY friendly!") + f' {d}')
 
-                    if not hutils.network.is_in_same_asn(d, ipv4_list[0]):
-                        server_asn = hutils.network.get_ip_asn(ipv4_list[0])
-                        domain_asn = hutils.network.get_ip_asn(dip)  # type: ignore
-                        msg = _("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.") + \
+                    if not hutils.network.is_in_same_asn(d, server_ips[0]):
+                        server_asn = hutils.network.get_ip_asn(server_ips[0])
+                        domain_asn = hutils.network.get_ip_asn(dips[0])  # type: ignore
+                        msg = _("domain.reality.asn_issue") + \
                             (f"<br> Server ASN={server_asn}<br>{d}_ASN={domain_asn}" if server_asn or domain_asn else "")
                         hutils.flask.flash(msg, 'warning')
 

hiddifypanel/panel/admin/ProxyAdmin.py

@@ -69,7 +69,7 @@ class ProxyAdmin(FlaskView):
 
 
 def get_global_config_form(empty=False):
-    boolconfigs = BoolConfig.query.all()
+    boolconfigs = BoolConfig.query.filter(BoolConfig.child_id == Child.current().id).all()
 
     class DynamicForm(FlaskForm):
         pass