tplinkrouterc6u 5.11.0__py3-none-any.whl → 5.12.0__py3-none-any.whl

tplinkrouterc6u/__init__.py

@@ -1,9 +1,9 @@
 from tplinkrouterc6u.client.c6u import TplinkRouter
 from tplinkrouterc6u.client.deco import TPLinkDecoClient
 from tplinkrouterc6u.client_abstract import AbstractRouter
-from tplinkrouterc6u.client.mr import TPLinkMRClient
+from tplinkrouterc6u.client.mr import TPLinkMRClient, TPLinkMRClientGCM
 from tplinkrouterc6u.client.mr200 import TPLinkMR200Client
-from tplinkrouterc6u.client.ex import TPLinkEXClient
+from tplinkrouterc6u.client.ex import TPLinkEXClient, TPLinkEXClientGCM
 from tplinkrouterc6u.client.vr import TPLinkVRClient
 from tplinkrouterc6u.client.c80 import TplinkC80Router
 from tplinkrouterc6u.client.c5400x import TplinkC5400XRouter

tplinkrouterc6u/client/c80.py

@@ -1,12 +1,9 @@
 from dataclasses import dataclass
 from logging import Logger
 from urllib import parse
-from base64 import b64encode, b64decode
 from collections import defaultdict
 from ipaddress import IPv4Address
 import re
-from Crypto.Cipher import AES
-from Crypto.Util.Padding import pad, unpad
 from macaddress import EUI48
 import requests
 from requests import Session
@@ -21,7 +18,6 @@ from tplinkrouterc6u.client_abstract import AbstractRouter
 class RouterConstants:
     AUTH_TOKEN_INDEX1 = 3
     AUTH_TOKEN_INDEX2 = 4
-    DEFAULT_AES_VALUE = "0000000000000000"
 
     HOST_WIFI_2G_REQUEST = '33|1,1,0'
     HOST_WIFI_5G_REQUEST = '33|2,1,0'
@@ -64,9 +60,7 @@ class EncryptionState:
         self.nn_rsa = ''
         self.ee_rsa = ''
         self.seq = ''
-        self.key_aes = ''
-        self.iv_aes = ''
-        self.aes_string = ''
+        self.aes = EncryptionWrapper()
         self.token = ''
 
 
@@ -105,14 +99,11 @@ class TplinkC80Router(AbstractRouter):
         self._encryption.nn_rsa = responseText[2]
         self._encryption.seq = responseText[3]
 
-        # Generate key and initialization vector
-        self._encryption.key_aes = RouterConstants.DEFAULT_AES_VALUE
-        self._encryption.iv_aes = RouterConstants.DEFAULT_AES_VALUE
-        self._encryption.aes_string = f'k={self._encryption.key_aes}&i={self._encryption.iv_aes}'
-
         # Encrypt AES string
-        aes_string_encrypted = EncryptionWrapper.rsa_encrypt(self._encryption.aes_string, self._encryption.nn_rsa,
+        aes_string_encrypted = EncryptionWrapper.rsa_encrypt(self._encryption.aes._get_aes_string(),
+                                                             self._encryption.nn_rsa,
                                                              self._encryption.ee_rsa)
+
         # Register AES string for decryption on server side
         self.request(16, 0, True, data=f'set {aes_string_encrypted}')
         # Some auth request, might be redundant
@@ -368,7 +359,7 @@ class TplinkC80Router(AbstractRouter):
 
     def _get_signature(self, datalen: int) -> str:
         encryption = self._encryption
-        r = f'{encryption.aes_string}&s={str(int(encryption.seq) + datalen)}'
+        r = f'{encryption.aes._get_aes_string()}&s={str(int(encryption.seq) + datalen)}'
         e = ''
         n = 0
         while n < len(r):
@@ -377,24 +368,12 @@ class TplinkC80Router(AbstractRouter):
         return e
 
     def _encrypt_body(self, text: str) -> str:
-        encryption = self._encryption
-
-        key_bytes = encryption.key_aes.encode("utf-8")
-        iv_bytes = encryption.iv_aes.encode("utf-8")
-
-        cipher = AES.new(key_bytes, AES.MODE_CBC, iv_bytes)
-        data = b64encode(cipher.encrypt(pad(text.encode("utf-8"), AES.block_size))).decode()
-
+        data = self._encryption.aes.aes_encrypt(text)
         sign = self._get_signature(len(data))
         return f'sign={sign}\r\ndata={data}'
 
     def _decrypt_data(self, encrypted_text: str) -> str:
-        key_bytes = self._encryption.key_aes.encode("utf-8")
-        iv_bytes = self._encryption.iv_aes.encode("utf-8")
-
-        cipher = AES.new(key_bytes, AES.MODE_CBC, iv_bytes)
-        decrypted_padded = cipher.decrypt(b64decode(encrypted_text))
-        return unpad(decrypted_padded, AES.block_size).decode("utf-8")
+        return self._encryption.aes.aes_decrypt(encrypted_text)
 
     def _extract_value(self, response_list, prefix):
         return next((s.split(prefix, 1)[1] for s in response_list if s.startswith(prefix)), None)

tplinkrouterc6u/client/ex.py

@@ -15,9 +15,10 @@ from tplinkrouterc6u.common.dataclass import (
     IPv4Status,
     VPNStatus)
 from tplinkrouterc6u.common.exception import ClientException, ClientError
-from tplinkrouterc6u.client.mr import TPLinkMRClientBase
+from tplinkrouterc6u.client.mr import TPLinkMRClientBase, TPLinkMRClientBaseGCM
 
 
+# Class for EX series routers which supports old firmwares with AES cipher CBC mode
 class TPLinkEXClient(TPLinkMRClientBase):
     WIFI_SET = {
         Connection.HOST_2G: '1,0,0,0,0,0',
@@ -331,3 +332,39 @@ class TPLinkEXClient(TPLinkMRClientBase):
         ]
 
         self.req_act(acts)
+
+
+# Class for EX series routers which supports AES cipher GCM mode
+class TPLinkEXClientGCM(TPLinkMRClientBaseGCM, TPLinkEXClient):
+
+    def _req_login(self) -> None:
+        login_data = ('{"data":{"UserName":"%s","Passwd":"%s","Action": "1","stack":"0,0,0,0,0,0",'
+                      '"pstack":"0,0,0,0,0,0"},"operation":"cgi","oid":"/cgi/login"}') % (
+            b64encode(bytes(self.username, "utf-8")).decode("utf-8"),
+            b64encode(bytes(self.password, "utf-8")).decode("utf-8")
+        )
+
+        sign, data, tag = self._prepare_data(login_data, True)
+        assert len(sign) == 256
+
+        request_data = f"sign={sign}\r\ndata={data}\r\ntag={tag}\r\n"
+
+        url = f"{self.host}/cgi_gdpr?9"
+        (code, response) = self._request(url, data_str=request_data)
+        response = self._encryption.aes_decrypt(response)
+
+        # parse and match return code
+        ret_code = self._parse_ret_val(response)
+        error = ''
+        if ret_code == self.HTTP_ERR_USER_PWD_NOT_CORRECT:
+            error = ('TplinkRouter - EX - Login failed, wrong user or password. '
+                     'Try to pass user instead of admin in username')
+        elif ret_code == self.HTTP_ERR_USER_BAD_REQUEST:
+            error = 'TplinkRouter - EX - Login failed. Generic error code: {}'.format(ret_code)
+        elif ret_code != self.HTTP_RET_OK:
+            error = 'TplinkRouter - EX - Login failed. Unknown error code: {}'.format(ret_code)
+
+        if error:
+            if self._logger:
+                self._logger.debug(error)
+            raise ClientException(error)

tplinkrouterc6u/client/mr.py

@@ -8,7 +8,7 @@ from macaddress import EUI48
 from ipaddress import IPv4Address
 from logging import Logger
 from tplinkrouterc6u.common.helper import get_ip, get_mac, get_value
-from tplinkrouterc6u.common.encryption import EncryptionWrapperMR
+from tplinkrouterc6u.common.encryption import EncryptionWrapperMR, EncryptionWrapperMRGCM
 from tplinkrouterc6u.common.package_enum import Connection, VPN
 from tplinkrouterc6u.common.dataclass import (
     Firmware,
@@ -80,6 +80,7 @@ class TPLinkMRClientBase(AbstractRouter):
         if self._verify_ssl is False:
             self.req.verify = False
         self._token = None
+        self._authorized_at = None
         self._hash = md5(f"{self.username}{self.password}".encode()).hexdigest()
         self._nn = None
         self._ee = None
@@ -96,10 +97,9 @@ class TPLinkMRClientBase(AbstractRouter):
             return False
 
     def authorize(self) -> None:
-        '''
-        Establishes a login session to the host using provided credentials
-        '''
-        # hash the password
+        if self._token is not None and self._authorized_at >= (datetime.now() - timedelta(seconds=3)):
+            return
+        self._token = None
 
         # request the RSA public key from the host
         self._nn, self._ee, self._seq = self._req_rsa_key()
@@ -109,6 +109,7 @@ class TPLinkMRClientBase(AbstractRouter):
 
         # request TokenID
         self._token = self._req_token()
+        self._authorized_at = datetime.now()
 
     def reboot(self) -> None:
         acts = [
@@ -587,6 +588,71 @@ class TPLinkMRClientBase(AbstractRouter):
         return signature, encrypted_data
 
 
+class TPLinkMRClientBaseGCM(TPLinkMRClientBase):
+    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._encryption = EncryptionWrapperMRGCM()
+
+    def supports(self) -> bool:
+        try:
+            self.authorize()
+            return True
+        except Exception:
+            pass
+
+        return False
+
+    def _request(self, url, method='POST', data_str=None, encrypt=False, is_login=False):
+        headers = self.HEADERS
+        headers['Referer'] = self.host
+
+        if self._token is not None:
+            headers['TokenID'] = self._token
+
+        if encrypt:
+            sign, data, tag = self._prepare_data(data_str, is_login)
+            data = 'sign={}\r\ndata={}\r\ntag={}\r\n'.format(sign, data, tag)
+        else:
+            data = data_str
+
+        retry = 0
+        while retry < self.REQUEST_RETRIES:
+            # send the request
+            if method == 'POST':
+                r = self.req.post(url, data=data, headers=headers, timeout=self.timeout, verify=self._verify_ssl)
+            elif method == 'GET':
+                r = self.req.get(url, data=data, headers=headers, timeout=self.timeout, verify=self._verify_ssl)
+            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
+
+        # decrypt the response, if needed
+        if encrypt and (r.status_code == 200) and (r.text != ''):
+            return r.status_code, self._encryption.aes_decrypt(r.text)
+        else:
+            return r.status_code, r.text
+
+    def _prepare_data(self, data: str, is_login: bool) -> tuple[str, str, str]:
+        encrypted_data, tag = self._encryption.aes_encrypt(data)
+        data_len = len(encrypted_data)
+        # get encrypted signature
+        signature = self._encryption.get_signature(int(self._seq) + data_len, is_login, self._hash, self._nn, self._ee)
+
+        # format expected raw request data
+        return signature, encrypted_data, tag
+
+
+# Class for MR series routers which supports old firmwares with AES cipher CBC mode
 class TPLinkMRClient(TPLinkMRClientBase):
 
     def logout(self) -> None:
@@ -716,3 +782,8 @@ class TPLinkMRClient(TPLinkMRClientBase):
         status.isp_name = values['3']['ispName']
 
         return status
+
+
+# Class for MR series routers which supports AES cipher GCM mode
+class TPLinkMRClientGCM(TPLinkMRClientBaseGCM, TPLinkMRClient):
+    pass

tplinkrouterc6u/client/mr200.py

@@ -4,20 +4,8 @@ from Crypto.PublicKey import RSA
 from binascii import hexlify
 from Crypto.Cipher import PKCS1_v1_5
 from re import search
-from time import sleep
-from datetime import timedelta, datetime
-from macaddress import EUI48
-from ipaddress import IPv4Address
-from tplinkrouterc6u.common.helper import get_ip, get_mac, get_value
-from tplinkrouterc6u.common.package_enum import Connection, VPN
+from tplinkrouterc6u.common.package_enum import VPN
 from tplinkrouterc6u.common.dataclass import (
-    Firmware,
-    Status,
-    Device,
-    IPv4Reservation,
-    IPv4DHCPLease,
-    IPv4Status,
-    SMS,
     LTEStatus,
     VPNStatus,
 )
@@ -26,8 +14,14 @@ from tplinkrouterc6u.common.exception import ClientException, ClientError, Autho
 
 class TPLinkMR200Client(TPLinkMRClient):
 
+    def supports(self) -> bool:
+        try:
+            self.__get_params()
+            return True
+        except ClientException:
+            return False
+
     def authorize(self) -> None:
-        self.req.headers = {'referer': f'{self.host}/', 'origin': self.host}
         params = self.__get_params()
 
         # Construct the RSA public key manually using modulus (n) and exponent (e)
@@ -58,203 +52,31 @@ class TPLinkMR200Client(TPLinkMRClient):
         except AttributeError:
             raise AuthorizeError()
 
-    def get_firmware(self) -> Firmware:
-        acts = [
-            self.ActItem(self.ActItem.GET, 'IGD_DEV_INFO')
-        ]
-        _, values = self.req_act(acts)
-
-        firmware = Firmware(values.get('hardwareVersion', ''), values.get('modelName', ''),
-                            values.get('softwareVersion', ''))
-
-        return firmware
-
-    def get_status(self) -> Status:
-        status = Status()
-        acts = [
-            self.ActItem(self.ActItem.GS, 'LAN_IP_INTF'),
-            self.ActItem(self.ActItem.GS, 'WAN_IP_CONN'),
-            self.ActItem(self.ActItem.GL, 'LAN_WLAN'),
-            self.ActItem(self.ActItem.GL, 'LAN_WLAN_GUESTNET'),
-            self.ActItem(self.ActItem.GL, 'LAN_HOST_ENTRY'),
-            self.ActItem(self.ActItem.GS, 'LAN_WLAN_ASSOC_DEV'),
-        ]
-        _, values = self.req_act(acts)
-
-        if values['0'].__class__ == list:
-            values['0'] = values['0'][0]
-
-        status._lan_macaddr = EUI48(values['0']['X_TP_MACAddress'])
-        status._lan_ipv4_addr = IPv4Address(values['0']['IPInterfaceIPAddress'])
-
-        for item in self._to_list(values.get('1')):
-            if int(item['enable']) == 0 and values.get('1').__class__ == list:
-                continue
-            status._wan_macaddr = EUI48(item['MACAddress']) if item.get('MACAddress') else None
-            status._wan_ipv4_addr = IPv4Address(item['externalIPAddress'])
-            status._wan_ipv4_gateway = IPv4Address(item['defaultGateway'])
-            status.conn_type = item.get('name', '')
-
-        if values['2'].__class__ != list:
-            status.wifi_2g_enable = bool(int(values['2']['enable']))
-        else:
-            status.wifi_2g_enable = bool(int(values['2'][0]['enable']))
-            status.wifi_5g_enable = bool(int(values['2'][1]['enable']))
-
-        if values['3'].__class__ != list:
-            status.guest_2g_enable = bool(int(values['3']['enable']))
-        else:
-            status.guest_2g_enable = bool(int(values['3'][0]['enable']))
-            status.guest_5g_enable = bool(int(values['3'][1]['enable']))
-
-        devices = {}
-        for val in self._to_list(values.get('4')):
-            if int(val['active']) == 0:
-                continue
-            conn = self.CLIENT_TYPES.get(int(val['X_TP_ConnType']))
-            if conn is None:
-                continue
-            elif conn == Connection.WIRED:
-                status.wired_total += 1
-            elif conn.is_guest_wifi():
-                status.guest_clients_total += 1
-            elif conn.is_host_wifi():
-                status.wifi_clients_total += 1
-            devices[val['MACAddress']] = Device(conn,
-                                                EUI48(val['MACAddress']),
-                                                IPv4Address(val['IPAddress']),
-                                                val['hostName'])
-
-        for val in self._to_list(values.get('5')):
-            if val['associatedDeviceMACAddress'] not in devices:
-                status.wifi_clients_total += 1
-                devices[val['associatedDeviceMACAddress']] = Device(
-                    Connection.HOST_2G,
-                    EUI48(val['associatedDeviceMACAddress']),
-                    IPv4Address('0.0.0.0'),
-                    '')
-            devices[val['associatedDeviceMACAddress']].packets_sent = int(val['X_TP_TotalPacketsSent'])
-            devices[val['associatedDeviceMACAddress']].packets_received = int(val['X_TP_TotalPacketsReceived'])
-
-        status.devices = list(devices.values())
-        status.clients_total = status.wired_total + status.wifi_clients_total + status.guest_clients_total
-
-        return status
-
-    def get_ipv4_reservations(self) -> [IPv4Reservation]:
-        acts = [
-            self.ActItem(self.ActItem.GL, 'LAN_DHCP_STATIC_ADDR'),
-        ]
-        _, values = self.req_act(acts)
-
-        ipv4_reservations = []
-        for item in self._to_list(values):
-            ipv4_reservations.append(
-                IPv4Reservation(
-                    EUI48(item['chaddr']),
-                    IPv4Address(item['yiaddr']),
-                    '',
-                    bool(int(item['enable']))
-                ))
-
-        return ipv4_reservations
-
-    def get_ipv4_dhcp_leases(self) -> [IPv4DHCPLease]:
-        acts = [
-            self.ActItem(self.ActItem.GL, 'LAN_HOST_ENTRY'),
-        ]
-        _, values = self.req_act(acts)
-
-        dhcp_leases = []
-        for item in self._to_list(values):
-            lease_time = item['leaseTimeRemaining']
-            dhcp_leases.append(
-                IPv4DHCPLease(
-                    EUI48(item['MACAddress']),
-                    IPv4Address(item['IPAddress']),
-                    item['hostName'],
-                    str(timedelta(seconds=int(lease_time))) if lease_time.isdigit() else 'Permanent',
-                ))
-
-        return dhcp_leases
-
-    def get_ipv4_status(self) -> IPv4Status:
-        acts = [
-            self.ActItem(self.ActItem.GS, 'LAN_IP_INTF'),
-            self.ActItem(self.ActItem.GET, 'LAN_HOST_CFG', '1,0,0,0,0,0'),
-            self.ActItem(self.ActItem.GS, 'WAN_IP_CONN'),
-        ]
-        _, values = self.req_act(acts)
-
-        ipv4_status = IPv4Status()
-        ipv4_status._lan_macaddr = get_mac(get_value(values, ['0', 'X_TP_MACAddress'], '00:00:00:00:00:00'))
-        ipv4_status._lan_ipv4_ipaddr = get_ip(get_value(values, ['0', 'IPInterfaceIPAddress'], '0.0.0.0'))
-        ipv4_status._lan_ipv4_netmask = get_ip(get_value(values, ['0', 'IPInterfaceSubnetMask'], '0.0.0.0'))
-        ipv4_status.lan_ipv4_dhcp_enable = bool(int(get_value(values, ['1', 'DHCPServerEnable'], '0')))
-
-        for item in self._to_list(values.get('2')):
-            if int(item.get('enable', '0')) == 0 and values.get('2').__class__ == list:
-                continue
-            ipv4_status._wan_macaddr = get_mac(item.get('MACAddress', '00:00:00:00:00:00'))
-            ipv4_status._wan_ipv4_ipaddr = get_ip(item.get('externalIPAddress', '0.0.0.0'))
-            ipv4_status._wan_ipv4_gateway = get_ip(item.get('defaultGateway', '0.0.0.0'))
-            ipv4_status._wan_ipv4_conntype = item.get('name', '')
-            ipv4_status._wan_ipv4_netmask = get_ip(item.get('subnetMask', '0.0.0.0'))
-            dns = item.get('DNSServers', '').split(',')
-            ipv4_status._wan_ipv4_pridns = get_ip(dns[0] if len(dns) > 0 else '0.0.0.0')
-            ipv4_status._wan_ipv4_snddns = get_ip(dns[1] if len(dns) > 1 else '0.0.0.0')
-
-        return ipv4_status
-
-    def set_wifi(self, wifi: Connection, enable: bool) -> None:
-        acts = [
-            self.ActItem(
-                self.ActItem.SET,
-                'LAN_WLAN' if wifi in [Connection.HOST_2G, Connection.HOST_5G] else 'LAN_WLAN_MSSIDENTRY',
-                self.WIFI_SET[wifi],
-                attrs=['enable={}'.format(int(enable))]),
-        ]
-        self.req_act(acts)
-
     def get_vpn_status(self) -> VPNStatus:
         status = VPNStatus()
         acts = [
-            self.ActItem(self.ActItem.GET, 'OPENVPN'),
-            self.ActItem(self.ActItem.GET, 'PPTPVPN'),
-            self.ActItem(self.ActItem.GL, 'OVPN_CLIENT'),
-            self.ActItem(self.ActItem.GL, 'PVPN_CLIENT'),
+            self.ActItem(self.ActItem.GL, 'IPSEC_CFG'),
         ]
         _, values = self.req_act(acts)
 
-        status.openvpn_enable = values['0']['enable'] == '1'
-        status.pptpvpn_enable = values['1']['enable'] == '1'
-
-        for item in values['2']:
-            if item['connAct'] == '1':
-                status.openvpn_clients_total += 1
-
-        for item in values['3']:
-            if item['connAct'] == '1':
-                status.pptpvpn_clients_total += 1
+        status.ipsecvpn_enable = values.get('enable') == '1'
 
         return status
 
     def set_vpn(self, vpn: VPN, enable: bool) -> None:
         acts = [
-            self.ActItem(self.ActItem.SET, vpn.value, attrs=['enable={}'.format(int(enable))])
+            self.ActItem(
+                self.ActItem.SET,
+                'IPSEC_CFG',
+                '1,0,0,0,0,0',
+                attrs=['enable={}'.format(int(enable))]
+            )
         ]
 
         self.req_act(acts)
 
     def logout(self) -> None:
-        '''
-        Logs out from the host
-        '''
-        if self._token is None:
-            return
-
         acts = [
-            # 8\r\n[/cgi/logout#0,0,0,0,0,0#0,0,0,0,0,0]0,0\r\n
             self.ActItem(self.ActItem.CGI, '/cgi/logout')
         ]
 
@@ -264,109 +86,38 @@ class TPLinkMR200Client(TPLinkMRClient):
         if ret_code == self.HTTP_RET_OK:
             del self.req.headers["TokenID"]
 
-    def send_sms(self, phone_number: str, message: str) -> None:
-        acts = [
-            self.ActItem(
-                self.ActItem.SET, 'LTE_SMS_SENDNEWMSG', attrs=[
-                    'index=1',
-                    'to={}'.format(phone_number),
-                    'textContent={}'.format(message),
-                ]),
-        ]
-        self.req_act(acts)
-
-    def get_sms(self) -> [SMS]:
-        acts = [
-            self.ActItem(
-                self.ActItem.SET, 'LTE_SMS_RECVMSGBOX', attrs=['PageNumber=1']),
-            self.ActItem(
-                self.ActItem.GL, 'LTE_SMS_RECVMSGENTRY'),
-        ]
-        _, values = self.req_act(acts)
-
-        messages = []
-        if values:
-            i = 1
-            for item in self._to_list(values.get('1')):
-                messages.append(
-                    SMS(
-                        i, item['from'], item['content'], datetime.fromisoformat(item['receivedTime']),
-                        item['unread'] == '1'
-                    )
-                )
-                i += 1
-
-        return messages
-
-    def set_sms_read(self, sms: SMS) -> None:
-        acts = [
-            self.ActItem(
-                self.ActItem.SET, 'LTE_SMS_RECVMSGENTRY', f'{sms.id},0,0,0,0,0', attrs=['unread=0']),
-        ]
-        self.req_act(acts)
-
-    def delete_sms(self, sms: SMS) -> None:
-        acts = [
-            self.ActItem(
-                self.ActItem.DEL, 'LTE_SMS_RECVMSGENTRY', f'{sms.id},0,0,0,0,0'),
-        ]
-        self.req_act(acts)
-
-    def send_ussd(self, command: str) -> str:
-        acts = [
-            self.ActItem(
-                self.ActItem.SET, 'LTE_USSD', attrs=[
-                    'action=1',
-                    f"reqContent={command}",
-                ]),
-        ]
-        self.req_act(acts)
-
-        status = '0'
-        while status == '0':
-            sleep(1)
-            acts = [
-                self.ActItem(self.ActItem.GET, 'LTE_USSD'),
-            ]
-            _, values = self.req_act(acts)
-
-            status = values.get('ussdStatus', '2')
-
-            if status == '1':
-                return values.get('response')
-            elif status == '2':
-                raise ClientError('Cannot send USSD!')
-
     def get_lte_status(self) -> LTEStatus:
         status = LTEStatus()
         acts = [
-            self.ActItem(self.ActItem.GET, 'WAN_LTE_LINK_CFG', '2,1,0,0,0,0'),
-            self.ActItem(self.ActItem.GET, 'WAN_LTE_INTF_CFG', '2,0,0,0,0,0'),
-            self.ActItem(self.ActItem.GET, 'LTE_NET_STATUS', '2,1,0,0,0,0'),
-            self.ActItem(self.ActItem.GET, 'LTE_PROF_STAT', '2,1,0,0,0,0'),
+            self.ActItem(self.ActItem.GET, 'WAN_LTE_LINK_CFG', '2,1,0,0,0,0',
+                         attrs=['enable', 'connectStatus', 'networkType', 'roamingStatus', 'simStatus']),
+            self.ActItem(self.ActItem.GET, 'WAN_LTE_INTF_CFG', '2,0,0,0,0,0',
+                         attrs=['dataLimit', 'enablePaymentDay', 'curStatistics', 'totalStatistics', 'enableDataLimit',
+                                'limitation',
+                                'curRxSpeed', 'curTxSpeed']),
+            self.ActItem(self.ActItem.GET, 'LTE_WAN_CFG', '2,1,0,0,0,0'),
         ]
         _, values = self.req_act(acts)
 
-        status.enable = int(values['0']['enable'])
-        status.connect_status = int(values['0']['connectStatus'])
-        status.network_type = int(values['0']['networkType'])
-        status.sim_status = int(values['0']['simStatus'])
+        status.enable = values['0'].get('enable', 0)
+        status.connect_status = values['0'].get('connectStatus', 0)
+        status.network_type = values['0'].get('networkType', 0)
+        status.sim_status = values['0'].get('simStatus', 0)
+        status.sig_level = values['0'].get('signalStrength', 0)
 
-        status.total_statistics = int(float(values['1']['totalStatistics']))
-        status.cur_rx_speed = int(values['1']['curRxSpeed'])
-        status.cur_tx_speed = int(values['1']['curTxSpeed'])
+        status.total_statistics = values['1'].get('totalStatistics', 0)
+        status.cur_rx_speed = values['1'].get('curRxSpeed', 0)
+        status.cur_tx_speed = values['1'].get('curTxSpeed', 0)
 
-        status.sms_unread_count = int(values['2']['smsUnreadCount'])
-        status.sig_level = int(values['2']['sigLevel'])
-        status.rsrp = int(values['2']['rfInfoRsrp'])
-        status.rsrq = int(values['2']['rfInfoRsrq'])
-        status.snr = int(values['2']['rfInfoSnr'])
+        status.isp_name = values['2'].get('profileName', '')
 
-        status.isp_name = values['3']['ispName']
+        sms_list = self.get_sms()
+        status.sms_unread_count = sum(1 for m in sms_list if getattr(m, 'unread', False))
 
         return status
 
     def __get_params(self, retry=False):
+        self.req.headers = {'referer': f'{self.host}/', 'origin': self.host}
         try:
             r = self.req.get(f"{self.host}/cgi/getParm", timeout=5)
             result = {}
@@ -399,14 +150,16 @@ class TPLinkMR200Client(TPLinkMRClient):
 
         data = ''.join(act_data)
         url = f"{self.host}/cgi?" + '&'.join(act_types)
-        (code, response) = self.req.post(url, data=data)
+        response = self.req.post(url, data=data)
+        code = response.status_code
 
         if code != 200:
-            error = 'TplinkRouter - MR200 -  Response with error; Request {} - Response {}'.format(data, response)
+            error = 'TplinkRouter - MR200 -  Response with error; Request {} - Response {}'.format(data, response.text)
             if self._logger:
                 self._logger.debug(error)
             raise ClientError(error)
 
-        result = self._merge_response(response)
+        # Convert Response to string for _merge_response
+        result = self._merge_response(response.text)
 
         return response, result.get('0') if len(result) == 1 and result.get('0') else result

tplinkrouterc6u/client/re330.py

@@ -1,17 +1,12 @@
 from dataclasses import dataclass
 from logging import Logger
 from urllib import parse
-from base64 import b64encode, b64decode
 from collections import defaultdict
 from ipaddress import IPv4Address
 import re
-from Crypto.Cipher import AES
-from Crypto.Util.Padding import pad, unpad
 from macaddress import EUI48
 import requests
 from requests import Session
-from datetime import datetime
-import random
 from tplinkrouterc6u.common.package_enum import Connection
 from tplinkrouterc6u.common.exception import ClientException
 from tplinkrouterc6u.common.encryption import EncryptionWrapper
@@ -58,9 +53,7 @@ class EncryptionState:
         self.nn_rsa = ''
         self.ee_rsa = ''
         self.seq = ''
-        self.key_aes = ''
-        self.iv_aes = ''
-        self.aes_string = ''
+        self.aes = EncryptionWrapper()
         self.token = ''
 
 
@@ -110,12 +103,9 @@ class TplinkRE330Router(AbstractRouter):
         self._encryption.nn_rsa = responseText[2]
         self._encryption.seq = responseText[3]
 
-        # Generate key and initialization vector
-        self._encryption.key_aes, self._encryption.iv_aes = self._generate_AES_key()
-        self._encryption.aes_string = f'k={self._encryption.key_aes}&i={self._encryption.iv_aes}'
-
         # Encrypt AES string
-        aes_string_encrypted = EncryptionWrapper.rsa_encrypt(self._encryption.aes_string, self._encryption.nn_rsa,
+        aes_string_encrypted = EncryptionWrapper.rsa_encrypt(self._encryption.aes._get_aes_string(),
+                                                             self._encryption.nn_rsa,
                                                              self._encryption.ee_rsa)
         # Mandatory intermediate request
         response = self.request(7, 0, True)
@@ -368,7 +358,7 @@ class TplinkRE330Router(AbstractRouter):
 
     def _get_signature(self, datalen: int) -> str:
         encryption = self._encryption
-        r = f'{encryption.aes_string}&s={str(int(encryption.seq) + datalen)}'
+        r = f'{encryption.aes._get_aes_string()}&s={str(int(encryption.seq) + datalen)}'
         e = ''
         n = 0
         while n < len(r):
@@ -377,24 +367,12 @@ class TplinkRE330Router(AbstractRouter):
         return e
 
     def _encrypt_body(self, text: str) -> str:
-        encryption = self._encryption
-
-        key_bytes = encryption.key_aes.encode("utf-8")
-        iv_bytes = encryption.iv_aes.encode("utf-8")
-
-        cipher = AES.new(key_bytes, AES.MODE_CBC, iv_bytes)
-        data = b64encode(cipher.encrypt(pad(text.encode("utf-8"), AES.block_size))).decode()
-
+        data = self._encryption.aes.aes_encrypt(text)
         sign = self._get_signature(len(data))
         return f'sign={sign}\r\ndata={data}'
 
     def _decrypt_data(self, encrypted_text: str) -> str:
-        key_bytes = self._encryption.key_aes.encode("utf-8")
-        iv_bytes = self._encryption.iv_aes.encode("utf-8")
-
-        cipher = AES.new(key_bytes, AES.MODE_CBC, iv_bytes)
-        decrypted_padded = cipher.decrypt(b64decode(encrypted_text))
-        return unpad(decrypted_padded, AES.block_size).decode("utf-8")
+        return self._encryption.aes.aes_decrypt(encrypted_text)
 
     def _extract_value(self, response_list, prefix):
         return next((s.split(prefix, 1)[1] for s in response_list if s.startswith(prefix)), None)
@@ -413,11 +391,3 @@ class TplinkRE330Router(AbstractRouter):
         except requests.exceptions.RequestException as e:
             self._logger.error(f"Network error: {e}")
             raise ClientException(f"Network error: {str(e)}") from e
-
-    @staticmethod
-    def _generate_AES_key() -> tuple[str, str]:
-        KEY_LEN = int(128 / 8)
-        IV_LEN = 16
-        key = (str(int(datetime.now().timestamp())) + str(int(random.random()*1000000000)))[:KEY_LEN]
-        iv = (str(int(datetime.now().timestamp())) + str(int(random.random()*1000000000)))[:IV_LEN]
-        return key, iv

tplinkrouterc6u/client/xdr.py

@@ -116,6 +116,8 @@ class TPLinkXDRClient(AbstractRouter):
             dev = Device(conn_type, get_mac(item['mac']), get_ip(item['ip']), unquote(item['hostname']))
             dev.up_speed = item['up_speed']
             dev.down_speed = item['down_speed']
+            if 'online' in item:
+                dev.active = item['online'] == '1'
             status.devices.append(dev)
         return status
 

tplinkrouterc6u/common/dataclass.py

@@ -310,5 +310,6 @@ class LTEStatus:
 class VPNStatus:
     openvpn_enable: bool | None = None
     pptpvpn_enable: bool | None = None
+    ipsecvpn_enable: bool | None = None
     openvpn_clients_total: int = 0
     pptpvpn_clients_total: int = 0

tplinkrouterc6u/common/encryption.py

@@ -189,3 +189,116 @@ class EncryptionWrapperMR:
         n = int('0x' + nn, 16)
         e = int('0x' + ee, 16)
         return RSA.construct((n, e))
+
+
+class EncryptionWrapperMRGCM:
+    RSA_USE_PKCS_V1_5 = False
+    AES_KEY_LEN = 128 // 8
+    AES_IV_LEN = 12  # previously 16
+
+    def __init__(self) -> None:
+        ts = str(round(time() * 1000))
+
+        key = (ts + str(randint(100000000, 1000000000 - 1)))[:self.AES_KEY_LEN]
+        iv = (ts + str(randint(100000000, 1000000000 - 1)))[:self.AES_IV_LEN]
+
+        assert len(key) == self.AES_KEY_LEN
+        assert len(iv) == self.AES_IV_LEN
+
+        self._key = key
+        self._iv = iv
+
+    def aes_encrypt(self, raw: str) -> tuple[str, str]:
+        # not sure what the padding was for here:
+        # data_padded = pad(raw.encode('utf8'), 16, 'pkcs7')
+
+        # encrypt the body
+        aes_encryptor = self._make_aes_cipher()
+        encrypted_data_bytes, tag = aes_encryptor.encrypt_and_digest(raw.encode('utf-8'))
+        return (
+            b64encode(encrypted_data_bytes).decode(),  # router expects b64 ciphertext
+            b64encode(tag).decode()  # router expects b64 tag (this is new)
+        )
+
+    def aes_decrypt(self, data: str):
+        # decode base64 string
+        tag = b64decode(data[-24:])  # last 24 characters are the tag
+        encrypted_response_data = b64decode(data[:-24])
+        # decrypt the response using our AES key
+        aes_decryptor = self._make_aes_cipher()
+        response = aes_decryptor.decrypt_and_verify(encrypted_response_data, tag)
+
+        # not sure what unpad did here before:
+        # return unpad(response, 16, 'pkcs7').decode('utf8')
+        return response.decode('utf8')
+
+    def get_signature(self, seq: int, is_login: bool, hash: str, nn: str, ee: str) -> str:
+        if is_login:
+            # on login we also send our AES key, which is subsequently
+            # used for E2E encrypted communication
+            # key and iv now base64 not like before
+            key = b64encode(self._key.encode('utf-8')).decode()
+            iv = b64encode(self._iv.encode('utf-8')).decode()
+            sign_data = 'key={}&iv={}&h={}&s={}'.format(key, iv, hash, seq)
+        else:
+            sign_data = 'h={}&s={}'.format(hash, seq)
+
+        # set step based on whether PKCS padding is used
+        rsa_byte_len = len(nn) // 2  # hexlen / 2 * 8 / 8
+        step = (rsa_byte_len - 11) if self.RSA_USE_PKCS_V1_5 else rsa_byte_len
+
+        # encrypt the signature using the RSA public key
+        rsa_key = self._make_rsa_pub_key(nn, ee)
+
+        # make the PKCS#1 v1.5 cipher
+        if self.RSA_USE_PKCS_V1_5:
+            rsa = PKCS1_v1_5.new(rsa_key)
+
+        signature = ''
+        pos = 0
+
+        while pos < len(sign_data):
+            sign_data_bin = sign_data[pos: pos + step].encode('utf8')
+
+            if self.RSA_USE_PKCS_V1_5:
+                # encrypt using the PKCS#1 v1.5 padding
+                enc = rsa.encrypt(sign_data_bin)
+            else:
+                # encrypt using NOPADDING
+                # ... pad the end with zero bytes
+                while len(sign_data_bin) < step:
+                    sign_data_bin = sign_data_bin + b'\0'
+
+                # step 3a (OS2IP)
+                em_int = bytes_to_long(sign_data_bin)
+
+                # step 3b (RSAEP)
+                m_int = rsa_key._encrypt(em_int)
+
+                # step 3c (I2OSP)
+                enc = long_to_bytes(m_int, 1)
+
+            # hexlify to string
+            enc_str = hexlify(enc).decode('utf8')
+
+            # pad the start with '0' hex char
+            while len(enc_str) < rsa_byte_len * 2:
+                enc_str = '0' + enc_str
+
+            signature += enc_str
+            pos = pos + step
+
+        return signature
+
+    def _make_aes_cipher(self) -> AES:
+        # consider renaming _iv to _nonce
+        return AES.new(self._key.encode('utf-8'), AES.MODE_GCM, nonce=self._iv.encode('utf-8'))
+
+    @staticmethod
+    def _make_rsa_pub_key(nn: str, ee: str):
+        '''
+        Makes a new RSA pub key from tuple (n, e)
+        '''
+        n = int('0x' + nn, 16)
+        e = int('0x' + ee, 16)
+        return RSA.construct((n, e))

tplinkrouterc6u/common/package_enum.py

@@ -49,6 +49,7 @@ class Connection(Enum):
 class VPN(Enum):
     OPEN_VPN = 'OPENVPN'
     PPTP_VPN = 'PPTPVPN'
+    IPSEC = 'IPSEC'
 
     @property
     def lowercase(self) -> str:

tplinkrouterc6u/provider.py

@@ -5,8 +5,9 @@ from tplinkrouterc6u.common.exception import ClientException
 from tplinkrouterc6u.client.c6u import TplinkRouter
 from tplinkrouterc6u.client.deco import TPLinkDecoClient
 from tplinkrouterc6u.client_abstract import AbstractRouter
-from tplinkrouterc6u.client.mr import TPLinkMRClient
-from tplinkrouterc6u.client.ex import TPLinkEXClient
+from tplinkrouterc6u.client.mr import TPLinkMRClient, TPLinkMRClientGCM
+from tplinkrouterc6u.client.mr200 import TPLinkMR200Client
+from tplinkrouterc6u.client.ex import TPLinkEXClient, TPLinkEXClientGCM
 from tplinkrouterc6u.client.c5400x import TplinkC5400XRouter
 from tplinkrouterc6u.client.c1200 import TplinkC1200Router
 from tplinkrouterc6u.client.c80 import TplinkC80Router
@@ -19,13 +20,15 @@ class TplinkRouterProvider:
     @staticmethod
     def get_client(host: str, password: str, username: str = 'admin', logger: Logger = None,
                    verify_ssl: bool = True, timeout: int = 30) -> AbstractRouter:
-        for client in [TplinkC5400XRouter, TPLinkVRClient, TPLinkEXClient, TPLinkMRClient, TPLinkDecoClient,
-                       TPLinkXDRClient, TplinkRouter, TplinkC80Router, TplinkWDRRouter, TplinkRE330Router]:
+        for client in [TplinkC5400XRouter, TPLinkVRClient, TPLinkEXClientGCM, TPLinkEXClient, TPLinkMRClientGCM,
+                       TPLinkMRClient, TPLinkMR200Client, TPLinkDecoClient, TPLinkXDRClient, TplinkRouter,
+                       TplinkC80Router, TplinkWDRRouter, TplinkRE330Router]:
             router = client(host, password, username, logger, verify_ssl, timeout)
             if router.supports():
                 return router
 
-        message = ('Login failed! Please check if your router local password is correct or '
+        message = ('Login failed! Please check if your router local password is correct,'
+                   'check if the default router username is correct or '
                    'try to use web encrypted password instead. Check the documentation!')
         router = TplinkC1200Router(host, password, username, logger, verify_ssl, timeout)
         try:

{tplinkrouterc6u-5.11.0.dist-info → tplinkrouterc6u-5.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tplinkrouterc6u
-Version: 5.11.0
+Version: 5.12.0
 Summary: TP-Link Router API (supports also Mercusys Router)
 Home-page: https://github.com/AlexandrErohin/TP-Link-Archer-C6U
 Author: Alex Erohin
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -48,7 +49,7 @@ Python package for API access and management for TP-Link and Mercusys Routers. S
  - [pycryptodome](https://pypi.org/project/pycryptodome/)
 
 ## Usage
-Enter the host & credentials used to log in to your router management page. Username is admin by default. But you may pass username as third parameter
+Enter the host & credentials used to log in to your router management page. Username is `admin` by default. But you may pass username as third parameter. Some routers have default username - `user`
 
 ```python
 from tplinkrouterc6u import (
@@ -56,13 +57,17 @@ from tplinkrouterc6u import (
     TplinkRouter,
     TplinkC1200Router,
     TplinkC5400XRouter,
-    TPLinkMRClient,
+    TPLinkMRClient, # Class for MR series routers which supports old firmwares with AES cipher CBC mode
+    TPLinkMRClientGCM, # Class for MR series routers which supports AES cipher GCM mode
+    TPLinkMR200Client,
     TPLinkVRClient,
-    TPLinkEXClient,
+    TPLinkEXClient, # Class for EX series routers which supports old firmwares with AES cipher CBC mode
+    TPLinkEXClientGCM, # Class for EX series routers which supports AES cipher GCM mode
     TPLinkXDRClient,
     TPLinkDecoClient,
     TplinkC80Router,
     TplinkWDRRouter,
+    TplinkRE330Router,
     Connection
 )
 from logging import Logger
@@ -243,6 +248,7 @@ or you have TP-link C5400X or similar router you need to get web encrypted passw
 | --- |---|---|
 | openvpn_enable | OpenVPN is enabled | bool |
 | pptpvpn_enable | PPTPVPN is enabled | bool |
+| ipsecvpn_enable | IPSEC is enabled | bool |
 | openvpn_clients_total | OpenVPN clients connected | int |
 | pptpvpn_clients_total | PPTPVPN clients connected | int |
 
@@ -292,6 +298,7 @@ or you have TP-link C5400X or similar router you need to get web encrypted passw
 ### <a id="vpn">VPN</a>
 - VPN.OPEN_VPN
 - VPN.PPTP_VPN
+- VPN.IPSEC
 
 ## <a id="supports">Supported routers</a>
 - [TP-LINK routers](#tplink)
@@ -340,7 +347,7 @@ or you have TP-link C5400X or similar router you need to get web encrypted passw
 - Archer C80 (1.0, 2.20)
 - Archer C5400X V1
 - Archer GX90 v1.0
-- Archer MR200 (v5, v5.3, v6.0)
+- Archer MR200 (v2, v5, v5.3, v6.0)
 - Archer MR550 v1
 - Archer MR600 (v1, v2, v3)
 - Archer NX200 v2.0
@@ -349,6 +356,7 @@ or you have TP-link C5400X or similar router you need to get web encrypted passw
 - Archer VR900v
 - Archer VR1200v v1
 - Archer VR2100v v1
+- Archer VX231v v1.0
 - Archer VX1800v v1.0
 - BE11000 2.0
 - Deco M4 2.0
@@ -379,11 +387,13 @@ or you have TP-link C5400X or similar router you need to get web encrypted passw
 - TL-WA3001 v1.0
 - TL-XDR3010 V2
 - TL-WDR3600 V1
+- TL-XDR6088 v1.0.30
 - VX420-G2h v1.1
 - VX800v v1
 - XC220-G3v v2.30
 - RE330 v1
 ### <a id="mercusys">MERCUSYS routers</a>
+- AC10 1.20
 - MR47BE v1.0
 - MR50G 1.0
 - H60XR 1.0

{tplinkrouterc6u-5.11.0.dist-info → tplinkrouterc6u-5.12.0.dist-info}/RECORD

@@ -8,30 +8,30 @@ test/test_client_mr.py,sha256=lePxkmjcPzcrSFcaT8bT67L154cVJIOWrFlXMDOa8oY,33423
 test/test_client_re330.py,sha256=MgefuvOzfZtZOujrcOsjiTDiGEAujfeFXshcq7gn32Q,17044
 test/test_client_wdr.py,sha256=0ZnRNP57MbuMv2cxFS8iIoVyv8Q6gtY0Q03gtHp9AWY,13492
 test/test_client_xdr.py,sha256=mgn-xL5mD5sHD8DjTz9vpY7jeh4Ob6Um6Y8v5Qgx2jA,23374
-tplinkrouterc6u/__init__.py,sha256=WHMzO1mOGJqx7n89jHfNtieehlE3JEF17gtFmyZrqRM,1124
+tplinkrouterc6u/__init__.py,sha256=33L1bT4g8pVn6XpM3nebdYRtz0DXTapRtFROd3uFjmg,1162
 tplinkrouterc6u/client_abstract.py,sha256=3UYzmll774S_Gb5E0FTVO_rI3-XFM7PSklg1-V-2jls,1419
-tplinkrouterc6u/provider.py,sha256=uv7AjDVOnud-hiXJdjoAbzy9UWPtiwHRIHRenjkVO_o,2230
+tplinkrouterc6u/provider.py,sha256=lqxw_pQ4VBYKS3jKrG1zVd4zVnlA6T8MaIRcqq3JAtM,2477
 tplinkrouterc6u/client/__init__.py,sha256=KBy3fmtA9wgyFrb0Urh2x4CkKtWVnESdp-vxmuOvq0k,27
 tplinkrouterc6u/client/c1200.py,sha256=4XEYidEGmVIJk0YQLvmTnd0Gqa7glH2gUWvjreHpWrk,3178
 tplinkrouterc6u/client/c5400x.py,sha256=9E0omBSbWY_ljrs5MTCMu5brmrLtzsDB5O62Db8lP8Q,4329
 tplinkrouterc6u/client/c6u.py,sha256=n4OMAxg0NXChYaVpWCvx3ZFUxVfynTMy-pyd1CTj9s4,19694
-tplinkrouterc6u/client/c80.py,sha256=ArVhza_fnXcEO-_fsQOd1l2QvmSfsswtohKxrZxEnoU,18568
+tplinkrouterc6u/client/c80.py,sha256=efE0DEjEfzRFr35fjKA_hsv9YaWy_2dgLAaurDM-WQk,17665
 tplinkrouterc6u/client/deco.py,sha256=cpKRggKD2RvSmMZuD6tzsZmehAUCU9oLiTTHcZBW81Y,8898
-tplinkrouterc6u/client/ex.py,sha256=gXWsVKAMo4CsX_Qeihb2iCARcsA3E9m2vgIWiJB3sjs,13197
-tplinkrouterc6u/client/mr.py,sha256=keMii7cetOvY1iq9_gWbWMWjuPShHhLXyrbGwX4Og44,26136
-tplinkrouterc6u/client/mr200.py,sha256=W6MhhRxi7cjw0C8BWvPQdMFmE-eYoIGsStH88OXKiKo,15288
-tplinkrouterc6u/client/re330.py,sha256=ELGc-_SUE4zSnzLuI74z-E4quP8i-Jt6I4905HzE0A0,18661
+tplinkrouterc6u/client/ex.py,sha256=tOcMugCViAcISULg8otp3NjdkPyuUXihcoe_0lql3AQ,14886
+tplinkrouterc6u/client/mr.py,sha256=7MtnKqmtbggWBx6RIiJzlGuSyVDbC8MFynPrc34bSd0,28948
+tplinkrouterc6u/client/mr200.py,sha256=-5CjqK8rbCAyiP7XPLlSJO3xqSPnQ8DeQ6S1jo4XKnc,5786
+tplinkrouterc6u/client/re330.py,sha256=9Wj4VpYJbVwZJUh9s3magdeL3Jl-B7qyrWfrVBxRk4A,17465
 tplinkrouterc6u/client/vr.py,sha256=7Tbu0IrWtr4HHtyrnLFXEJi1QctzhilciL7agtwQ0R8,5025
 tplinkrouterc6u/client/wdr.py,sha256=i54PEifjhfOScDpgNBXygw9U4bfsVtle846_YjnDoBs,21679
-tplinkrouterc6u/client/xdr.py,sha256=QaZ_5vCaf8BV_JEs3S2Nz-QDREBYHGh3OUWIVS-fefY,10406
+tplinkrouterc6u/client/xdr.py,sha256=jdDhQZgJjReN3wMWKch4VHEun2OzUFyzmOWyY5-1IP8,10490
 tplinkrouterc6u/common/__init__.py,sha256=pCTvVZ9CAwgb7MxRnLx0y1rI0sTKSwT24FfxWfQXeTM,33
-tplinkrouterc6u/common/dataclass.py,sha256=mIQFJoDmKZccV5M3NjguIGm7N9ROEt71Weg0ExYWrEQ,7709
-tplinkrouterc6u/common/encryption.py,sha256=4HelTxzN6esMfDZRBt3m8bwB9Nj_biKijnCnrGWPWKg,6228
+tplinkrouterc6u/common/dataclass.py,sha256=NmwN6Iqpd9Ne7Zr-R0J1OZQz28NRp5Qzh6NjVFZV_DA,7749
+tplinkrouterc6u/common/encryption.py,sha256=EWfgGafOz0YgPilBndVaupnjw6JrzhVBdZkBy3oWhj0,10229
 tplinkrouterc6u/common/exception.py,sha256=_0G8ZvW5__CsGifHrsZeULdl8c6EUD071sDCQsQgrHY,140
 tplinkrouterc6u/common/helper.py,sha256=23b04fk9HuVinrZXMCS5R1rmF8uZ7eM-Cdnp7Br9NR0,572
-tplinkrouterc6u/common/package_enum.py,sha256=4ykL_2Pw0nDEIH_qR9UJlFF6stTgSfhPz32r8KT-sh8,1624
-tplinkrouterc6u-5.11.0.dist-info/licenses/LICENSE,sha256=YF6QR6Vjxcg5b_sYIyqkME7FZYau5TfEUGTG-0JeRK0,35129
-tplinkrouterc6u-5.11.0.dist-info/METADATA,sha256=KfWtkeZaFzuCLfpzGduvJfqVbKW_qI3EDnNjEnMLXJM,16663
-tplinkrouterc6u-5.11.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tplinkrouterc6u-5.11.0.dist-info/top_level.txt,sha256=1iSCCIueqgEkrTxtQ-jiHe99jAB10zqrVdBcwvNfe_M,21
-tplinkrouterc6u-5.11.0.dist-info/RECORD,,
+tplinkrouterc6u/common/package_enum.py,sha256=CMHVSgk4RSZyFoPi3499-sJDYg-nfnyJbz1iArFU9Hw,1644
+tplinkrouterc6u-5.12.0.dist-info/licenses/LICENSE,sha256=YF6QR6Vjxcg5b_sYIyqkME7FZYau5TfEUGTG-0JeRK0,35129
+tplinkrouterc6u-5.12.0.dist-info/METADATA,sha256=ZyKhYdvdTxEjUCuFKwlbj8E5nssESZZFRmtGs65pKsk,17267
+tplinkrouterc6u-5.12.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tplinkrouterc6u-5.12.0.dist-info/top_level.txt,sha256=1iSCCIueqgEkrTxtQ-jiHe99jAB10zqrVdBcwvNfe_M,21
+tplinkrouterc6u-5.12.0.dist-info/RECORD,,