hiddifypanel 10.10.20__py3-none-any.whl → 10.11.1__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-10.10.20
+10.11.1

hiddifypanel/VERSION.py

@@ -1,3 +1,3 @@
-__version__='10.10.20'
+__version__='10.11.1'
 from datetime import datetime
-__release_date__= datetime.strptime('2024-03-11','%Y-%m-%d')
+__release_date__= datetime.strptime('2024-03-16','%Y-%m-%d')

hiddifypanel/hutils/__init__.py

@@ -8,3 +8,6 @@ from . import random
 from . import encode
 from . import auth
 from . import utils
+from . import model
+from . import crypto
+from . import proxy

hiddifypanel/hutils/crypto.py

@@ -0,0 +1,29 @@
+import subprocess
+
+
+def get_ed25519_private_public_pair():
+    from cryptography.hazmat.primitives.asymmetric import ed25519
+    from cryptography.hazmat.primitives import serialization
+    privkey = ed25519.Ed25519PrivateKey.generate()
+    pubkey = privkey.public_key()
+    priv_bytes = privkey.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.OpenSSH,
+        encryption_algorithm=serialization.NoEncryption(),
+    )
+    pub_bytes = pubkey.public_bytes(
+        encoding=serialization.Encoding.OpenSSH,
+        format=serialization.PublicFormat.OpenSSH,
+    )
+    return priv_bytes.decode(), pub_bytes.decode()
+
+
+def get_wg_private_public_psk_pair():
+    try:
+        private_key = subprocess.run(["wg", "genkey"], capture_output=True, text=True, check=True).stdout.strip()
+        public_key = subprocess.run(["wg", "pubkey"], input=private_key, capture_output=True, text=True, check=True).stdout.strip()
+        psk = subprocess.run(["wg", "genpsk"], capture_output=True, text=True, check=True).stdout.strip()
+        return private_key, public_key, psk
+    except subprocess.CalledProcessError as e:
+        print(f"Error: {e}")
+        return None, None, None

hiddifypanel/hutils/encode.py

@@ -26,6 +26,10 @@ def is_valid_uuid(val: str, version: int | None = None) -> bool:
 
     return True
 
+
+def convert_dict_to_url(dict):
+    return '&' + '&'.join([f'{k}={v}' for k, v in dict.items()]) if len(dict) else ''
+
 # not used
 # def is_assci_alphanumeric(str):
 #     for c in str:

hiddifypanel/hutils/flask.py

@@ -233,6 +233,10 @@ def validate_domain_exist(form, field):
             _("Domain can not be resolved! there is a problem in your domain"))  # type: ignore
 
 
+def get_proxy_stats_url():
+    proxy_stats_url = f'{request.host_url}{g.proxy_path}/proxy-stats/'
+    params = f'hostname={proxy_stats_url}api/&port=443'
+    return f'{proxy_stats_url}?{params}/'
 # region not used
 
 

hiddifypanel/hutils/github_issue.py

@@ -12,7 +12,6 @@ from flask import g, request, render_template
 import hiddifypanel
 from hiddifypanel.models.config import hconfig
 from hiddifypanel.models.config_enum import ConfigEnum
-from hiddifypanel.auth import current_account
 
 
 class __IssueUrl:
@@ -136,6 +135,7 @@ def __github_issue_details() -> dict:
 
 
 def __remove_sensetive_data_from_github_issue_link(issue_link: str):
+    from hiddifypanel.auth import current_account
     if current_account.uuid:
         issue_link.replace(f'{current_account.uuid}', '*******************')
 

hiddifypanel/{models/utils.py → hutils/model.py}

@@ -1,6 +1,4 @@
-
-
-def fill_username(model) -> None:
+def gen_username(model) -> None:
     from hiddifypanel import hutils
     if model.username:
         return
@@ -19,8 +17,20 @@ def fill_username(model) -> None:
         model.username += rand_str
 
 
-def fill_password(model) -> None:
+def gen_password(model) -> None:
     from hiddifypanel import hutils
     # TODO: hash the password
     if not model.password or len(model.password) < 16:
         model.password = hutils.random.get_random_password(length=16)
+
+
+def gen_wg_keys(model) -> None:
+    from hiddifypanel import hutils
+    if not model.wg_pk or not model.wg_pub or not model.wg_psk:
+        model.wg_pk, model.wg_pub, model.wg_psk = hutils.crypto.get_wg_private_public_psk_pair()
+
+
+def gen_ed25519_keys(model) -> None:
+    from hiddifypanel import hutils
+    if not model.ed25519_private_key or not model.ed25519_public_key:
+        model.ed25519_private_key, model.ed25519_public_key = hutils.crypto.get_ed25519_private_public_pair()

hiddifypanel/hutils/network/net.py

@@ -1,7 +1,8 @@
-from typing import List, Literal, Union
+from typing import List, Literal, Tuple, Union
 from urllib.parse import urlparse
 import urllib.request
 import ipaddress
+from hiddifypanel.hutils.network.auto_ip_selector import IPASN
 import netifaces
 import requests
 import random
@@ -16,7 +17,7 @@ from hiddifypanel.models import *
 from hiddifypanel.cache import cache
 
 
-def get_domain_ip(domain: str, retry: int = 3, version: Literal[4, 6] = None) -> Union[ipaddress.IPv4Address, ipaddress.IPv6Address, None]:
+def get_domain_ip(domain: str, retry: int = 3, version: Literal[4, 6] | None = None) -> Union[ipaddress.IPv4Address, ipaddress.IPv6Address, None]:
     res = None
     if not version:
         try:
@@ -326,3 +327,46 @@ def add_number_to_ipv6(ip: str, number: int) -> str:
     modified_ipv6 = ":".join(segments)
 
     return modified_ipv6
+
+
+def is_in_same_asn(domain_or_ip: str, domain_or_ip_target: str) -> bool:
+    '''Returns True if domain is in panel ASN'''
+    if not IPASN:
+        return False
+    try:
+        ip = domain_or_ip if is_ip(domain_or_ip) else get_domain_ip(domain_or_ip)
+        ip_target = domain_or_ip_target if is_ip(domain_or_ip_target) else get_domain_ip(domain_or_ip_target)
+
+        if not ip or not ip_target:
+            return False
+
+        ip_asn = get_ip_asn_name(ip)
+        ip_target_asn = get_ip_asn_name(ip_target)
+
+        if not ip_asn or not ip_target_asn:
+            return False
+
+        return ip_asn == ip_target_asn
+    except Exception as e:
+        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.") +
+        #                    f"<br> Server ASN={asn_ipv4.get('autonomous_system_organization','unknown')}<br>{domain}_ASN={asn_dip.get('autonomous_system_organization','unknown')}", "warning")
+
+
+def get_ip_asn_name(ip: ipaddress.IPv4Address | ipaddress.IPv6Address | str) -> str:
+    try:
+        if asn := IPASN.get(str(ip)):
+            return str(asn.get('autonomous_system_organization', ''))
+        return ''
+    except:
+        return ''
+
+
+def is_ip(input: str):
+    try:
+        _ = ipaddress.ip_address(input)
+        return True
+    except:
+        return False

hiddifypanel/hutils/proxy/__init__.py

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

hiddifypanel/hutils/proxy/clash.py

@@ -0,0 +1,161 @@
+import yaml
+from hiddifypanel.models import Proxy, ProxyCDN, ProxyL3, ProxyProto, ProxyTransport, Domain
+from hiddifypanel import hutils
+
+
+def get_clash_config_names(meta_or_normal, domains: list[Domain]):
+    allp = []
+    for pinfo in hutils.proxy.get_valid_proxies(domains):
+        clash = to_clash(pinfo, meta_or_normal)
+        if 'msg' not in clash:
+            allp.append(clash['name'])
+
+    return yaml.dump(allp, sort_keys=False)
+
+
+def get_all_clash_configs(meta_or_normal, domains: list[Domain]):
+    allp = []
+    for pinfo in hutils.proxy.get_valid_proxies(domains):
+        clash = to_clash(pinfo, meta_or_normal)
+        if 'msg' not in clash:
+            allp.append(clash)
+
+    return yaml.dump({"proxies": allp}, sort_keys=False)
+
+# def to_clash_yml(proxy):
+#     return yaml.dump(to_clash(proxy,'normal'))
+
+
+def to_clash(proxy, meta_or_normal):
+
+    name = proxy['name']
+    if proxy['l3'] == "kcp":
+        return {'name': name, 'msg': "clash does not support kcp", 'type': 'debug'}
+    if proxy['proto'] == "ssh":
+        return {'name': name, 'msg': "clash does not support ssh", 'type': 'debug'}
+    if meta_or_normal == "normal":
+        if proxy['proto'] in ["vless", 'tuic', 'hysteria2']:
+            return {'name': name, 'msg': f"{proxy['proto']} not supported in clash", 'type': 'debug'}
+        if proxy.get('flow'):
+            return {'name': name, 'msg': "xtls not supported in clash", 'type': 'debug'}
+        if proxy['transport'] == "shadowtls":
+            return {'name': name, 'msg': "shadowtls not supported in clash", 'type': 'debug'}
+    if proxy['l3'] == ProxyL3.tls_h2 and proxy['proto'] in [ProxyProto.vmess, ProxyProto.vless] and proxy['dbe'].cdn == ProxyCDN.direct:
+        return {'name': name, 'msg': "bug tls_h2 vmess and vless in clash meta", 'type': 'warning'}
+    base = {}
+    # vmess ws
+    base["name"] = f"""{proxy['extra_info']} {proxy["name"]} § {proxy['port']} {proxy["dbdomain"].id}"""
+    base["type"] = str(proxy["proto"])
+    base["server"] = proxy["server"]
+    base["port"] = proxy["port"]
+    base['alpn'] = proxy['alpn'].split(',')
+    if proxy["proto"] == "ssr":
+        base["cipher"] = proxy["cipher"]
+        base["password"] = proxy["uuid"]
+        base["udp"] = True
+        base["obfs"] = proxy["ssr-obfs"]
+        base["protocol"] = proxy["ssr-protocol"]
+        base["obfs-param"] = proxy["fakedomain"]
+        return base
+    elif proxy["proto"] == "tuic":
+        base["uuid"] = proxy["uuid"]
+        base["password"] = proxy["uuid"]
+        base["disable-sni"] = proxy['allow_insecure']
+        base["reduce-rtt"] = True
+        base["request-timeout"] = 8000
+        base["udp-relay-mode"] = 'native'
+        base["congestion-controller"] = 'cubic'
+        base['sni'] = proxy['sni']
+        return base
+    elif proxy["proto"] in ["ss", "v2ray"]:
+        base["cipher"] = proxy["cipher"]
+        base["password"] = proxy["password"]
+        base["udp_over_tcp"] = True
+        if proxy["transport"] == "faketls":
+            base["plugin"] = "obfs"
+            base["plugin-opts"] = {
+                "mode": 'tls',
+                "host": proxy["fakedomain"]
+            }
+        elif proxy["transport"] == "shadowtls":
+            base["plugin"] = "shadow-tls"
+            base["plugin-opts"] = {
+                "host": proxy["fakedomain"],
+                "password": proxy["proxy_path"],
+                "version": 3  # support 1/2/3
+
+            }
+
+        elif proxy["proto"] == "v2ray":
+            base["plugin"] = "v2ray-plugin"
+            base["type"] = "ss"
+            base["plugin-opts"] = {
+                "mode": "websocket",
+                "tls": "tls" in proxy["l3"],
+                "skip-cert-verify": proxy["mode"] == "Fake" or proxy['allow_insecure'],
+                "host": proxy['sni'],
+                "path": proxy["path"]
+            }
+        return base
+    elif proxy["proto"] == "trojan":
+        base["password"] = proxy["uuid"]
+        base["sni"] = proxy["sni"]
+
+    else:
+        base["uuid"] = proxy["uuid"]
+        base["servername"] = proxy["sni"]
+        base["tls"] = "tls" in proxy["l3"] or "reality" in proxy["l3"]
+    if meta_or_normal == "meta":
+        base['client-fingerprint'] = proxy['fingerprint']
+    if proxy.get('flow'):
+        base["flow"] = proxy['flow']
+        # base["flow-show"] = True
+
+    if proxy["proto"] == "vmess":
+        base["alterId"] = 0
+        base["cipher"] = proxy["cipher"]
+    base["udp"] = True
+
+    base["skip-cert-verify"] = proxy["mode"] == "Fake"
+
+    base["network"] = proxy["transport"]
+
+    if base["network"] == "ws":
+        base["ws-opts"] = {
+            "path": proxy["path"]
+        }
+        if "host" in proxy:
+            base["ws-opts"]["headers"] = {"Host": proxy["host"]}
+
+    if base["network"] == "tcp" and proxy['alpn'] != 'h2':
+        if proxy['transport'] != ProxyTransport.XTLS:
+            base["network"] = "http"
+
+        if "path" in proxy:
+            base["http-opts"] = {
+                "path": [proxy["path"]]
+            }
+            if 'host' in proxy:
+                base["http-opts"]["host"] = [proxy["host"]]
+    if base["network"] == "tcp" and proxy['alpn'] == 'h2':
+        base["network"] = "h2"
+
+        if "path" in proxy:
+            base["h2-opts"] = {
+                "path": proxy["path"]
+            }
+            if 'host' in proxy:
+                base["h2-opts"]["host"] = [proxy["host"]]
+    if base["network"] == "grpc":
+        base["grpc-opts"] = {
+            "grpc-service-name": proxy["grpc_service_name"]
+        }
+    if proxy['l3'] == ProxyL3.reality:
+        base["reality-opts"] = {
+            "public-key": proxy['reality_pbk'],
+            "short-id": proxy['reality_short_id'],
+        }
+        if proxy["transport"] != 'grpc':
+            base["network"] = 'tcp'
+
+    return base