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

test/test_client_c6u.py

@@ -603,6 +603,143 @@ class TestTPLinkClient(TestCase):
         self.assertEqual(status.devices[6].packets_sent, 134815)
         self.assertEqual(status.devices[6].packets_received, 2953078)
 
+    def test_get_status_with_game_accelerator_fallback_values(self) -> None:
+        response_status = '''
+    {
+        "success": true,
+        "data": {
+            "lan_macaddr": "06:e6:97:9e:23:f5",
+            "access_devices_wireless_host": [
+                {
+                    "wire_type": "5G",
+                    "macaddr": "f4:aa:bb:cc:dd:ee",
+                    "ipaddr": "192.168.1.110",
+                    "hostname": "CLIENT1"
+                }
+            ]
+        }
+    }
+'''
+        response_game_accelerator = '''
+  {
+      "data": [
+          {"mac": "f4:aa:bb:cc:dd:ee", "deviceTag":"5G", "isGuest":false, "ip":"192.168.1.110",
+          "deviceName":"CLIENT1", "downSpeed":112458738, "upSpeed":704111,
+          "txRate":1441170, "rxRate":1080880, "online_time":34990.64,
+          "trafficUsed":19594852347, "signal": -60},
+          {"deviceName":"no-mac-device"}
+      ],
+      "timeout": false,
+      "success": true
+  }
+'''
+        response_stats = '''
+  {
+      "data": [],
+      "timeout": false,
+      "success": true,
+      "operator": "load"
+  }
+'''
+
+        router_class = self.router_class
+        game_accelerator_path = self.game_accelerator_path
+
+        class TPLinkRouterTest(router_class):
+            def request(self, path: str, data: str,
+                        ignore_response: bool = False, ignore_errors: bool = False) -> dict | None:
+                if path == 'admin/status?form=all&operation=read':
+                    return loads(response_status)['data']
+                elif path == game_accelerator_path:
+                    return loads(response_game_accelerator)['data']
+                elif path == 'admin/wireless?form=statistics':
+                    return loads(response_stats)['data']
+                raise ClientException()
+
+        client = TPLinkRouterTest('', '')
+        status = client.get_status()
+
+        self.assertEqual(len(status.devices), 1)
+        device = status.devices[0]
+        self.assertEqual(device.macaddr, 'F4-AA-BB-CC-DD-EE')
+        self.assertEqual(device.ipaddr, '192.168.1.110')
+        self.assertEqual(device.hostname, 'CLIENT1')
+        self.assertEqual(device.down_speed, 112458738)
+        self.assertEqual(device.up_speed, 704111)
+        self.assertEqual(device.tx_rate, 1441170)
+        self.assertEqual(device.rx_rate, 1080880)
+        self.assertEqual(device.online_time, 34990.64)
+        self.assertEqual(device.traffic_usage, 19594852347)
+        self.assertEqual(device.signal, -60)
+
+    def test_get_status_with_game_accelerator_alt_keys(self) -> None:
+        response_status = '''
+    {
+        "success": true,
+        "data": {
+            "lan_macaddr": "06:e6:97:9e:23:f5",
+            "access_devices_wireless_host": [
+                {
+                    "wire_type": "5G",
+                    "macaddr": "aa:bb:cc:dd:ee:ff",
+                    "ipaddr": "192.168.1.120",
+                    "hostname": "CLIENT2"
+                }
+            ]
+        }
+    }
+'''
+        response_game_accelerator = '''
+  {
+      "data": [
+          {"mac": "aa:bb:cc:dd:ee:ff", "deviceTag":"5G", "isGuest":false, "ip":"192.168.1.120",
+          "deviceName":"CLIENT2", "downloadSpeed":12345, "uploadSpeed":2345,
+          "txrate":300, "rxrate":400, "onlineTime":123.45,
+          "trafficUsage":987654321, "signal": -55}
+      ],
+      "timeout": false,
+      "success": true
+  }
+'''
+        response_stats = '''
+  {
+      "data": [],
+      "timeout": false,
+      "success": true,
+      "operator": "load"
+  }
+'''
+
+        router_class = self.router_class
+        game_accelerator_path = self.game_accelerator_path
+
+        class TPLinkRouterTest(router_class):
+            def request(self, path: str, data: str,
+                        ignore_response: bool = False, ignore_errors: bool = False) -> dict | None:
+                if path == 'admin/status?form=all&operation=read':
+                    return loads(response_status)['data']
+                elif path == game_accelerator_path:
+                    return loads(response_game_accelerator)['data']
+                elif path == 'admin/wireless?form=statistics':
+                    return loads(response_stats)['data']
+                raise ClientException()
+
+        client = TPLinkRouterTest('', '')
+        status = client.get_status()
+
+        self.assertEqual(len(status.devices), 1)
+        device = status.devices[0]
+        self.assertEqual(device.macaddr, 'AA-BB-CC-DD-EE-FF')
+        self.assertEqual(device.ipaddr, '192.168.1.120')
+        self.assertEqual(device.hostname, 'CLIENT2')
+        self.assertEqual(device.down_speed, 12345)
+        self.assertEqual(device.up_speed, 2345)
+        self.assertEqual(device.tx_rate, 300)
+        self.assertEqual(device.rx_rate, 400)
+        self.assertEqual(device.online_time, 123.45)
+        self.assertEqual(device.traffic_usage, 987654321)
+        self.assertEqual(device.signal, -55)
+
     def test_get_status_with_perf_request(self) -> None:
         response_status = '''
     {

test/test_client_ex.py

@@ -6,6 +6,7 @@ from tplinkrouterc6u import (
     Connection,
     Firmware,
     Status,
+    LTEStatus,
     Device,
     IPv4Reservation,
     IPv4DHCPLease,
@@ -705,6 +706,76 @@ class TestTPLinkEXClient(TestCase):
         self.assertEqual(check_data, '{"data":{"stack":"0,0,0,0,0,0","pstack":"0,0,0,0,0,0",'
                                      '"enable":"1"},"operation":"so","oid":"DEV2_OPENVPN"}')
 
+    def test_get_lte_status(self) -> None:
+
+        DEV2_LTE_LINK_CFG = ('{"data":{"enable":"1","wispConnStat":"0","networkType":"3","endcStatus":"-1",'
+                             '"connectedBand":"B3","availableBand":"B3","roamingStatus":"0","connectStatus":"4",'
+                             '"simStatus":"3","simCardNumber":"0","simCardType":"0","simCardState":"1",'
+                             '"simCardImsi":"0","simCardGid1":"010XXXFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",'
+                             '"dataSwitch":"1","roamSwitch":"0","prefNet":"3","timeFactroyFlag":"0",'
+                             '"wlanFactoryFlag":"0","smsScEnable":"0","smsScAddress":"491712121212",'
+                             '"signalStrength":"0","ipv4":"10.171.53.12","dns1v4":"62.109.121.17",'
+                             '"dns2v4":"62.109.121.18","ipv4_mtu":"1500","ipv6":"2a02:3036:282:7376",'
+                             '"ipv6PrefixLen":"64","dns1v6":"2a02:3018:0","dns2v6":"2a02:3018:0:40ff::bbbb",'
+                             '"ipv6_mtu":"1500","ifName":"rmnet_data0","gatewayV4":"10.171.53.2",'
+                             '"gatewayV6":"fe80::4d7c:fa07","netmask":"255.255.255.248","__indexPrimaryServingCell":"",'
+                             '"stack":"1,0,0,0,0,0"},"operation":"go","oid":"DEV2_LTE_LINK_CFG","success":true}')
+        DEV2_XTP_LTE_INTF_CFG = ('{"data":{"enable":"1","freeDurationEnabled":"0","freeDurationWhenRoaming":"0",'
+                                 '"freeDurationStart":"00:00","freeDurationEnd":"00:00","cfgModified":"0",'
+                                 '"dailyFlow":"294896362.0000","currentDate":"1770073200","ledLimitReached":"1",'
+                                 '"allowDialOnce":"0","enableDataLimit":"0","autoDisconnect":"1","dataLimit":"0",'
+                                 '"limitType":"0","limitation":"0","warningPercent":"90","warnSimNumber":"",'
+                                 '"needSmsTip":"0","enablePaymentDay":"1","nextDue":"1772233200","paymentDay":"28",'
+                                 '"adjustStatistics":"-1","curStatistics":"0","curConnTime":"1545647",'
+                                 '"totalStatistics":"38819729967.0000","totalConnTime":"84667","rxFlow":"0",'
+                                 '"txFlow":"0","curRxSpeed":"31921","curTxSpeed":"28242","plmnLock":"0",'
+                                 '"enablePushNotification":"0","stack":"1,0,0,0,0,0"},"operation":"go",'
+                                 '"oid":"DEV2_XTP_LTE_INTF_CFG","success":true}')
+        DEV2_LTE_NET_STATUS = ('{"data":{"ussdSessionStatus":"0","ussdStatus":"0","smsUnreadCount":"0",'
+                               '"smsSendCause":"0","smsSendResult":"3","rfSwitch":"1","sigLevel":"0","connStat":"4",'
+                               '"roamStat":"0","regStat":"1","netType":"3","srvStat":"2","rfInfoChannel":"0",'
+                               '"rfInfoBand":"0","rfInfoIf":"0","rfInfoRat":"0","rfInfoRssi":"0","rfInfoRsrp":"0",'
+                               '"rfInfoRsrq":"0","rfInfoSnr":"0","rfInfoEcio":"0","region":"","callStatus":"0",'
+                               '"stack":"1,0,0,0,0,0"},"operation":"go","oid":"DEV2_LTE_NET_STATUS","success":true}')
+        DEV2_LTE_PROF_STAT = ('{"data":{"activeProfType":"0","activeProfIndex":"0","spn":"","ispWhich":"0",'
+                              '"ispCount":"3","ispMnc":"3","ispMcc":"262","ispName":"O2 2025","usrWhich":"0",'
+                              '"usrCount":"1","usrMnc":"3","usrMcc":"262","stack":"1,0,0,0,0,0"},"operation":"go",'
+                              '"oid":"DEV2_LTE_PROF_STAT","success":true}')
+
+        class TPLinkEXClientTest(TPLinkEXClient):
+            self._token = True
+
+            def _request(self, url, method='POST', data_str=None, encrypt=False):
+                if 'DEV2_LTE_LINK_CFG' in data_str:
+                    return 200, DEV2_LTE_LINK_CFG
+                elif 'DEV2_XTP_LTE_INTF_CFG' in data_str:
+                    return 200, DEV2_XTP_LTE_INTF_CFG
+                elif 'DEV2_LTE_NET_STATUS' in data_str:
+                    return 200, DEV2_LTE_NET_STATUS
+                elif 'DEV2_LTE_PROF_STAT' in data_str:
+                    return 200, DEV2_LTE_PROF_STAT
+                raise ClientException()
+
+        client = TPLinkEXClientTest('', '')
+        status = client.get_lte_status()
+
+        self.assertIsInstance(status, LTEStatus)
+
+        self.assertIsInstance(status, LTEStatus)
+        self.assertEqual(status.enable, 1)
+        self.assertEqual(status.connect_status, 4)
+        self.assertEqual(status.network_type, 3)
+        self.assertEqual(status.sim_status, 3)
+        self.assertEqual(status.sig_level, 0)
+        self.assertEqual(status.total_statistics, 38819729967)
+        self.assertEqual(status.cur_rx_speed, 31921)
+        self.assertEqual(status.cur_tx_speed, 28242)
+        self.assertEqual(status.sms_unread_count, 0)
+        self.assertEqual(status.rsrp, 0)
+        self.assertEqual(status.rsrq, 0)
+        self.assertEqual(status.snr, 0)
+        self.assertEqual(status.isp_name, 'O2 2025')
+
 
 if __name__ == '__main__':
     main()

test/test_client_sg.py

@@ -0,0 +1,217 @@
+import json
+from hashlib import sha256
+from unittest import main, TestCase
+from unittest.mock import patch, Mock
+
+from tplinkrouterc6u import TplinkRouterSG, ClientException
+from test_client_c6u import TestTPLinkClient
+
+
+class TestTPLinkClientSG(TestTPLinkClient):
+    """Inherits get_status and other tests from TestTPLinkClient."""
+
+    router_class = TplinkRouterSG
+    game_accelerator_path = 'admin/smart_network?form=game_accelerator&operation=loadDevice'
+    openvpn_config_path = 'admin/openvpn?form=config&operation=read'
+    pptpd_config_path = 'admin/pptpd?form=config&operation=read'
+    vpn_uses_data_param = False
+
+
+class TestTplinkRouterSGUnit(TestCase):
+    """Unit tests specific to TplinkRouterSG authentication and encryption."""
+
+    def test_supports_password_too_long(self) -> None:
+        long_password = 'a' * 126
+        client = TplinkRouterSG('http://192.168.0.1', long_password)
+        self.assertFalse(client.supports())
+
+    @patch('tplinkrouterc6u.client.sg.post')
+    def test_check_sg_certification_match(self, mock_post: Mock) -> None:
+        response = Mock()
+        response.json.return_value = {
+            'data': {
+                'certification': ['SG CLS L1 STAGE2', 'OTHER']
+            }
+        }
+        mock_post.return_value = response
+
+        client = TplinkRouterSG('http://192.168.0.1', 'testpassword')
+        result = client._check_sg_certification()
+
+        self.assertTrue(result)
+        self.assertEqual(mock_post.call_count, 1)
+        call_args = mock_post.call_args
+        self.assertIn('device_config', call_args[0][0])
+
+    @patch('tplinkrouterc6u.client.sg.post')
+    def test_check_sg_certification_no_match(self, mock_post: Mock) -> None:
+        response = Mock()
+        response.json.return_value = {
+            'data': {
+                'certification': ['SOME_OTHER_CERT']
+            }
+        }
+        mock_post.return_value = response
+
+        client = TplinkRouterSG('http://192.168.0.1', 'testpassword')
+        result = client._check_sg_certification()
+
+        self.assertFalse(result)
+
+    @patch('tplinkrouterc6u.client.sg.post')
+    def test_authorize_success(self, mock_post: Mock) -> None:
+        pwd_keys_response = Mock()
+        pwd_keys_response.json.return_value = {
+            'data': {
+                'password': ['mock_pwd_nn', '010001']
+            }
+        }
+
+        auth_keys_response = Mock()
+        auth_keys_response.json.return_value = {
+            'data': {
+                'seq': 100,
+                'key': ['mock_auth_nn', '010001']
+            }
+        }
+
+        login_response = Mock()
+        login_response.json.return_value = {'data': 'encrypted_login_blob'}
+        login_response.headers = {
+            'set-cookie': 'sysauth=test_sysauth_value; path=/'
+        }
+        login_response.text = 'mock response text'
+
+        mock_post.side_effect = [
+            pwd_keys_response,
+            auth_keys_response,
+            login_response,
+        ]
+
+        client = TplinkRouterSG('http://192.168.0.1', 'testpassword')
+
+        login_result = json.dumps({
+            'success': True,
+            'data': {'stok': 'test_stok_12345'}
+        })
+        with patch.object(client, '_rsa_v15_encrypt', return_value='encrypted_pwd_hex'), \
+             patch.object(client, '_aes_encrypt', return_value='encrypted_data_b64'), \
+             patch.object(client, '_build_login_signature', return_value='mock_sign'), \
+             patch.object(client, '_aes_decrypt', return_value=login_result):
+            client.authorize()
+
+        self.assertTrue(client._logged)
+        self.assertEqual(client._stok, 'test_stok_12345')
+        self.assertEqual(client._sysauth, 'test_sysauth_value')
+        self.assertEqual(mock_post.call_count, 3)
+
+        first_call = mock_post.call_args_list[0]
+        self.assertIn('login?form=keys', first_call[0][0])
+
+        second_call = mock_post.call_args_list[1]
+        self.assertIn('login?form=auth', second_call[0][0])
+
+        third_call = mock_post.call_args_list[2]
+        self.assertIn('login?form=login', third_call[0][0])
+
+    @patch('tplinkrouterc6u.client.sg.post')
+    def test_authorize_failure(self, mock_post: Mock) -> None:
+        pwd_keys_response = Mock()
+        pwd_keys_response.json.return_value = {
+            'data': {
+                'password': ['mock_pwd_nn', '010001']
+            }
+        }
+
+        auth_keys_response = Mock()
+        auth_keys_response.json.return_value = {
+            'data': {
+                'seq': 100,
+                'key': ['mock_auth_nn', '010001']
+            }
+        }
+
+        login_response = Mock()
+        login_response.json.return_value = {'data': 'encrypted_login_blob'}
+        login_response.headers = {}
+        login_response.text = 'mock error response'
+
+        mock_post.side_effect = [
+            pwd_keys_response,
+            auth_keys_response,
+            login_response,
+        ]
+
+        client = TplinkRouterSG('http://192.168.0.1', 'wrongpassword')
+
+        login_result = json.dumps({
+            'success': False,
+            'data': {'errorcode': 'invalid password'}
+        })
+        with patch.object(client, '_rsa_v15_encrypt', return_value='encrypted_pwd_hex'), \
+             patch.object(client, '_aes_encrypt', return_value='encrypted_data_b64'), \
+             patch.object(client, '_build_login_signature', return_value='mock_sign'), \
+             patch.object(client, '_aes_decrypt', return_value=login_result):
+            with self.assertRaises(ClientException) as context:
+                client.authorize()
+
+        self.assertIn('Login failed', str(context.exception))
+        self.assertFalse(client._logged)
+
+    def test_authorize_uses_username(self) -> None:
+        """Verify SHA256 hash uses self.username, not hardcoded 'admin'."""
+        client = TplinkRouterSG(
+            'http://192.168.0.1', 'testpassword', username='customuser')
+
+        expected_hash = sha256(
+            ('customuser' + 'testpassword').encode()).hexdigest()
+        admin_hash = sha256(
+            ('admin' + 'testpassword').encode()).hexdigest()
+
+        # Simulate the hash computation that happens in authorize()
+        client._hash = sha256(
+            (client.username + client.password).encode()).hexdigest()
+
+        self.assertEqual(client._hash, expected_hash)
+        self.assertNotEqual(client._hash, admin_hash)
+
+    @patch('tplinkrouterc6u.client.sg.post')
+    def test_request_hmac_signature(self, mock_post: Mock) -> None:
+        """Verify non-login requests use HMAC-SHA256 signature."""
+        client = TplinkRouterSG('http://192.168.0.1', 'testpassword')
+        client._logged = True
+        client._stok = 'test_stok'
+        client._sysauth = 'test_sysauth'
+        client._aes_key = '1234567890123456'
+        client._aes_iv = '6543210987654321'
+        client._hash = 'fakehash'
+        client._seq = 100
+
+        response = Mock()
+        decrypted_data = json.dumps({
+            'success': True,
+            'data': {'key': 'value'}
+        })
+        response.json.return_value = {'data': 'encrypted'}
+
+        mock_post.return_value = response
+
+        with patch.object(
+            client, '_aes_decrypt', return_value=decrypted_data
+        ):
+            result = client.request(
+                'admin/status?form=all', 'operation=read')
+
+        self.assertEqual(result, {'key': 'value'})
+
+        call_kwargs = mock_post.call_args
+        body = call_kwargs[1]['data']
+        self.assertTrue(body.startswith('sign='))
+        self.assertIn('&data=', body)
+
+        # Hash should have been updated to SHA256 of the encrypted data
+        self.assertNotEqual(client._hash, 'fakehash')
+
+
+if __name__ == '__main__':
+    main()

tplinkrouterc6u/__init__.py

@@ -1,4 +1,5 @@
 from tplinkrouterc6u.client.c6u import TplinkRouter, TplinkRouterV1_11
+from tplinkrouterc6u.client.sg import TplinkRouterSG
 from tplinkrouterc6u.client.deco import TPLinkDecoClient
 from tplinkrouterc6u.client_abstract import AbstractRouter
 from tplinkrouterc6u.client.mr import TPLinkMRClient, TPLinkMRClientGCM

tplinkrouterc6u/client/c6u.py

@@ -348,18 +348,27 @@ class TplinkBaseRouter(AbstractRouter, TplinkRequest):
 
         if smart_network:
             for item in smart_network:
-                if item['mac'] not in devices:
+                mac = item.get('mac')
+                if not mac:
+                    continue
+
+                if mac not in devices:
                     conn = self._map_wire_type(item.get('deviceTag'), not item.get('isGuest'))
-                    devices[item['mac']] = Device(conn, get_mac(item.get('mac', '00:00:00:00:00:00')),
-                                                  get_ip(item['ip']), item['deviceName'])
+                    devices[mac] = Device(conn, get_mac(item.get('mac', '00:00:00:00:00:00')),
+                                          get_ip(item.get('ip', '0.0.0.0')), item.get('deviceName', ''))
                     if conn.is_iot():
                         if status.iot_clients_total is None:
                             status.iot_clients_total = 0
                         status.iot_clients_total += 1
 
-                devices[item['mac']].down_speed = item.get('downloadSpeed')
-                devices[item['mac']].up_speed = item.get('uploadSpeed')
-                devices[item['mac']].signal = int(item.get('signal')) if item.get('signal') else None
+                device = devices[mac]
+                device.down_speed = item.get('downloadSpeed', item.get('downSpeed'))
+                device.up_speed = item.get('uploadSpeed', item.get('upSpeed'))
+                device.tx_rate = item.get('txrate', item.get('txRate'))
+                device.rx_rate = item.get('rxrate', item.get('rxRate'))
+                device.online_time = item.get('onlineTime', item.get('online_time'))
+                device.traffic_usage = item.get('trafficUsage', item.get('trafficUsed'))
+                device.signal = int(item.get('signal')) if item.get('signal') else None
 
         try:
             wireless_stats = self.request('admin/wireless?form=statistics', 'operation=load')
@@ -514,7 +523,10 @@ class TplinkRouterV1_11(TplinkBaseRouter):
         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
+            if len(self._pwdNN) >= 512:
+                self.authorize()
+                self.logout()
+                return True
         except Exception:
             return False
 
@@ -534,7 +546,7 @@ class TplinkRouterV1_11(TplinkBaseRouter):
             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 - {}'
+            error = ('TplinkRouterV1_11 - {} - Failed to get encryption keys! Error - {}; Response - {}'
                      .format(self.__class__.__name__, e, response.text))
             if self._logger:
                 self._logger.debug(error)
@@ -563,7 +575,7 @@ class TplinkRouterV1_11(TplinkBaseRouter):
             if not data.get('success'):
                 error_info = data.get(self._data_block, {})
                 raise ClientException(
-                    'TplinkRouter - {} - Login failed: {}'.format(
+                    'TplinkRouterV1_11 - {} - Login failed: {}'.format(
                         self.__class__.__name__,
                         error_info.get('errorcode', 'unknown error')
                     )
@@ -582,7 +594,7 @@ class TplinkRouterV1_11(TplinkBaseRouter):
         except ClientException:
             raise
         except Exception as e:
-            error = ('TplinkRouter - {} - Cannot authorize! Error - {}; Response - {}'
+            error = ('TplinkRouterV1_11 - {} - Cannot authorize! Error - {}; Response - {}'
                      .format(self.__class__.__name__, e, response.text))
             if self._logger:
                 self._logger.debug(error)

tplinkrouterc6u/client/ex.py

@@ -13,6 +13,7 @@ from tplinkrouterc6u.common.dataclass import (
     IPv4Reservation,
     IPv4DHCPLease,
     IPv4Status,
+    LTEStatus,
     VPNStatus)
 from tplinkrouterc6u.common.exception import ClientException, ClientError
 from tplinkrouterc6u.client.mr import TPLinkMRClientBase, TPLinkMRClientBaseGCM
@@ -238,6 +239,38 @@ class TPLinkEXClient(TPLinkMRClientBase):
         ]
         self.req_act(acts)
 
+    def get_lte_status(self) -> LTEStatus:
+        status = LTEStatus()
+        acts = [
+            self.ActItem(self.ActItem.GET, 'DEV2_LTE_LINK_CFG', '1,0,0,0,0,0',
+                         attrs=['enable', 'connectStatus', 'networkType', 'simStatus']),
+            self.ActItem(self.ActItem.GET, 'DEV2_XTP_LTE_INTF_CFG', '1,0,0,0,0,0',
+                         attrs=['totalStatistics', 'curRxSpeed', 'curTxSpeed']),
+            self.ActItem(self.ActItem.GET, 'DEV2_LTE_NET_STATUS', '1,0,0,0,0,0',
+                         attrs=['smsUnreadCount', 'sigLevel', 'rfInfoRsrp', 'rfInfoRsrq', 'rfInfoSnr']),
+            self.ActItem(self.ActItem.GET, 'DEV2_LTE_PROF_STAT', '1,0,0,0,0,0', attrs=['ispName']),
+        ]
+        _, 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.total_statistics = int(float(values[1]['totalStatistics']))
+        status.cur_rx_speed = int(values[1]['curRxSpeed'])
+        status.cur_tx_speed = int(values[1]['curTxSpeed'])
+
+        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[3]['ispName']
+
+        return status
+
     def req_act(self, acts: list):
         '''
         Requests ACTs via the cgi_gdpr proxy

tplinkrouterc6u/client/mr200.py

@@ -91,7 +91,8 @@ class TPLinkMR200Client(TPLinkMRClient):
         status = LTEStatus()
         acts = [
             self.ActItem(self.ActItem.GET, 'WAN_LTE_LINK_CFG', '2,1,0,0,0,0',
-                         attrs=['enable', 'connectStatus', 'networkType', 'roamingStatus', 'simStatus']),
+                         attrs=['enable', 'connectStatus', 'networkType', 'roamingStatus', 'simStatus',
+                                'signalStrength']),
             self.ActItem(self.ActItem.GET, 'WAN_LTE_INTF_CFG', '2,0,0,0,0,0',
                          attrs=['dataLimit', 'enablePaymentDay', 'curStatistics', 'totalStatistics', 'enableDataLimit',
                                 'limitation',

tplinkrouterc6u/client/sg.py

@@ -0,0 +1,285 @@
+"""
+TP-Link router client for SG_L1_S2 / CE_RED certified devices.
+
+Routers with these certifications (e.g., Archer BE3600, Wi-Fi 7 models)
+use an enhanced encryption scheme:
+  1. SHA256 hash instead of MD5 for authentication
+  2. PKCS1-OAEP RSA padding for login signature encryption
+  3. HMAC-SHA256 for non-login request signatures
+  4. Dynamic hash replacement: SHA256(encrypted_data) per request
+
+Fixes: https://github.com/AlexandrErohin/home-assistant-tplink-router/issues/220
+"""
+
+import hmac
+import json
+from re import search
+from hashlib import sha256
+from base64 import b64encode, b64decode
+from random import randint
+from logging import Logger
+from urllib.parse import quote
+
+from Crypto.PublicKey.RSA import construct
+from Crypto.Cipher import PKCS1_OAEP, PKCS1_v1_5, AES
+from Crypto.Util.Padding import pad, unpad
+from binascii import hexlify
+from requests import post
+
+from tplinkrouterc6u.client.c6u import TplinkBaseRouter
+from tplinkrouterc6u.common.exception import ClientException, ClientError
+
+# SG_L1_S2 and CE_RED certifications that trigger enhanced encryption
+SG_CERTIFICATIONS = ['SG CLS L1 STAGE2', 'EU CE RED']
+
+SIGNATURE_OFFSET = 53
+AES_KEY_LEN = 16
+
+
+class TplinkRouterSG(TplinkBaseRouter):
+    """
+    Client for TP-Link routers with SG_L1_S2 / CE_RED certification.
+
+    These routers use SHA256 + OAEP + HMAC-SHA256 instead of the standard
+    MD5 + PKCS1_v1_5 + RSA encryption scheme.
+    """
+
+    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._aes_key = ''
+        self._aes_iv = ''
+        self._hash = ''
+        self._seq = 0
+        self._nn = ''
+        self._ee = ''
+        self._pwdNN = ''
+        self._pwdEE = ''
+        self._data_block = 'data'
+
+    def supports(self) -> bool:
+        """Check if this router uses SG/CE_RED encryption."""
+        if len(self.password) > 125:
+            return False
+        try:
+            if not self._check_sg_certification():
+                return False
+            self._request_pwd_keys()
+            return True
+        except Exception:
+            return False
+
+    def _check_sg_certification(self) -> bool:
+        """Check if the router has SG_L1_S2 or CE_RED certification."""
+        url = '{}/cgi-bin/luci/;stok=/device_config?form=config'.format(self.host)
+        response = post(
+            url, data='operation=read',
+            headers=self._headers_login,
+            timeout=self.timeout, verify=self._verify_ssl,
+        )
+        try:
+            data = response.json()
+            certs = data.get('data', {}).get('certification', [])
+            return any(c in SG_CERTIFICATIONS for c in certs)
+        except Exception:
+            return False
+
+    def _generate_aes_key(self) -> None:
+        """Generate random AES key and IV (16 random digits, matching JS behavior)."""
+        self._aes_key = ''.join([str(randint(0, 9)) for _ in range(AES_KEY_LEN)])
+        self._aes_iv = ''.join([str(randint(0, 9)) for _ in range(AES_KEY_LEN)])
+
+    def _aes_encrypt(self, data: str) -> str:
+        """AES-CBC encrypt with PKCS7 padding."""
+        cipher = AES.new(self._aes_key.encode(), AES.MODE_CBC, self._aes_iv.encode())
+        return b64encode(cipher.encrypt(pad(data.encode(), AES.block_size))).decode()
+
+    def _aes_decrypt(self, data: str) -> str:
+        """AES-CBC decrypt with PKCS7 unpadding."""
+        cipher = AES.new(self._aes_key.encode(), AES.MODE_CBC, self._aes_iv.encode())
+        return unpad(cipher.decrypt(b64decode(data)), AES.block_size).decode()
+
+    @staticmethod
+    def _rsa_v15_encrypt(data: str, n_hex: str, e_hex: str) -> str:
+        """RSA encrypt with PKCS1 v1.5 padding (used for password encryption)."""
+        key = construct((int(n_hex, 16), int(e_hex, 16)))
+        cipher = PKCS1_v1_5.new(key)
+        result = hexlify(cipher.encrypt(data.encode())).decode()
+        key_len = len(n_hex)
+        return result.zfill(key_len) if len(result) < key_len else result
+
+    @staticmethod
+    def _rsa_oaep_encrypt(data: str, n_hex: str, e_hex: str) -> str:
+        """RSA encrypt with PKCS1-OAEP padding (used for login signature)."""
+        key = construct((int(n_hex, 16), int(e_hex, 16)))
+        cipher = PKCS1_OAEP.new(key)
+        result = hexlify(cipher.encrypt(data.encode())).decode()
+        key_len = len(n_hex)
+        return result.zfill(key_len) if len(result) < key_len else result
+
+    def _get_aes_formatted_key(self) -> str:
+        return 'k={}&i={}'.format(self._aes_key, self._aes_iv)
+
+    def _request_pwd_keys(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['data']['password'][0]
+            self._pwdEE = data['data']['password'][1]
+        except Exception as e:
+            error = ('TplinkRouterSG - Failed to get password keys: {}'.format(e))
+            if self._logger:
+                self._logger.debug(error)
+            raise ClientException(error)
+
+    def _request_auth_keys(self) -> None:
+        """Get sequence number and RSA public key for data encryption."""
+        url = '{}/cgi-bin/luci/;stok=/login?form=auth'.format(self.host)
+        response = post(
+            url, params={'operation': 'read'},
+            timeout=self.timeout, verify=self._verify_ssl,
+        )
+        try:
+            data = response.json()
+            self._seq = data['data']['seq']
+            self._nn = data['data']['key'][0]
+            self._ee = data['data']['key'][1]
+        except Exception as e:
+            error = ('TplinkRouterSG - Failed to get auth keys: {}'.format(e))
+            if self._logger:
+                self._logger.debug(error)
+            raise ClientException(error)
+
+    def _build_login_signature(self, data_len: int) -> str:
+        """Build RSA-OAEP encrypted signature for login requests."""
+        sign_str = '{}&h={}&s={}'.format(
+            self._get_aes_formatted_key(), self._hash, self._seq + data_len)
+        sign = ''
+        for i in range(0, len(sign_str), SIGNATURE_OFFSET):
+            chunk = sign_str[i:i + SIGNATURE_OFFSET]
+            sign += self._rsa_oaep_encrypt(chunk, self._nn, self._ee)
+        return sign
+
+    def _build_request_signature(self, data_len: int) -> str:
+        """Build HMAC-SHA256 signature for non-login requests."""
+        sign_str = 'h={}&s={}'.format(self._hash, self._seq + data_len)
+        aes_key = self._get_aes_formatted_key()
+        sign = ''
+        for i in range(0, len(sign_str), SIGNATURE_OFFSET):
+            chunk = sign_str[i:i + SIGNATURE_OFFSET]
+            h = hmac.new(aes_key.encode(), chunk.encode(), sha256)
+            sign += h.hexdigest()
+        return sign
+
+    def authorize(self) -> None:
+        """Authorize using SHA256 + OAEP encryption scheme."""
+        self._request_pwd_keys()
+        self._request_auth_keys()
+
+        # SHA256 hash of username + password (not MD5)
+        self._hash = sha256((self.username + self.password).encode()).hexdigest()
+
+        # Generate AES session key
+        self._generate_aes_key()
+
+        # RSA encrypt password with PKCS1 v1.5 (password uses v1.5, not OAEP)
+        encrypted_pwd = self._rsa_v15_encrypt(self.password, self._pwdNN, self._pwdEE)
+
+        # Build and AES-encrypt the login payload
+        login_data = 'operation=login&password={}&confirm=true'.format(encrypted_pwd)
+        encrypted_data = self._aes_encrypt(login_data)
+
+        # Build OAEP-encrypted signature
+        sign = self._build_login_signature(len(encrypted_data))
+
+        # Send login request
+        url = '{}/cgi-bin/luci/;stok=/login?form=login'.format(self.host)
+        body = 'sign={}&data={}'.format(sign, quote(encrypted_data))
+        response = post(
+            url, data=body, headers=self._headers_login,
+            timeout=self.timeout, verify=self._verify_ssl,
+        )
+
+        try:
+            resp = response.json()
+            decrypted = json.loads(self._aes_decrypt(resp['data']))
+
+            if not decrypted.get('success'):
+                error_data = decrypted.get('data', {})
+                raise ClientException(
+                    'TplinkRouterSG - Login failed: {}'.format(
+                        error_data.get('errorcode', 'unknown')))
+
+            self._stok = decrypted['data']['stok']
+            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 = ('TplinkRouterSG - Cannot authorize! Error - {}; Response - {}'
+                     .format(e, response.text[:200] if response.text else ''))
+            if self._logger:
+                self._logger.debug(error)
+            raise ClientException(error)
+
+    def request(self, path: str, data: str,
+                ignore_response: bool = False,
+                ignore_errors: bool = False) -> dict | None:
+        """Make an authenticated request using HMAC-SHA256 signatures."""
+        if self._logged is False:
+            raise Exception('Not authorised')
+
+        # AES encrypt the request data
+        encrypted_data = self._aes_encrypt(data)
+
+        # REPLACE_HASH: update hash with SHA256 of encrypted data
+        self._hash = sha256(encrypted_data.encode()).hexdigest()
+
+        # Build HMAC-SHA256 signature
+        sign = self._build_request_signature(len(encrypted_data))
+
+        url = '{}/cgi-bin/luci/;stok={}/{}'.format(self.host, self._stok, path)
+        body = 'sign={}&data={}'.format(sign, quote(encrypted_data))
+        response = post(
+            url, data=body, headers=self._headers_request,
+            cookies={'sysauth': self._sysauth},
+            timeout=self.timeout, verify=self._verify_ssl,
+        )
+
+        if ignore_response:
+            return None
+
+        try:
+            resp = response.json()
+            decrypted = json.loads(self._aes_decrypt(resp['data']))
+
+            if self._is_valid_response(decrypted):
+                return decrypted.get(self._data_block)
+            elif ignore_errors:
+                return decrypted
+        except Exception as e:
+            error = ('TplinkRouterSG - Unknown response - {}; Request {} - Response {}'
+                     .format(e, path, response.text[:200] if response.text else ''))
+            if self._logger:
+                self._logger.debug(error)
+            raise ClientError(error)
+
+        error = ('TplinkRouterSG - Response with error; Request {} - Response {}'
+                 .format(path, response.text[:200] if response.text else ''))
+        if self._logger:
+            self._logger.debug(error)
+        raise ClientError(error)
+
+    def _is_valid_response(self, data: dict) -> bool:
+        return 'success' in data and data['success'] and self._data_block in data

tplinkrouterc6u/common/dataclass.py

@@ -22,6 +22,10 @@ class Device:
     packets_received: int | None = None
     down_speed: int | None = None
     up_speed: int | None = None
+    tx_rate: int | None = None
+    rx_rate: int | None = None
+    online_time: float | None = None
+    traffic_usage: int | None = None
     signal: int | None = None
     active: bool = True
 

tplinkrouterc6u/provider.py

@@ -3,6 +3,7 @@ from logging import Logger
 from tplinkrouterc6u import TPLinkXDRClient
 from tplinkrouterc6u.common.exception import ClientException
 from tplinkrouterc6u.client.c6u import TplinkRouter, TplinkRouterV1_11
+from tplinkrouterc6u.client.sg import TplinkRouterSG
 from tplinkrouterc6u.client.deco import TPLinkDecoClient
 from tplinkrouterc6u.client_abstract import AbstractRouter
 from tplinkrouterc6u.client.mr import TPLinkMRClient, TPLinkMRClientGCM
@@ -37,6 +38,7 @@ class TplinkRouterProvider:
                        TPLinkDecoClient,
                        TPLinkXDRClient,
                        TPLinkRClient,
+                       TplinkRouterSG,
                        TplinkRouterV1_11,
                        TplinkRouter,
                        TplinkC80Router,

{tplinkrouterc6u-5.14.0.dist-info → tplinkrouterc6u-5.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tplinkrouterc6u
-Version: 5.14.0
+Version: 5.15.0
 Summary: TP-Link Router API (supports also Mercusys Router)
 Home-page: https://github.com/AlexandrErohin/TP-Link-Archer-C6U
 Author: Alex Erohin
@@ -57,6 +57,7 @@ Python package for API access and management for TP-Link and Mercusys Routers. S
 from tplinkrouterc6u import (
     TplinkRouterProvider,
     TplinkRouterV1_11,
+    TplinkRouterSG, # For routers like Archer BE3600, Archer BE230
     TplinkRouter,
     TplinkC1200Router,
     TplinkC5400XRouter,
@@ -68,7 +69,7 @@ from tplinkrouterc6u import (
     TPLinkVR400v2Client,
     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
-    TPLinkRClient,
+    TPLinkRClient, # For routers like TL-R470GP-AC
     TPLinkXDRClient,
     TPLinkDecoClient,
     TplinkC80Router,
@@ -83,11 +84,11 @@ router = TplinkRouterProvider.get_client('http://192.168.0.1', 'password')
 # You may use client directly like
 # router = TplinkRouter('http://192.168.0.1', 'password')
 # You may also pass username if it is different and a logger to log errors as
-# router = TplinkRouter('http://192.168.0.1','password','admin2', Logger('test'))
+# router = TplinkRouter('http://192.168.0.1','password','admin2', logger=Logger('test'))
 # If you have the TP-link C5400X or similar, you can use the TplinkC5400XRouter class instead of the TplinkRouter class.
 # Remember that the password for this router is different, here you need to use the web encrypted password.
 # To get web encrypted password, read Web Encrypted Password section
-# router = TplinkC5400XRouter('http://192.168.0.1','WebEncryptedPassword', logger: Logger('test'))
+# router = TplinkC5400XRouter('http://192.168.0.1','WebEncryptedPassword', logger=Logger('test'))
 
 try:
     router.authorize()  # authorizing
@@ -202,6 +203,10 @@ or you have TP-link C5400X or similar router you need to get web encrypted passw
 | packets_received | total packets received | int, None |
 | down_speed | download speed | int, None |
 | up_speed | upload speed | int, None |
+| tx_rate | transmit rate (Mbps) | int, None |
+| rx_rate | receive rate (Mbps) | int, None |
+| online_time | client online time (seconds) | float, None |
+| traffic_usage | total traffic usage (bytes) | int, None |
 | signal | Signal strength | int, None |
 | active | Is active device | bool |
 
@@ -315,6 +320,7 @@ or you have TP-link C5400X or similar router you need to get web encrypted passw
 - Archer A7 V5
 - Archer A8 (1.0, 2.20)
 - Archer A9 V6
+- Archer A10 v1
 - Archer A20 v1.0
 - Archer AX10 v1.0
 - Archer AX12 v1.0
@@ -344,10 +350,10 @@ or you have TP-link C5400X or similar router you need to get web encrypted passw
 - Archer BE550 v1.0
 - Archer BE800 v1.0
 - Archer BE805 v1.0
-- Archer BE3600 1.6
+- Archer BE3600 (v1.0, v1.6)
 - Archer C1200 (v1.0, v2.0)
 - Archer C2300 (v1.0, v2.0)
-- Archer C3200
+- Archer C3200 v1
 - Archer C6 (v2.0, v3.0, v3.20, 4.0)
 - Archer C6U v1.0
 - Archer C7 (v4.0, v5.0)
@@ -360,7 +366,7 @@ or you have TP-link C5400X or similar router you need to get web encrypted passw
 - Archer MR200 (v2, v5, v5.3, v6.0)
 - Archer MR550 v1
 - Archer MR600 (v1, v2, v3)
-- Archer NX200 v2.0
+- Archer NX200 (v1.0, v2.0)
 - Archer VR400 (v2, v3)
 - Archer VR600 v3
 - Archer VR900v
@@ -387,6 +393,7 @@ or you have TP-link C5400X or similar router you need to get web encrypted passw
 - HX510 v1.0
 - M8550 v1
 - NE200-Outdoor v1.0
+- NE211-Outdoor v1.0
 - NX510v v1.0
 - NX600 v2.0
 - TD-W9960 (v1, V1.20)

{tplinkrouterc6u-5.14.0.dist-info → tplinkrouterc6u-5.15.0.dist-info}/RECORD

@@ -1,46 +1,48 @@
 test/__init__.py,sha256=McQmUjeN3AwmwdS6QNfwGXXE77OKoPK852I2BM9XsrU,210
 test/test_client_C3200.py,sha256=jQoGq3yasoOc2Da37RkZ8uT0uyFrKfX2OGGy7hq02A0,20932
 test/test_client_c1200.py,sha256=Sl-85JGqINNg-ckBZCIVqY0CC-V1UOc-yiIUljtePRM,7582
-test/test_client_c6u.py,sha256=GGYReY9RmnkJDgcaWtzbti-hTkab2D8JXxZCPt0wTfk,41662
+test/test_client_c6u.py,sha256=ZdIMNpnLrwH6a4E6Myb8tz6S0qtiVOJ9ye4mmn-vVCI,46579
 test/test_client_c6u_v1_11.py,sha256=FkpDRYk-LKC_YFNyrDUZUm7_x89REMnl4zquiEtyFB4,3343
 test/test_client_c80.py,sha256=RY_1SgRVcQQdN9h0_IXA0YW4_0flEB_uel05QvDDfws,42359
 test/test_client_deco.py,sha256=YPLKRD8GoyDYHfRgdXvCk8iVNw8zdMJW-AHVnNbpdTM,31719
-test/test_client_ex.py,sha256=_HvQhT2dG63fg6kJkgnZoPwa9qCgFDjWSAYQfjgVRA4,40480
+test/test_client_ex.py,sha256=IPPqFllDFCn2-StsV3cv3GuIDgwXM75x4wk8dSXN8eA,45556
 test/test_client_mr.py,sha256=HYn39wynxeWKyWLGKpnBrutnb1Yq6k1tp6_vH-L_UKQ,33839
 test/test_client_mr_200.py,sha256=86yANn5SUhVW6Uc5q5s_aTNL7tDnREeXk378G61v_TM,1186
 test/test_client_r.py,sha256=AMZklBTLDmnlluNu8hyJfty-1lnN9YReIT522D2Bf9c,20565
 test/test_client_re330.py,sha256=MgefuvOzfZtZOujrcOsjiTDiGEAujfeFXshcq7gn32Q,17044
+test/test_client_sg.py,sha256=p8YlashUz370XFEY40PqiXE7CauEbUHEroTUjRIzjS8,7722
 test/test_client_vr400v2.py,sha256=J1MFUQKGX0czhYS2s8q1Fa8-aKAZ9RfWb0rE_yAxXmg,1813
 test/test_client_wdr.py,sha256=0ZnRNP57MbuMv2cxFS8iIoVyv8Q6gtY0Q03gtHp9AWY,13492
 test/test_client_xdr.py,sha256=o0d1mq5ev1wWcs7FvwYGMUKDSVZJREETZk__7Al5EtI,23640
-tplinkrouterc6u/__init__.py,sha256=K5c8sBDldVKcD_OfMB83U3xfEkLyRfxdE3VAtbsMMAo,1419
+tplinkrouterc6u/__init__.py,sha256=ekYOi1CJEH-OvqC7OgsYPUTkwt0kokD3xGVhSLMUh6A,1472
 tplinkrouterc6u/client_abstract.py,sha256=3UYzmll774S_Gb5E0FTVO_rI3-XFM7PSklg1-V-2jls,1419
-tplinkrouterc6u/provider.py,sha256=XeUXzrpgo35DhFG7FvgcAtD0oZZlXl8OOyPfNAVfxMI,3224
+tplinkrouterc6u/provider.py,sha256=TsKKhMSrE6ZhTJL3qf8T34lw3-t68KmHdp6EvzFaUwc,3316
 tplinkrouterc6u/client/__init__.py,sha256=KBy3fmtA9wgyFrb0Urh2x4CkKtWVnESdp-vxmuOvq0k,27
 tplinkrouterc6u/client/c1200.py,sha256=4XEYidEGmVIJk0YQLvmTnd0Gqa7glH2gUWvjreHpWrk,3178
 tplinkrouterc6u/client/c3200.py,sha256=GjaOjcVoKlRiSjn19d1rEIfZbIP_6SWsqDlsd_BbC7I,7057
 tplinkrouterc6u/client/c5400x.py,sha256=ID9jC-kLUBBeETvOh8cxyQpKmJBIzdwNYR03DmvMN0s,4289
-tplinkrouterc6u/client/c6u.py,sha256=7OGRnAfc9S7-v2-CrM0rayqesYkhIPouK7LJUV2opno,23574
+tplinkrouterc6u/client/c6u.py,sha256=Owf-nZmqVK4lvP86_oYbs5kBdJtlfew_r8iHrasSv1Q,24130
 tplinkrouterc6u/client/c80.py,sha256=efE0DEjEfzRFr35fjKA_hsv9YaWy_2dgLAaurDM-WQk,17665
 tplinkrouterc6u/client/deco.py,sha256=cpKRggKD2RvSmMZuD6tzsZmehAUCU9oLiTTHcZBW81Y,8898
-tplinkrouterc6u/client/ex.py,sha256=qqlVJi2BIlMLjL9A2_Yi-5AFk18A1Ts8zW6qRPQQWQM,15016
+tplinkrouterc6u/client/ex.py,sha256=ujUzhrRyzbV2vTIbDqiiuWybOOWVNjHHD8VnkGqbVjA,16556
 tplinkrouterc6u/client/mr.py,sha256=Yh7U0nWa_l5HKrUM5fDGewQlxHlyK-JcoPFXmSDgog4,29606
-tplinkrouterc6u/client/mr200.py,sha256=Z02ew7ZLCEdNyGB7mcPHPP-oaAUwJyt7euc2ubiuEo4,5891
+tplinkrouterc6u/client/mr200.py,sha256=vqBnx8JzdegXzOBfyPo_AjsPpbYZHxzNSeW0cqBmTqY,5941
 tplinkrouterc6u/client/mr6400v7.py,sha256=PR7dk4Q0OMqMwnuExpHFjanCYAcZ2gjnJ0XoMV-ex8I,2407
 tplinkrouterc6u/client/r.py,sha256=H-qArD60gasT07pEeY48n0_c6-yUbAKL7IRmQtr6jXk,7632
 tplinkrouterc6u/client/re330.py,sha256=9Wj4VpYJbVwZJUh9s3magdeL3Jl-B7qyrWfrVBxRk4A,17465
+tplinkrouterc6u/client/sg.py,sha256=WPxqxST84Dh-iO-V0oPRpehn2D21YwAq4r_4mEAFSv8,11353
 tplinkrouterc6u/client/vr.py,sha256=7Tbu0IrWtr4HHtyrnLFXEJi1QctzhilciL7agtwQ0R8,5025
 tplinkrouterc6u/client/vr400v2.py,sha256=ZgQ3w4s9cqhAYgq-xr7l64v1pCT3izdw6amG9XfM0cA,4208
 tplinkrouterc6u/client/wdr.py,sha256=i54PEifjhfOScDpgNBXygw9U4bfsVtle846_YjnDoBs,21679
 tplinkrouterc6u/client/xdr.py,sha256=CQN5h2f2oUuwjbtUeOjisBT8K1a72snIDxsWMc_qGik,10917
 tplinkrouterc6u/common/__init__.py,sha256=pCTvVZ9CAwgb7MxRnLx0y1rI0sTKSwT24FfxWfQXeTM,33
-tplinkrouterc6u/common/dataclass.py,sha256=NmwN6Iqpd9Ne7Zr-R0J1OZQz28NRp5Qzh6NjVFZV_DA,7749
+tplinkrouterc6u/common/dataclass.py,sha256=9l_OepmU2JU8SJxYVOPvO_9PMu5nofKEqeFTSHB-s2c,7885
 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=CMHVSgk4RSZyFoPi3499-sJDYg-nfnyJbz1iArFU9Hw,1644
-tplinkrouterc6u-5.14.0.dist-info/licenses/LICENSE,sha256=YF6QR6Vjxcg5b_sYIyqkME7FZYau5TfEUGTG-0JeRK0,35129
-tplinkrouterc6u-5.14.0.dist-info/METADATA,sha256=9FKClNuCn3ur3yEcnUmUZ5G7eBBN-j1aCyfBQZGtxmY,17853
-tplinkrouterc6u-5.14.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-tplinkrouterc6u-5.14.0.dist-info/top_level.txt,sha256=1iSCCIueqgEkrTxtQ-jiHe99jAB10zqrVdBcwvNfe_M,21
-tplinkrouterc6u-5.14.0.dist-info/RECORD,,
+tplinkrouterc6u-5.15.0.dist-info/licenses/LICENSE,sha256=YF6QR6Vjxcg5b_sYIyqkME7FZYau5TfEUGTG-0JeRK0,35129
+tplinkrouterc6u-5.15.0.dist-info/METADATA,sha256=9EEpcuq5euG0Beh4eGSldAafxtnnXob-bNX9bPnNEfY,18229
+tplinkrouterc6u-5.15.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tplinkrouterc6u-5.15.0.dist-info/top_level.txt,sha256=1iSCCIueqgEkrTxtQ-jiHe99jAB10zqrVdBcwvNfe_M,21
+tplinkrouterc6u-5.15.0.dist-info/RECORD,,

{tplinkrouterc6u-5.14.0.dist-info → tplinkrouterc6u-5.15.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any