zte-wrapper 1.0.0__py3-none-any.whl

zte_wrapper/authwrapper.py

@@ -0,0 +1,167 @@
+import logging
+import aiohttp
+from hashlib import sha256
+import urllib.parse
+import time
+import json
+from typing import Literal, Dict, Any, Tuple
+from copy import deepcopy
+
+logger = logging.getLogger("zte")
+
+GOFORM_COMMANDS = Literal["goform_get_cmd_process", "goform_set_cmd_process"]
+HEADERS = {
+    "Accept": "application/json, text/javascript, */*; q=0.01",
+    "Accept-Encoding": "gzip, deflate",
+    "Accept-Language": "en-US,en;q=0.5",
+    "Connection": "keep-alive",
+    "Host": "192.168.32.1",
+    "Referer": "http://192.168.32.1/",
+    "Sec-Gpc": "1",
+    "User-Agent": "Mozilla",
+    "X-Requested-With": "XMLHttpRequest",
+}
+
+
+def zte_sha256_string(input: str) -> str:
+    return sha256(input.encode("UTF-8")).hexdigest().upper()
+
+
+class ZTEAuthWrapper:
+    def __init__(self, webui_address: str, password: str) -> None:
+        self.address: str = webui_address
+        self.__password = zte_sha256_string(password)
+        self.__auth_code: str | None = None
+
+        self.headers = HEADERS
+        self.headers["Referer"] = f"http://{self.address}/"
+        self.headers["Host"] = self.address
+
+        self.session: aiohttp.ClientSession | None = None
+
+    def construct_url(self, command: GOFORM_COMMANDS, args: Dict[str, Any]) -> str:
+        base_url = f"http://{self.address}/goform/{command}/?"
+
+        url = base_url + urllib.parse.urlencode(
+            {k: urllib.parse.quote(str(v)) for k, v in args.items()}
+        )
+
+        logger.debug(f"Constructed url {url}")
+        return url
+
+    def get_timestamp(self) -> int:
+        return round(time.time() * 1000)
+
+    async def __get_ld(self) -> str:
+        async with aiohttp.ClientSession() as session:
+            res = await session.get(
+                self.construct_url(
+                    "goform_get_cmd_process",
+                    {"isTest": "false", "cmd": "LD", "_": self.get_timestamp()},
+                ),
+                headers=self.headers,
+            )
+
+            logger.info("Got LD token")
+            return json.loads((await res.text())).get(
+                "LD"
+            )  # json.loads instead of res.json() because the stupid API returns the stuff as text/html
+
+    async def __get_rd0_rd1(self) -> Tuple[str, str]:
+        res = await self.request(
+            "GET",
+            self.construct_url(
+                "goform_get_cmd_process",
+                {
+                    "isTest": "false",
+                    "cmd": "cr_version,wa_inner_version",
+                    "multi_data": "1",
+                },
+            ),
+        )
+        res_text = await res.text()
+        logger.debug(f"Retrieved rd0 and rd1: {res_text}")
+
+        data = json.loads(res_text)
+        return (data["wa_inner_version"], data["cr_version"])
+
+    async def __get_rd_token(self) -> str:
+        res = await self.request(
+            "GET",
+            self.construct_url(
+                "goform_get_cmd_process",
+                {"isTest": "false", "cmd": "RD", "_": self.get_timestamp()},
+            ),
+        )
+        logger.debug("")
+        return json.loads(await res.text())["RD"]
+
+    # please check notes/tokens.md if it breaks, it might help you a little
+    async def construct_ad_token(self) -> str:
+        rd0, rd1 = await self.__get_rd0_rd1()
+        first_step = zte_sha256_string(rd0 + rd1)
+        rd_token = await self.__get_rd_token()
+        return zte_sha256_string(first_step + rd_token)
+
+    async def refresh_auth(self) -> str:
+        ld_token: str = await self.__get_ld()
+        hashed_password: str = zte_sha256_string(self.__password + ld_token)
+
+        async with aiohttp.ClientSession() as session:
+            logger.debug("Refreshing authentication")
+            res = await session.post(
+                self.construct_url("goform_set_cmd_process", {}),
+                data={
+                    "isTest": "false",
+                    "goformId": "LOGIN",
+                    "password": hashed_password,
+                },
+                headers=self.headers,
+            )
+            self.__auth_code = str(res.cookies.get("stok"))
+
+        return self.__auth_code
+
+    async def confirm_auth(self) -> bool:
+        res = await self.request(
+            "GET",
+            self.construct_url(
+                "goform_get_cmd_process",
+                {"isTest": "false", "cmd": "date_month", "_": self.get_timestamp()},
+            ),
+            skip_auth_check=True,
+        )
+
+        result = bool(json.loads(await res.text())["date_month"])
+        logger.debug(f"Logged in? {result}")
+
+        return result
+
+    async def request(
+        self, method: Literal["GET", "POST"], *args, **kwargs
+    ) -> aiohttp.ClientResponse:
+        if not self.session:
+            self.session = aiohttp.ClientSession()
+
+        headers = deepcopy(self.headers)
+        headers["Cookie"] = f'stok="{self.__auth_code}"'
+
+        if kwargs.get("skip_auth_check"):
+            logger.debug("Skipping authentication checks...")
+            del kwargs["skip_auth_check"]
+        else:
+            if not await self.confirm_auth():
+                await self.refresh_auth()
+                headers["Cookie"] = f'stok="{self.__auth_code}"'
+
+        if method == "GET":
+            res = await self.session.get(*args, **kwargs, headers=headers)
+        elif method == "POST":
+            res = await self.session.post(*args, **kwargs, headers=headers)
+
+        return res
+
+    async def close(self) -> None:
+        logger.info("Closign aiohttp client")
+        if self.session:
+            await self.session.close()

zte_wrapper/helpers.py

@@ -0,0 +1,17 @@
+from datetime import datetime
+
+
+def utf_16_decode(inp: str) -> str:
+    return bytes.fromhex(inp).decode("utf-16-be")
+
+
+def utf_16_encode(inp: str) -> str:
+    return inp.encode("utf-16-be").hex().upper()
+
+
+def get_zte_timestring(timezone_offset: int) -> str:
+    now = datetime.now()
+
+    output = f"{str(now.year)[2:]};{now.month};{now.day};{now.hour+1};{now.minute};{now.second};+{timezone_offset}"
+
+    return output

zte_wrapper/types.py

@@ -0,0 +1,233 @@
+from dataclasses import dataclass
+from typing import List, Literal, TypedDict
+from datetime import datetime
+
+PhoneNumber = str
+RuleType = Literal["TCP"] | Literal["UDP"] | Literal["TCP&UDP"]
+InterfaceType = (
+    Literal["WIFI6"]
+    | Literal["WIFI1"]
+    | Literal["Ethernet"]
+    | Literal["WIFI"]
+    | Literal[""]
+)
+FirewallProtocolTarget = (
+    Literal["TCP"] | Literal["UDP"] | Literal["ICMP"] | Literal["ALL"]
+)
+FirewallAction = Literal["DROP"] | Literal["ACCEPT"]
+Hostname = TypedDict("Hostname", {"hostname": str, "mac": str})
+AutoOrManual = Literal["auto"] | Literal["manual"]
+
+
+class AuthError(Exception):
+    pass
+
+
+class PortRange:
+    start: int
+    end: int
+    iter: int
+
+    def __init__(self, start: int, end: int):
+        self.start = start
+        self.end = end
+
+    def __iter__(self):
+        self.iter = self.start
+        return self
+
+    def __next__(self):
+        if self.iter > self.end:
+            raise StopIteration
+
+        val = self.iter
+        self.iter += 1
+        return val
+
+
+@dataclass
+class SMSMessage:
+    content: str
+    tag: int
+    id: int
+
+
+@dataclass
+class SignalStrength:
+    sinr_5g: float
+    rsrp_5g: float
+    rsrq_5g: float
+    rssi_5g: float
+
+    band_5g: str
+    band_lte: str
+
+    pci_lte: float
+    rsrq_lte: float
+    rsrp_lte: float
+    rssi_lte: float
+    snr_lte: float
+
+
+@dataclass
+class NetworkDetails:
+    isp_name: str
+    download_mbps: float
+    upload_mbps: float
+    monthly_download_megabytes: float
+    monthly_upload_megabytes: float
+
+
+@dataclass
+class PortforwardingRule:
+    ip_addr: str
+    comment: str
+    port_start: int
+    port_end: int
+    protocol: RuleType
+
+
+@dataclass
+class PortforwardingTable:
+    gateway_addr: str
+    enabled: bool
+    rules_amount: int
+    rules: List[PortforwardingRule]
+
+
+@dataclass
+class PortmappingRule:
+    ip_addr: str
+    comment: str
+    port_external: int
+    port_internal: int
+    protocol: RuleType
+
+
+@dataclass
+class PortmappingTable:
+    gateway_addr: str
+    enabled: bool
+    rules_amount: int
+    rules: List[PortmappingRule]
+
+
+@dataclass
+class WirelessStation:  # basically a wireless device
+    addr_type: Literal["DHCP"] | str
+    connect_time: int
+    hostname: str
+    interface_type: InterfaceType
+    ip_address: str
+    mac_address: str
+    mac_bound: bool
+    ssid_index: int
+    wifi_rssi: int
+
+
+@dataclass
+class LanStation:
+    addr_type: Literal["Static"] | str
+    agreed_rate_mbps: int
+    connect_time: int
+    hostname: str
+    ip_address: str
+    mac_address: str
+    mac_bound: bool
+
+
+@dataclass
+class OfflineStation:
+    interface_type: InterfaceType
+    offline_time: datetime
+    start_time: datetime
+    start_time_t: datetime
+    hostname: str
+    ip_address: str
+    mac_address: str
+
+
+@dataclass
+class DDNSSettings:
+    provider: (
+        Literal["freedns.afraid.org"]
+        | Literal["dyndns.org"]
+        | Literal["zoneedit.org"]
+        | Literal["no-ip.com"]
+        | str
+    )
+    account_username: str
+    account_password: str
+    hash_value: str
+    mode: AutoOrManual
+    enabled: bool
+    domain: str
+
+
+@dataclass
+class MacBinding:
+    domain: str | Literal["(null)"]
+    hostname: str | Literal["(null)"]
+    ip: str
+    mac: str
+
+
+@dataclass
+class APNProfile:
+    data: str
+
+
+@dataclass
+class APNSettings:
+    apn_mode: AutoOrManual
+    profile_name: str
+    apn_wan_dial: str
+    apn_select: AutoOrManual
+    pdp_type: Literal["IP"] | str
+    pdp_select: AutoOrManual
+    pdp_address: str
+    index: int
+    wan_apn: str
+    ppp_auth_mode: str | Literal["none"]
+    ppp_username: str
+    ppp_password: str
+    dns_mode: AutoOrManual
+    prefer_dns_manual: str  # find later
+    standby_dns_manual: str  # find later x2
+    profiles: List[APNProfile]
+
+
+@dataclass
+class DHCPSettings:
+    enabled: bool
+    end_ip: str
+    start_ip: str
+    lease_time_hours: int
+    dhcp_type: Literal["SERVER"] | str
+    lan_ip_addr: str
+    lan_netmask: str
+    mac_addr: str
+    mtu: int
+    tcp_mss: int
+
+
+@dataclass
+class FirewallRule:
+    mac_addr: str
+    source_ip: str
+    dest_ip: str
+    protocol: FirewallProtocolTarget
+
+    source_port: PortRange
+    dest_port: PortRange
+
+    action: FirewallAction
+    comment: str
+
+
+@dataclass
+class FirewallConfig:
+    default_policy: FirewallAction
+    enabled: bool
+    rules_ipv4: List[FirewallRule]
+    rules_ipv6: List[FirewallRule]

zte_wrapper/wrapper.py

@@ -0,0 +1,83 @@
+import json
+from typing import Dict, List
+from datetime import datetime
+from .authwrapper import ZTEAuthWrapper
+from .wrappers import (
+    portforwarding,
+    sms,
+    signal,
+    devices,
+    portmapping,
+    ddns,
+    networktools,
+    bindings,
+    apn,
+    dhcp,
+    firewall,
+)
+from dataclasses import dataclass, asdict
+
+import logging
+
+logger = logging.getLogger("zte")
+
+
+class ZTEWrapper(ZTEAuthWrapper):
+    def __init__(self, webui_address: str, password: str) -> None:
+        super().__init__(webui_address, password)
+
+        self.portforwarding = portforwarding.PortforwardingWrapper(self)
+        self.portmapping = portmapping.PortmappingWrapper(self)
+        self.sms = sms.SmsWrapper(self)
+        self.signal = signal.SignalWrapper(self)
+        self.devices = devices.DeviceWrapper(self)
+        self.ddns = ddns.DDNSWrapper(self)
+        self.network_tools = networktools.NetworkToolWrapper(self)
+        self.bindings = bindings.BindingWrapper(self)
+        self.apn = apn.APNWrapper(self)
+        self.dhcp = dhcp.DHCPWrapper(self)
+        self.firewall = firewall.FirewallWrapper(self)
+
+    async def perform_dbg_query(self, items: List[str]) -> dict:
+        res = await self.request(
+            "GET",
+            self.construct_url(
+                "goform_get_cmd_process",
+                {"cmd": ",".join(items), "isTest": "false", "multi_data": "true"},
+            ),
+        )
+
+        txt = await res.text()
+        try:
+            data = json.loads(txt)
+            return data
+        except Exception as e:
+            print(txt)
+            print(e)
+            return {}
+
+    async def backup_settings(self) -> dict:
+        data = {}
+
+        logger.info("DDNS...")
+        data["ddns"] = await self.ddns.get_ddns_settings()
+
+        logger.info("Port forwarding...")
+        data["portforw"] = await self.portforwarding.get_port_forwarding_rules()
+
+        logger.info("Port Mapping...")
+        data["portmap"] = await self.portmapping.get_portmap_rules()
+
+        logger.info("Bindings...")
+        data["bindings"] = await self.bindings.get_mac_bindings()
+
+        logger.info("APN...")
+        data["apn"] = await self.apn.get_apn_settings()
+
+        logger.info("DHCP...")
+        data["dhcp"] = await self.dhcp.get_settings()
+
+        logger.info("Firewall...")
+        data["firewall"] = await self.firewall.get_config()
+
+        return data

zte_wrapper/wrappers/apn.py

@@ -0,0 +1,83 @@
+from ..authwrapper import ZTEAuthWrapper
+import json
+from ..types import APNSettings, APNProfile
+from typing import List
+
+
+class APNWrapper:
+    def __init__(self, auth: ZTEAuthWrapper):
+        self.auth = auth
+
+    async def get_apn_settings(self) -> APNSettings:
+        res = await self.auth.request(
+            "GET",
+            self.auth.construct_url(
+                "goform_get_cmd_process",
+                {
+                    "cmd": "apn_interface_version,APN_config0,APN_config1,APN_config2,APN_config3,APN_config4,APN_config5,APN_config6,APN_config7,APN_config8,APN_config9,APN_config10,APN_config11,APN_config12,APN_config13,APN_config14,APN_config15,APN_config16,APN_config17,APN_config18,APN_config19,ipv6_APN_config0,ipv6_APN_config1,ipv6_APN_config2,ipv6_APN_config3,ipv6_APN_config4,ipv6_APN_config5,ipv6_APN_config6,ipv6_APN_config7,ipv6_APN_config8,ipv6_APN_config9,ipv6_APN_config10,ipv6_APN_config11,ipv6_APN_config12,ipv6_APN_config13,ipv6_APN_config14,ipv6_APN_config15,ipv6_APN_config16,ipv6_APN_config17,ipv6_APN_config18,ipv6_APN_config19,apn_m_profile_name,profile_name,apn_wan_dial,apn_select,apn_pdp_type,apn_pdp_select,apn_pdp_addr,index,apn_Current_index,apn_auto_config,apn_ipv6_apn_auto_config,apn_mode,apn_wan_apn,apn_ppp_auth_mode,apn_ppp_username,apn_ppp_passwd,dns_mode,prefer_dns_manual,standby_dns_manual,apn_ipv6_wan_apn,apn_ipv6_pdp_type,apn_ipv6_ppp_auth_mode,apn_ipv6_ppp_username,apn_ipv6_ppp_passwd,ipv6_dns_mode,ipv6_prefer_dns_manual,ipv6_standby_dns_manual,apn_num_preset,wan_apn_ui,profile_name_ui,pdp_type_ui,ppp_auth_mode_ui,ppp_username_ui,ppp_passwd_ui,dns_mode_ui,prefer_dns_manual_ui,standby_dns_manual_ui,ipv6_wan_apn_ui,ipv6_ppp_auth_mode_ui,ipv6_ppp_username_ui,ipv6_ppp_passwd_ui,ipv6_dns_mode_ui,ipv6_prefer_dns_manual_ui,ipv6_standby_dns_manual_ui",
+                    "isTest": "false",
+                    "multi_data": "1",
+                },
+            ),
+        )
+
+        data: dict = json.loads(await res.text())
+        profiles: List[APNProfile] = []
+
+        for k, v in data.items():
+            k: str = k
+            v: str = v
+
+            if k.startswith("ipv6_APN_config") or k.startswith("APN_config"):
+                profiles.append(APNProfile(data=v))
+
+        settings = APNSettings(
+            apn_mode=data["apn_mode"],
+            apn_select=data["apn_select"],
+            apn_wan_dial="*99#",
+            dns_mode=data["dns_mode"],
+            pdp_address=data["apn_pdp_addr"],
+            pdp_select="auto",
+            pdp_type=data["apn_pdp_type"],
+            ppp_auth_mode=data["apn_ppp_auth_mode"],
+            ppp_password=data["apn_ppp_passwd"],
+            ppp_username=data["apn_ppp_username"],
+            prefer_dns_manual=data["prefer_dns_manual"],
+            profile_name=data["profile_name_ui"],
+            standby_dns_manual=data["standby_dns_manual"],
+            wan_apn=data["apn_wan_apn"],
+            index=int(data["apn_Current_index"]),
+            profiles=profiles,
+        )
+        return settings
+
+    async def set_apn_settings(self, settings: APNSettings) -> bool:
+        d = {
+            "isTest": "false",
+            "goformId": "APN_PROC_EX",
+            "apn_action": "save",
+            "apn_mode": settings.apn_mode,
+            "profile_name": settings.profile_name,
+            "apn_wan_dial": settings.apn_wan_dial,
+            "apn_select": settings.apn_select,
+            "apn_pdp_type": settings.pdp_type,
+            "apn_pdp_select": settings.pdp_select,
+            "apn_pdp_addr": settings.pdp_address,
+            "index": str(settings.index),
+            "apn_wan_apn": settings.wan_apn,
+            "apn_ppp_auth_mode": settings.ppp_auth_mode,
+            "apn_ppp_username": settings.ppp_username,
+            "apn_ppp_passwd": settings.ppp_password,
+            "dns_mode": settings.dns_mode,
+            "prefer_dns_manual": settings.prefer_dns_manual,
+            "standby_dns_manual": settings.standby_dns_manual,
+            "AD": await self.auth.construct_ad_token(),
+        }
+        res = await self.auth.request(
+            "POST",
+            self.auth.construct_url("goform_set_cmd_process", {}),
+            data=d,
+        )
+
+        data = json.loads(await res.text())
+        return data["result"] == "success"

zte_wrapper/wrappers/bindings.py

@@ -0,0 +1,67 @@
+from ..authwrapper import ZTEAuthWrapper
+import json
+from ..types import MacBinding
+from typing import List
+
+
+class BindingWrapper:
+    def __init__(self, auth: ZTEAuthWrapper):
+        self.auth = auth
+
+    async def get_mac_bindings(self) -> List[MacBinding]:
+        res = await self.auth.request(
+            "GET",
+            self.auth.construct_url(
+                "goform_get_cmd_process",
+                {
+                    "isTest": "false",
+                    "cmd": "current_static_addr_list",
+                },
+            ),
+        )
+
+        data: dict = json.loads(await res.text())
+        bindings: List[MacBinding] = []
+
+        for binding in data["current_static_addr_list"]:
+            bindings.append(
+                MacBinding(
+                    domain=binding["domain"],
+                    hostname=binding["hostname"],
+                    ip=binding["ip"],
+                    mac=binding["mac"],
+                )
+            )
+
+        return bindings
+
+    async def create_mac_binding(self, mac_address: str, ip: str) -> bool:
+        res = await self.auth.request(
+            "POST",
+            self.auth.construct_url("goform_set_cmd_process", {}),
+            data={
+                "isTest": "false",
+                "goformId": "BIND_STATIC_ADDRESS_ADD",
+                "mac_address": mac_address,
+                "ip_address": ip,
+                "AD": await self.auth.construct_ad_token(),
+            },
+        )
+
+        data = json.loads(await res.text())
+        return data["result"] == "success"
+
+    async def delete_mac_binding(self, mac_address: str) -> bool:
+        res = await self.auth.request(
+            "POST",
+            self.auth.construct_url("goform_set_cmd_process", {}),
+            data={
+                "isTest": "false",
+                "goformId": "BIND_STATIC_ADDRESS_DEL",
+                "mac_address": mac_address,
+                "AD": await self.auth.construct_ad_token(),
+            },
+        )
+
+        data = json.loads(await res.text())
+        return data["result"] == "success"