tplinkrouterc6u 5.12.4__py3-none-any.whl → 5.14.0__py3-none-any.whl

tplinkrouterc6u/client/c3200.py

@@ -0,0 +1,198 @@
+import base64
+import re
+from time import sleep
+from urllib.parse import urlparse
+
+import requests
+from requests import Response
+
+from tplinkrouterc6u.client.mr200 import TPLinkMR200Client
+from tplinkrouterc6u.common.package_enum import VPN
+from tplinkrouterc6u.common.dataclass import (
+    LTEStatus,
+)
+from tplinkrouterc6u.common.exception import ClientException, ClientError
+from tplinkrouterc6u.common.package_enum import Connection
+
+
+class TplinkC3200Router(TPLinkMR200Client):
+    # This is a session variable that will contain everything needed as soon as the router is connected.
+    #  - The "Referer" header which allows to be accepted by the CGI module.
+    # - the Authentification cookie
+    SESSION: requests.Session
+
+    # Possible retries limit
+    REQUEST_RETRIES = 1
+
+    # Router name to be included in logs for example,
+    # or to be redefined by subclasses.
+    ROUTER_NAME = "TP Link Router C3200"
+
+    # Connection method
+    def supports(self) -> bool:
+        if len(self.password) > 125:
+            return False
+
+        try:
+            # This method checks if we can recognize the router type.
+            welcome_page = requests.get(self.host, timeout=5)
+            if welcome_page and welcome_page.status_code == 200 and re.search("Archer", welcome_page.text):
+                return True
+        except ClientException:
+            pass
+
+        return False
+
+    def authorize(self) -> None:
+
+        # ———————————————————————————————————————————
+        # Create the SESSION object and the authorization cookie
+        # ———————————————————————————————————————————
+        self.SESSION = requests.Session()
+
+        if self._logger:
+            self._logger.debug("!")
+        # We need to extract the domain form the host to fill the cookie.
+        router_host = urlparse(self.host).hostname
+        if not router_host:
+            raise ValueError(self.host & " must contain a valid host, ex. http://192.168.168.1")
+
+        """Return the string "Basic <base64(username:password)>"."""
+        token_bytes = f"{self.username}:{self.password}".encode()
+        encoded = base64.b64encode(token_bytes).decode()
+        auth_cookie_value = f"Basic {encoded}"
+
+        self.SESSION.cookies.set(
+            name="Authorization",
+            value=auth_cookie_value,
+            domain=router_host,
+            path="/",
+        )
+
+        self.SESSION.headers = {"Referer": f"{self.host}/", "Origin": self.host}
+
+        login_url = '{}/'.format(self.host)
+        response = Response()
+
+        try:
+            response = self.SESSION.post(login_url, timeout=10)
+        except Exception as e:
+            error = self.ROUTER_NAME + " - Cannot authorize! Error - {}; Response - {}".format(e, response.text)
+            if self._logger:
+                self._logger.debug(error)
+            raise ClientException(error)
+
+    def logout(self) -> None:
+        self.SESSION.cookies.clear(domain=urlparse(self.host).hostname, path="/")
+
+    def get_lte_status(self) -> LTEStatus:
+        pass
+
+    def _get_params(self, retry=False) -> None:
+        pass
+
+    def set_vpn(self, vpn: VPN, enable: bool) -> None:
+        # Unable to test it on my C3200
+        pass
+
+    def req_act(self, acts: list):
+        act_types, act_data = self._fill_acts(acts)
+
+        url = f"{self.host}/cgi?" + '&'.join(act_types)
+        data_str = ''.join(act_data)
+        (code, response) = self._request(url, data_str=data_str)
+
+        if code != 200:
+            error = self.ROUTER_NAME + ' -  Response with error; Request {} - Response {}'.format(data_str, response)
+            if self._logger:
+                self._logger.debug(error)
+            raise ClientError(error)
+
+        result = self._merge_response(response)
+
+        return response, result.get('0') if len(result) == 1 and result.get('0') else result
+
+    def _request(self, url, method='POST', data_str=None, encrypt=False, is_login=False):
+        r = Response()
+
+        retry = 0
+        while retry < self.REQUEST_RETRIES:
+            # send the request
+            if method == 'POST':
+                r = self.SESSION.post(url, data=data_str)
+            elif method == 'GET':
+                r = self.SESSION.get(url, data=data_str)
+            else:
+                raise Exception('Unsupported method ' + str(method))
+
+            # sometimes we get 500 here, not sure why... just retry the request
+            if (r.status_code not in [500, 406]
+                    and '<title>500 Internal Server Error</title>' not in r.text
+                    and '<title>406 Not Acceptable</title>' not in r.text):
+                break
+
+            sleep(0.1)
+            retry += 1
+
+        return r.status_code, r.text
+
+    # Overriding the method since we have two 5G bands in the rooter.
+    # We manage both as one.
+    def set_wifi(self, wifi: Connection, enable: bool) -> None:
+        acts = []
+
+        match wifi:
+            case Connection.HOST_2G:
+                acts = [
+                    self.ActItem(
+                        self.ActItem.SET,
+                        'LAN_WLAN',
+                        '1,1,0,0,0,0',
+                        attrs=['enable={}'.format(int(enable))]),
+                ]
+            case Connection.HOST_5G:
+                # We activate both 5G bands
+                acts = [
+                    self.ActItem(
+                        self.ActItem.SET,
+                        'LAN_WLAN',
+                        '1,2,0,0,0,0',
+                        attrs=['enable={}'.format(int(enable))]),
+                    self.ActItem(
+                        self.ActItem.SET,
+                        'LAN_WLAN',
+                        '1,3,0,0,0,0',
+                        attrs=['enable={}'.format(int(enable))]),
+                ]
+            case Connection.GUEST_2G:
+                acts = [
+                    self.ActItem(
+                        self.ActItem.SET,
+                        'LAN_WLAN_MSSIDENTRY',
+                        '1,1,1,0,0,0',
+                        attrs=['enable={}'.format(int(enable))]),
+                ]
+            case Connection.GUEST_5G:
+                acts = [
+                    self.ActItem(
+                        self.ActItem.SET,
+                        'LAN_WLAN_MSSIDENTRY',
+                        '1,2,1,0,0,0',
+                        attrs=['enable={}'.format(int(enable))]),
+                    self.ActItem(
+                        self.ActItem.SET,
+                        'LAN_WLAN_MSSIDENTRY',
+                        '1,3,1,0,0,0',
+                        attrs=['enable={}'.format(int(enable))]),
+                ]
+        self.req_act(acts)
+
+    def reboot(self) -> None:
+        # CGI 7 et [ACT_REBOOT#0,0,0,0,0,0#0,0,0,0,0,0]0,0
+
+        acts = [
+            self.ActItem(self.ActItem.OP, 'ACT_REBOOT'),
+        ]
+        _, values = self.req_act(acts)
+
+        # print(values.keys())

tplinkrouterc6u/client/c6u.py

@@ -490,3 +490,100 @@ class TplinkRouter(TplinkEncryption, TplinkBaseRouter):
         self._url_pptpd = 'admin/pptpd?form=config'
         self._url_vpnconn_openvpn = 'admin/vpnconn?form=config'
         self._url_vpnconn_pptpd = 'admin/vpnconn?form=config'
+
+
+class TplinkRouterV1_11(TplinkBaseRouter):
+    """
+    Router client for newer TP-Link firmware (1.11.0+) that uses simplified
+    RSA-only authentication without AES encryption wrapper.
+
+    Based on fix from: https://github.com/AlexandrErohin/TP-Link-Archer-C6U/issues/90
+    """
+
+    def __init__(self, host: str, password: str, username: str = 'admin', logger: Logger = None,
+                 verify_ssl: bool = True, timeout: int = 30) -> None:
+        super().__init__(host, password, username, logger, verify_ssl, timeout)
+        self._pwdNN = ''
+        self._pwdEE = ''
+
+    def supports(self) -> bool:
+        """Check if this client can handle the router (new firmware with RSA-only auth)."""
+        if len(self.password) > 125:
+            return False
+
+        try:
+            self._request_pwd()
+            # V1_11 uses 2048-bit RSA = 512 hex chars, older firmware uses 1024-bit = 256 chars
+            return len(self._pwdNN) >= 512
+        except Exception:
+            return False
+
+    def _request_pwd(self) -> None:
+        """Get RSA public key for password encryption."""
+        url = '{}/cgi-bin/luci/;stok=/login?form=keys'.format(self.host)
+
+        response = post(
+            url,
+            params={'operation': 'read'},
+            timeout=self.timeout,
+            verify=self._verify_ssl,
+        )
+
+        try:
+            data = response.json()
+            self._pwdNN = data[self._data_block]['password'][0]
+            self._pwdEE = data[self._data_block]['password'][1]
+        except Exception as e:
+            error = ('TplinkRouter - {} - Failed to get encryption keys! Error - {}; Response - {}'
+                     .format(self.__class__.__name__, e, response.text))
+            if self._logger:
+                self._logger.debug(error)
+            raise ClientException(error)
+
+    def authorize(self) -> None:
+        """Authorize using simplified RSA-only authentication (no AES encryption)."""
+        if self._pwdNN == '':
+            self._request_pwd()
+
+        # RSA encrypt password using existing utility
+        encrypted_pwd = EncryptionWrapper.rsa_encrypt(self.password, self._pwdNN, self._pwdEE)
+
+        # Simple login - just operation=login&password=<HEX>
+        url = '{}/cgi-bin/luci/;stok=/login?form=login'.format(self.host)
+        response = post(
+            url,
+            data='operation=login&password={}'.format(encrypted_pwd),
+            headers=self._headers_login,
+            timeout=self.timeout,
+            verify=self._verify_ssl,
+        )
+
+        try:
+            data = response.json()
+            if not data.get('success'):
+                error_info = data.get(self._data_block, {})
+                raise ClientException(
+                    'TplinkRouter - {} - Login failed: {}'.format(
+                        self.__class__.__name__,
+                        error_info.get('errorcode', 'unknown error')
+                    )
+                )
+
+            self._stok = data[self._data_block]['stok']
+
+            # Get sysauth cookie
+            if 'set-cookie' in response.headers:
+                regex_result = search(r'sysauth=([^;]+)', response.headers['set-cookie'])
+                if regex_result:
+                    self._sysauth = regex_result.group(1)
+
+            self._logged = True
+
+        except ClientException:
+            raise
+        except Exception as e:
+            error = ('TplinkRouter - {} - Cannot authorize! Error - {}; Response - {}'
+                     .format(self.__class__.__name__, e, response.text))
+            if self._logger:
+                self._logger.debug(error)
+            raise ClientException(error)

tplinkrouterc6u/client/ex.py

@@ -92,7 +92,7 @@ class TPLinkEXClient(TPLinkMRClientBase):
             self.ActItem(self.ActItem.GL, 'DEV2_ADT_LAN', attrs=['MACAddress', 'IPAddress']),
             self.ActItem(self.ActItem.GL, 'DEV2_ADT_WAN',
                          attrs=['enable', 'MACAddr', 'connIPv4Address', 'connIPv4Gateway']),
-            self.ActItem(self.ActItem.GL, 'DEV2_ADT_WIFI_COMMON', attrs=['primaryEnable', 'guestEnable']),
+            self.ActItem(self.ActItem.GL, 'DEV2_ADT_WIFI_COMMON'),
             self.ActItem(self.ActItem.GL, 'DEV2_HOST_ENTRY',
                          attrs=['active', 'X_TP_LanConnType', 'physAddress', 'IPAddress', 'hostName']),
             self.ActItem(self.ActItem.GO, 'DEV2_MEM_STATUS', attrs=['total', 'free']),
@@ -114,17 +114,17 @@ class TPLinkEXClient(TPLinkMRClientBase):
             status._wan_ipv4_addr = IPv4Address(item['connIPv4Address']) if item.get('connIPv4Address') else None
             status._wan_ipv4_gateway = IPv4Address(item['connIPv4Gateway']) if item.get('connIPv4Address') else None
 
-        if values[2].__class__ != list:
-            status.wifi_2g_enable = bool(int(values[2]['primaryEnable']))
-        else:
-            status.wifi_2g_enable = bool(int(values[2][0]['primaryEnable']))
-            status.wifi_5g_enable = bool(int(values[2][1]['primaryEnable']))
-
-        if values[2].__class__ != list:
-            status.guest_2g_enable = bool(int(values[2]['guestEnable']))
-        else:
-            status.guest_2g_enable = bool(int(values[2][0]['guestEnable']))
-            status.guest_5g_enable = bool(int(values[2][1]['guestEnable']))
+        if values[2]:
+            if values[2].__class__ != list:
+                status.wifi_2g_enable = bool(int(values[2]['primaryEnable']))
+                status.guest_2g_enable = bool(int(values[2]['guestEnable'])) if values[2].get('guestEnable') else None
+            else:
+                status.wifi_2g_enable = bool(int(values[2][0]['primaryEnable']))
+                status.wifi_5g_enable = bool(int(values[2][1]['primaryEnable']))
+                status.guest_2g_enable = bool(int(values[2][0]['guestEnable'])) \
+                    if values[2][0].get('guestEnable') else None
+                status.guest_5g_enable = bool(int(values[2][1]['guestEnable'])) \
+                    if values[2][1].get('guestEnable') else None
 
         devices = {}
         for val in self._to_list(values[3]):

tplinkrouterc6u/client/mr.py

@@ -2,7 +2,7 @@ from hashlib import md5
 from re import search
 from time import time, sleep
 from urllib.parse import quote
-from requests import Session
+from requests import Session, Response
 from datetime import timedelta, datetime
 from macaddress import EUI48
 from ipaddress import IPv4Address
@@ -23,6 +23,7 @@ from tplinkrouterc6u.common.dataclass import (
 )
 from tplinkrouterc6u.common.exception import ClientException, ClientError
 from tplinkrouterc6u.client_abstract import AbstractRouter
+from typing import List
 
 
 class TPLinkMRClientBase(AbstractRouter):
@@ -54,6 +55,10 @@ class TPLinkMRClientBase(AbstractRouter):
         Connection.GUEST_5G: '1,2,1,0,0,0',
     }
 
+    # Router name to be included in logs for example,
+    # or to be redefined by subclasses.
+    ROUTER_NAME = "TP Link Router MR"
+
     class ActItem:
         GET = 1
         SET = 2
@@ -65,7 +70,9 @@ class TPLinkMRClientBase(AbstractRouter):
         CGI = 8
 
         def __init__(self, type: int, oid: str, stack: str = '0,0,0,0,0,0', pstack: str = '0,0,0,0,0,0',
-                     attrs: list = []):
+                     attrs=None):
+            if attrs is None:
+                attrs = []
             self.type = type
             self.oid = oid
             self.stack = stack
@@ -111,6 +118,10 @@ class TPLinkMRClientBase(AbstractRouter):
         self._token = self._req_token()
         self._authorized_at = datetime.now()
 
+    # Fake implementation of all abstract methods
+    def logout(self) -> None:
+        pass
+
     def reboot(self) -> None:
         acts = [
             self.ActItem(self.ActItem.OP, 'ACT_REBOOT')
@@ -215,9 +226,9 @@ class TPLinkMRClientBase(AbstractRouter):
 
         return status
 
-    def get_ipv4_reservations(self) -> [IPv4Reservation]:
+    def get_ipv4_reservations(self) -> List[IPv4Reservation]:
         acts = [
-            self.ActItem(self.ActItem.GL, 'LAN_DHCP_STATIC_ADDR', attrs=['enable', 'chaddr', 'yiaddr']),
+            self.ActItem(self.ActItem.GL, 'LAN_DHCP_STATIC_ADDR'),
         ]
         _, values = self.req_act(acts)
 
@@ -227,13 +238,13 @@ class TPLinkMRClientBase(AbstractRouter):
                 IPv4Reservation(
                     EUI48(item['chaddr']),
                     IPv4Address(item['yiaddr']),
-                    '',
+                    item.get('description', ''),
                     bool(int(item['enable']))
                 ))
 
         return ipv4_reservations
 
-    def get_ipv4_dhcp_leases(self) -> [IPv4DHCPLease]:
+    def get_ipv4_dhcp_leases(self) -> List[IPv4DHCPLease]:
         acts = [
             self.ActItem(self.ActItem.GL, 'LAN_HOST_ENTRY', attrs=['IPAddress', 'MACAddress', 'hostName',
                                                                    'leaseTimeRemaining']),
@@ -324,12 +335,11 @@ class TPLinkMRClientBase(AbstractRouter):
 
         self.req_act(acts)
 
-    def req_act(self, acts: list):
-        '''
-        Requests ACTs via the cgi_gdpr proxy
-        '''
-        act_types = []
-        act_data = []
+    @staticmethod
+    def _fill_acts(acts: list) -> tuple[List[str], List[str]]:
+        # Fill the act lists, to refactor for other subclasses.
+        act_types: List[str] = []
+        act_data: List[str] = []
 
         for act in acts:
             act_types.append(str(act.type))
@@ -342,13 +352,18 @@ class TPLinkMRClientBase(AbstractRouter):
                 '\r\n'.join(act.attrs)
             ))
 
+        return act_types, act_data
+
+    def req_act(self, acts: list):
+        act_types, act_data = self._fill_acts(acts)
+
         data = '&'.join(act_types) + '\r\n' + ''.join(act_data)
 
         url = self._get_url('cgi_gdpr')
         (code, response) = self._request(url, data_str=data, encrypt=True)
 
         if code != 200:
-            error = 'TplinkRouter - MR -  Response with error; Request {} - Response {}'.format(data, response)
+            error = self.ROUTER_NAME + ' -  Response with error; Request {} - Response {}'.format(data, response)
             if self._logger:
                 self._logger.debug(error)
             raise ClientError(error)
@@ -391,7 +406,11 @@ class TPLinkMRClientBase(AbstractRouter):
 
         return result if result else []
 
-    def _get_url(self, endpoint: str, params: dict = {}, include_ts: bool = True) -> str:
+    def _get_url(self, endpoint: str, params: dict = None, include_ts: bool = True) -> str:
+        # check if there is any param
+        if params is None:
+            params = {}
+
         # add timestamp param
         if include_ts:
             params['_'] = str(round(time() * 1000))
@@ -410,14 +429,14 @@ class TPLinkMRClientBase(AbstractRouter):
         )
 
     def _req_token(self):
-        '''
+        """
         Requests the TokenID, used for CGI authentication (together with cookies)
             - token is inlined as JS var in the index (/) html page
               e.g.: <script type="text/javascript">var token="086724f57013f16e042e012becf825";</script>
 
         Return value:
             TokenID string
-        '''
+        """
         url = self._get_url('')
         (code, response) = self._request(url, method='GET')
         assert code == 200
@@ -430,12 +449,12 @@ class TPLinkMRClientBase(AbstractRouter):
         return result.group(1)
 
     def _req_rsa_key(self):
-        '''
+        """
         Requests the RSA public key from the host
 
         Return value:
             ((n, e), seq) tuple
-        '''
+        """
         response = ''
         try:
             url = self._get_url(self._url_rsa_key)
@@ -459,7 +478,7 @@ class TPLinkMRClientBase(AbstractRouter):
             assert seq.isnumeric()
 
         except Exception as e:
-            error = ('TplinkRouter - {} - Unknown error rsa_key! Error - {}; Response - {}'
+            error = (self.ROUTER_NAME + '- {} - Unknown error rsa_key! Error - {}; Response - {}'
                      .format(self.__class__.__name__, e, response))
             if self._logger:
                 self._logger.debug(error)
@@ -468,7 +487,7 @@ class TPLinkMRClientBase(AbstractRouter):
         return nn, ee, int(seq)
 
     def _req_login(self) -> None:
-        '''
+        """
         Authenticates to the host
             - sets the session token after successful login
             - data/signature is passed as a GET parameter, NOT as a raw request data
@@ -476,7 +495,7 @@ class TPLinkMRClientBase(AbstractRouter):
 
         Example session token (set as a cookie):
             {'JSESSIONID': '4d786fede0164d7613411c7b6ec61e'}
-        '''
+        """
         # encrypt username + password
 
         sign, data = self._prepare_data(self.username + '\n' + self.password, True)
@@ -501,12 +520,12 @@ class TPLinkMRClientBase(AbstractRouter):
             info = search('var currAuthTimes=(.*);\nvar currForbidTime=(.*);', response)
             assert info is not None
 
-            error = 'TplinkRouter - MR - Login failed, wrong password. Auth times: {}/5, Forbid time: {}'.format(
+            error = self.ROUTER_NAME + ' - Login failed, wrong password. Auth times: {}/5, Forbid time: {}'.format(
                 info.group(1), info.group(2))
         elif ret_code == self.HTTP_ERR_USER_BAD_REQUEST:
-            error = 'TplinkRouter - MR - Login failed. Generic error code: {}'.format(ret_code)
+            error = self.ROUTER_NAME + ' - Login failed. Generic error code: {}'.format(ret_code)
         elif ret_code != self.HTTP_RET_OK:
-            error = 'TplinkRouter - MR - Login failed. Unknown error code: {}'.format(ret_code)
+            error = self.ROUTER_NAME + ' - Login failed. Unknown error code: {}'.format(ret_code)
 
         if error:
             if self._logger:
@@ -514,14 +533,14 @@ class TPLinkMRClientBase(AbstractRouter):
             raise ClientException(error)
 
     def _request(self, url, method='POST', data_str=None, encrypt=False, is_login=False):
-        '''
+        """
         Prepares and sends an HTTP request to the host
             - sets up the headers, handles token auth
             - encrypts/decrypts the data, if needed
 
         Return value:
             (status_code, response_text) tuple
-        '''
+        """
         headers = self.HEADERS
 
         # add referer to request headers,
@@ -541,6 +560,8 @@ class TPLinkMRClientBase(AbstractRouter):
             data = data_str
 
         retry = 0
+        r = Response()
+
         while retry < self.REQUEST_RETRIES:
             # send the request
             if method == 'POST':
@@ -566,12 +587,12 @@ class TPLinkMRClientBase(AbstractRouter):
             return r.status_code, r.text
 
     def _parse_ret_val(self, response_text):
-        '''
+        """
         Parses $.ret value from the response text
 
         Return value:
             return code (int)
-        '''
+        """
         result = search(r'\$\.ret=(.*);', response_text)
         assert result is not None
         assert result.group(1).isnumeric()
@@ -618,6 +639,8 @@ class TPLinkMRClientBaseGCM(TPLinkMRClientBase):
             data = data_str
 
         retry = 0
+        r = Response()
+
         while retry < self.REQUEST_RETRIES:
             # send the request
             if method == 'POST':
@@ -656,9 +679,9 @@ class TPLinkMRClientBaseGCM(TPLinkMRClientBase):
 class TPLinkMRClient(TPLinkMRClientBase):
 
     def logout(self) -> None:
-        '''
+        """
         Logs out from the host
-        '''
+        """
         if self._token is None:
             return
 
@@ -684,7 +707,7 @@ class TPLinkMRClient(TPLinkMRClientBase):
         ]
         self.req_act(acts)
 
-    def get_sms(self) -> [SMS]:
+    def get_sms(self) -> List[SMS]:
         acts = [
             self.ActItem(
                 self.ActItem.SET, 'LTE_SMS_RECVMSGBOX', attrs=['PageNumber=1']),

tplinkrouterc6u/client/mr200.py

@@ -57,7 +57,10 @@ class TPLinkMR200Client(TPLinkMRClient):
         ]
         _, values = self.req_act(acts)
 
-        status.ipsecvpn_enable = values.get('enable') == '1'
+        if len(values) == 0:
+            status.ipsecvpn_enable = False
+        else:
+            status.ipsecvpn_enable = values.get('enable') == '1'
 
         return status