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

test/test_client_re330.py

@@ -0,0 +1,296 @@
+from unittest import main, TestCase
+from ipaddress import IPv4Address
+from macaddress import EUI48
+from tplinkrouterc6u.common.dataclass import Firmware, Status, Device
+from tplinkrouterc6u.common.dataclass import IPv4Status, IPv4Reservation, IPv4DHCPLease
+from tplinkrouterc6u import Connection, ClientException
+from tplinkrouterc6u.client.re330 import TplinkRE330Router
+
+
+IPV4_STATUS_RESPONSE = ('00000\r\nid 1|1,0,0\r\noldAuthKey \r\nsetWzd 1\r\nmode 3\r\nlogLevel 3\r\nfastpath 1\r\n'
+                        'mac 0 00-00-00-00-00-01\r\nmac 1 00-00-00-00-00-02\r\nauthKey keykeykey\r\nid 4|1,0,0\r\n'
+                        'ip 2.2.2.2\r\nmask 255.255.255.0\r\ngateway 3.3.3.3\r\ndns 0 1.1.1.1\r\n'
+                        'dns 1 8.8.8.8\r\nmode 0\r\nid 8|1,0,0\r\nmode 2\r\npoolStart 192.168.1.100\r\n'
+                        'poolEnd 192.168.1.199\r\n'
+                        'leaseTime 120\r\ndns 0 0.0.0.0\r\ndns 1 0.0.0.0\r\ngateway 0.0.0.0\r\nhostName \r\n'
+                        'id 22|1,0,0\r\nenable 1\r\nwirelessWanNoUsed 0\r\nlinkMode 0\r\nlinkType 0\r\nid 23|1,0,0\r\n'
+                        'ip 4.4.4.4\r\nmask 255.255.252.0\r\ngateway 5.5.5.5\r\ndns 0 1.1.1.1\r\ndns 1 8.8.8.8\r\n'
+                        'status 1\r\ncode 0\r\nupTime 0\r\ninPkts 0\r\ninOctets 0\r\noutPkts 0\r\noutOctets 0\r\n'
+                        'inRates 0\r\noutRates 0\r\ndualMode 0\r\ndualIp 0.0.0.0\r\ndualMask 0.0.0.0\r\n'
+                        'dualGateway 0.0.0.0\r\ndualDns 0 0.0.0.0\r\ndualDns 1 0.0.0.0\r\ndualCode 0\r\ndualStatus 0')
+
+STATUS_RESPONSE_TEXT = ('00000\r\nid 1|1,0,0\r\noldAuthKey \r\nsetWzd 1\r\nmode 3\r\nlogLevel 3\r\nfastpath 1\r\n'
+                        'mac 0 00-00-00-00-00-01\r\nmac 1 00-00-00-00-00-02\r\nauthKey keykeykey\r\nid 4|1,0,0\r\n'
+                        'ip 2.2.2.2\r\nmask 255.255.255.0\r\ngateway 3.3.3.3\r\ndns 0 1.1.1.1\r\ndns 1 8.8.8.8\r\n'
+                        'mode 0\r\nid 23|1,0,0\r\nip 4.4.4.4\r\nmask 255.255.255.0\r\ngateway 5.5.5.5\r\n'
+                        'dns 0 1.1.1.1\r\ndns 1 8.8.8.8\r\nstatus 1\r\ncode 0\r\nupTime 0\r\ninPkts 0\r\ninOctets 0\r\n'
+                        'outPkts 0\r\noutOctets 0\r\ninRates 0\r\noutRates 0\r\ndualMode 0\r\ndualIp 0.0.0.0\r\n'
+                        'dualMask 0.0.0.0\r\ndualGateway 0.0.0.0\r\ndualDns 0 0.0.0.0\r\ndualDns 1 0.0.0.0\r\n'
+                        'dualCode 0\r\ndualStatus 0\r\nid 13|1,0,0\r\nip 0 10.10.10.10\r\nip 1 11.11.11.11\r\n'
+                        'ip 2 0.0.0.0\r\nip 3 0.0.0.0\r\nip 4 0.0.0.0\r\nip 5 0.0.0.0\r\nmac 0 00-00-00-00-00-03\r\n'
+                        'mac 1 00-00-00-00-00-04\r\nmac 2 00-00-00-00-00-00\r\nmac 3 00-00-00-00-00-00\r\n'
+                        'mac 4 00-00-00-00-00-00\r\nmac 5 00-00-00-00-00-00\r\n'
+                        'reserved 0 \r\nreserved 1 \r\nreserved 2 \r\nreserved 3 \r\nreserved 4 \r\nreserved 5 \r\n'
+                        'bindEntry 0 0\r\nbindEntry 1 0\r\nbindEntry 2 0\r\nbindEntry 3 0\r\nbindEntry 4 0\r\n'
+                        'bindEntry 5 0\r\nstaMgtEntry 0 0\r\nstaMgtEntry 1 0\r\nstaMgtEntry 2 0\r\nstaMgtEntry 3 0\r\n'
+                        'staMgtEntry 4 0\r\nstaMgtEntry 5 0\r\ntype 0 3\r\ntype 1 1\r\ntype 2 0\r\ntype 3 0\r\n'
+                        'type 4 0\r\ntype 5 0\r\nonline 0 1\r\nonline 1 1\r\nonline 2 0\r\nonline 3 0\r\nonline 4 0\r\n'
+                        'online 5 0\r\nname 0 ANONYMOUS\r\nname 1 BANANA-12\r\nname 2 \r\nname 3 \r\nname 4 \r\n'
+                        'name 5 \r\nDevType 0 OTHER\r\nDevType 1 OTHER\r\nDevType 2 \r\nDevType 3 \r\nDevType 4 \r\n'
+                        'DevType 5 \r\nid 33|1,1,0\r\nuUnit 0\r\ncSsidPrefix \r\nuRadiusIp 0.0.0.0\r\n'
+                        'uRadiusGKUpdateIntvl 0\r\nuPskGKUpdateIntvl 0\r\nuKeyLength 0 0\r\nuKeyLength 1 0\r\n'
+                        'uKeyLength 2 0\r\nuKeyLength 3 0\r\ncKeyVal 0 \r\ncKeyVal 1 \r\ncKeyVal 2 \r\ncKeyVal 3 \r\n'
+                        'uRadiusPort 1812\r\nuKeyType 1\r\nuDefaultKey 1\r\nbEnable 1\r\nbBcastSsid 1\r\n'
+                        'cSsid SuperWifi\r\nbSecurityEnable 1\r\nuAuthType 3\r\nuWEPSecOpt 3\r\nuRadiusSecOpt 3\r\n'
+                        'uPSKSecOpt 2\r\nuRadiusEncryptType 4\r\nuPSKEncryptType 3\r\ncRadiusSecret \r\n'
+                        'cPskSecret YouThoughtIdForgetMyKey?\r\nbSecCheck 0\r\nbEnabled 1\r\nbPinEnabled 0\r\n'
+                        'cUsrPIN 11100111\r\nbConfigured 0\r\nbIsLocked 0\r\nid 33|2,1,0\r\nuUnit 0\r\ncSsidPrefix \r\n'
+                        'uRadiusIp 0.0.0.0\r\nuRadiusGKUpdateIntvl 0\r\nuPskGKUpdateIntvl 0\r\nuKeyLength 0 0\r\n'
+                        'uKeyLength 1 0\r\nuKeyLength 2 0\r\nuKeyLength 3 0\r\ncKeyVal 0 \r\ncKeyVal 1 \r\n'
+                        'cKeyVal 2 \r\ncKeyVal 3 \r\nuRadiusPort 1812\r\nuKeyType 1\r\nuDefaultKey 1\r\nbEnable 1\r\n'
+                        'bBcastSsid 1\r\ncSsid SuperWifi\r\nbSecurityEnable 1\r\nuAuthType 3\r\nuWEPSecOpt 3\r\n'
+                        'uRadiusSecOpt 3\r\nuPSKSecOpt 2\r\nuRadiusEncryptType 4\r\nuPSKEncryptType 3\r\n'
+                        'cRadiusSecret \r\ncPskSecret YouThoughtIdForgetMyKey?\r\nbSecCheck 0\r\n'
+                        'bEnabled 1\r\nbPinEnabled 0\r\ncUsrPIN 11100111\r\nbConfigured 0\r\nbIsLocked 0')
+
+
+class ResponseMock():
+    def __init__(self, text, status_code=0):
+        self.text = text
+        self.status_code = status_code
+
+
+class TplinkRE330RouterTest(TplinkRE330Router):
+    response = ''
+
+    def _init_session(self) -> None:
+        pass
+
+    def request(self, code: int, asyn: int, use_token: bool = False, data: str = None) -> dict | None:
+
+        # Responses
+        if code == 2 and (asyn == 0 or asyn == 1):
+            if use_token is False:
+                if data == '50|1,0,0':
+                    # Supports
+                    return ResponseMock(self.response, 200)
+                else:
+                    # Authorization
+                    return ResponseMock('blabla\r\nblabla\r\nblabla\r\nauthinfo1\r\nauthinfo2')
+            elif use_token is True:
+                return ResponseMock(self.response)
+        if code == 7 and asyn == 1:
+            if use_token is False:
+                # Authorization
+                return ResponseMock('00007\r\n00004\r\n00002\r\n'
+                                    'BC97577E65233B3E1137C61091D64176C334E52AD78FFBDDABC826B685435E'
+                                    '9D3DE83FE70C2AC62D6B13BD8EADA10B5623F9354DA0E99636A4F5519CA2DC2DC3\r\n'
+                                    '12345656\r\n00000')
+            elif use_token is True:
+                return ResponseMock('00000')
+        elif code == 16 and asyn == 0:
+            if use_token is False:
+                # Authorization
+                return ResponseMock('00000\r\n010001\r\nBC97577E65233B3E1137C61091D64176C334E52AD78FFBDDABC826B685435E'
+                                    '9D3DE83FE70C2AC62D6B13BD8EADA10B5623F9354DA0E99636A4F5519CA2DC2DC3\r\n12345656')
+            elif use_token is True:
+                # Authorization
+                return ResponseMock('00000')
+        elif code == 7 and asyn == 0:
+            return ResponseMock('00000')
+
+        raise ClientException()
+
+    def set_encrypted_response(self, response_text) -> None:
+        self.response = self._encrypt_body(response_text).split('data=')[1]
+
+
+class TestTPLinkClient(TestCase):
+
+    def test_supports(self) -> None:
+        response = ('00000\r\nid 50|1,0,0\r\ncurrentLanguage\r\n'
+                    'languageList bg_BG,cs_CZ,de_DE,en_US,es_ES,es_LA,fr_FR,hu_HU,it_IT,ja_JP,ko_KR,nl_NL,pl_PL,pt_BR,'
+                    'pt_PT,ro_RO,ru_RU,sk_SK,tr_TR,uk_UA,vi_VN,zh_TW\r\nsetByUser 0')
+
+        client = TplinkRE330RouterTest('', '')
+        client.response = response
+        supports = client.supports()
+        self.assertTrue(supports)
+
+    def test_authorize(self) -> None:
+        client = TplinkRE330RouterTest('', '')
+        client.authorize()
+
+        encryption = client._encryption
+        self.assertEqual(encryption.ee_rsa, '010001')
+        self.assertEqual(encryption.nn_rsa, 'BC97577E65233B3E1137C61091D64176C334E52AD78FFBDDABC826B685435E9D3DE83FE70C'
+                                            '2AC62D6B13BD8EADA10B5623F9354DA0E99636A4F5519CA2DC2DC3')
+        self.assertEqual(encryption.seq, '12345656')
+
+    def test_get_firmware(self) -> None:
+        response = ('00000\r\nid 0|1,0,0\r\nfullName TP-Link%20Wireless%20Extender%20RE330\r\nfacturer TP-Link\r\n'
+                    'modelName RE330\r\nmodelVer 1\r\nsoftVer 1.0.23%20Build%20230418%20Rel.60395n\r\n'
+                    'hardVer %20RE330%201.0\r\nprodId 0x3300001\r\ncloudShouldActive 1\r\ncountryId 0x0\r\n'
+                    'specialId 0x5545\r\ncountryCode 0x4544\r\nmainVer 0x5a010017\r\nminorVer 0x1\r\noemId 0x1\r\n'
+                    'deviceId 8002A1F018FA0C879DB62FA981FB0D1D231D490F\r\n'
+                    'hardwareId 5E055ADC85F0800C6C3044E5A3180E2A\r\nfirmwareId FFFFFFFFFFFFFFFFFFFF033001004555\r\n'
+                    'oem_id B30DDAF6C31C08B9C50A48B0B9168003\r\nfacturerType 0')
+
+        client = TplinkRE330RouterTest('', '')
+        client.authorize()
+
+        client.set_encrypted_response(response)
+
+        firmware = client.get_firmware()
+
+        self.assertIsInstance(firmware, Firmware)
+        self.assertEqual(firmware.hardware_version, ' RE330 1.0')
+        self.assertEqual(firmware.model, 'RE330')
+        self.assertEqual(firmware.firmware_version, '1.0.23 Build 230418 Rel.60395n')
+
+    def test_get_ipv4_status(self) -> None:
+
+        client = TplinkRE330RouterTest('', '')
+        client.authorize()
+
+        client.set_encrypted_response(IPV4_STATUS_RESPONSE)
+
+        ipv4_status: IPv4Status = client.get_ipv4_status()
+
+        self.assertIsInstance(ipv4_status, IPv4Status)
+        self.assertEqual(ipv4_status.wan_macaddress, EUI48('00-00-00-00-00-02'))
+        self.assertEqual(ipv4_status._wan_ipv4_ipaddr, IPv4Address('4.4.4.4'))
+        self.assertEqual(ipv4_status._wan_ipv4_gateway, IPv4Address('5.5.5.5'))
+        self.assertEqual(ipv4_status._wan_ipv4_conntype, 'Dynamic IP')
+        self.assertEqual(ipv4_status._wan_ipv4_netmask, IPv4Address('255.255.252.0'))
+        self.assertEqual(ipv4_status._wan_ipv4_pridns, IPv4Address('1.1.1.1'))
+        self.assertEqual(ipv4_status._wan_ipv4_snddns, IPv4Address('8.8.8.8'))
+        self.assertEqual(ipv4_status._lan_macaddr, EUI48('00-00-00-00-00-01'))
+        self.assertEqual(ipv4_status._lan_ipv4_ipaddr, IPv4Address('2.2.2.2'))
+        self.assertEqual(ipv4_status.lan_ipv4_dhcp_enable, False)
+        self.assertEqual(ipv4_status._lan_ipv4_netmask, IPv4Address('255.255.255.0'))
+
+    def test_get_ipv4_reservations(self) -> None:
+        response = ('00000\r\nid 12|1,0,0\r\nip 0 192.168.0.112\r\nip 1 0.0.0.0\r\nmac 0 00-00-00-00-00-00\r\n'
+                    'mac 1 00-00-00-00-00-01\r\nreserved 0\r\nreserved 1\r\nbindEntry 0 0\r\nbindEntry 1 0\r\n'
+                    'staMgtEntry 0 0\r\nstaMgtEntry 1 1\r\nname 0 Galaxy-S21\r\nname 1 Camera\r\nreserved_name 0\r\n'
+                    'reserved_name 1\r\nblocked 0 0\r\nblocked 1 0\r\nupLimit 0 0\r\nupLimit 1 0\r\ndownLimit 0 0'
+                    '\r\ndownLimit 1 0\r\nqosEntry 0 0\r\nqosEntry 1 0\r\npriTime 0 0\r\npriTime 1 0\r\n'
+                    'dhcpsEntry 0 1\r\ndhcpsEntry 1 0\r\ndhcpsEnable 0 1\r\ndhcpsEnable 1 0\r\nslEnable 0 0\r\n'
+                    'slEnable 1 0\r\nstart 0 0\r\nstart 1 0\r\nend 0 0\r\nend 1 0\r\nday 0 0\r\nday 1 0\r\n'
+                    'startMin 0 0\r\nstartMin 1 0\r\nendMin 0 0\r\nendMin 1 0\r\ndevType 0 0\r\ndevType 1 0\r\n'
+                    'reserved2 0 0\r\nreserved2 1 0\r\ndisable 1')
+
+        client = TplinkRE330RouterTest('', '')
+        client.authorize()
+
+        client.set_encrypted_response(response)
+
+        ipv4_reservations: list[IPv4Reservation] = client.get_ipv4_reservations()
+        ipv4_reservation: IPv4Reservation = ipv4_reservations[0]
+
+        self.assertIsInstance(ipv4_reservation, IPv4Reservation)
+        self.assertEqual(ipv4_reservation.macaddress, EUI48('00-00-00-00-00-00'))
+        self.assertEqual(ipv4_reservation.ipaddress, IPv4Address('192.168.0.112'))
+        self.assertEqual(ipv4_reservation.hostname, 'Galaxy-S21')
+        self.assertEqual(ipv4_reservation.enabled, True)
+
+    def test_get_dhcp_leases(self) -> None:
+        response = ('00000\r\nid 9|1,0,0\r\nhostName 0 Galaxy-S21\r\nhostName 1 iPhone\r\nhostName 2 PC\r\n'
+                    'hostName 3 Laptop\r\nmac 0 00-00-00-00-00-00\r\nmac 1 00-00-00-00-00-01\r\n'
+                    'mac 2 00-00-00-00-00-02\r\nmac 3 00-00-00-00-00-03\r\nreserved 0\r\nreserved 1'
+                    '\r\nreserved 2\r\nreserved 3\r\nstate 0 5\r\nstate 1 5\r\nstate 2 5\r\nstate 3 5'
+                    '\r\nip 0 192.168.0.112\r\nip 1 192.168.0.101\r\nip 2 192.168.0.245\r\nip 3 192.168.0.186'
+                    '\r\nexpires 0 4294967295\r\nexpires 1 3669\r\nexpires 2 4025\r\nexpires 3 4202')
+
+        client = TplinkRE330RouterTest('', '')
+        client.authorize()
+
+        client.set_encrypted_response(response)
+
+        dhcp_leases: list[IPv4DHCPLease] = client.get_dhcp_leases()
+
+        self.assertIsInstance(dhcp_leases[0], IPv4DHCPLease)
+        self.assertEqual(dhcp_leases[0].macaddress, EUI48('00-00-00-00-00-00'))
+        self.assertEqual(dhcp_leases[0].ipaddress, IPv4Address('192.168.0.112'))
+        self.assertEqual(dhcp_leases[0].hostname, 'Galaxy-S21')
+        self.assertEqual(dhcp_leases[0].lease_time, 'expires 4294967295')
+
+        self.assertIsInstance(dhcp_leases[1], IPv4DHCPLease)
+        self.assertEqual(dhcp_leases[1].macaddress, EUI48('00-00-00-00-00-01'))
+        self.assertEqual(dhcp_leases[1].ipaddress, IPv4Address('192.168.0.101'))
+        self.assertEqual(dhcp_leases[1].hostname, 'iPhone')
+        self.assertEqual(dhcp_leases[1].lease_time, 'expires 3669')
+
+    def test_get_status(self) -> None:
+        client = TplinkRE330RouterTest('', '')
+        client.authorize()
+
+        client.set_encrypted_response(STATUS_RESPONSE_TEXT)
+        status = client.get_status()
+
+        self.assertIsInstance(status, Status)
+        self.assertEqual(status.wan_macaddr, '00-00-00-00-00-02')
+        self.assertIsInstance(status.wan_macaddress, EUI48)
+        self.assertEqual(status.lan_macaddr, '00-00-00-00-00-01')
+        self.assertIsInstance(status.lan_macaddress, EUI48)
+        self.assertEqual(status.wan_ipv4_addr, '4.4.4.4')
+        self.assertIsInstance(status.lan_ipv4_address, IPv4Address)
+        self.assertEqual(status.lan_ipv4_addr, '2.2.2.2')
+        self.assertEqual(status.wan_ipv4_gateway, '5.5.5.5')
+        self.assertIsInstance(status.wan_ipv4_address, IPv4Address)
+        self.assertEqual(status.wired_total, 0)
+        self.assertEqual(status.wifi_clients_total, 2)
+        self.assertEqual(status.guest_clients_total, 0)
+        self.assertEqual(status.clients_total, 2)
+        self.assertEqual(status.iot_clients_total, 0)
+        self.assertFalse(status.guest_2g_enable)
+        self.assertFalse(status.guest_5g_enable)
+        self.assertFalse(status.iot_2g_enable)
+        self.assertFalse(status.iot_5g_enable)
+        self.assertTrue(status.wifi_2g_enable)
+        self.assertTrue(status.wifi_5g_enable)
+        self.assertEqual(status.wan_ipv4_uptime, 0)
+        self.assertEqual(status.mem_usage, None)
+        self.assertEqual(status.cpu_usage, None)
+        self.assertEqual(len(status.devices), 2)
+
+        device = status.devices[0]
+        self.assertIsInstance(device, Device)
+        self.assertEqual(device.type, Connection.HOST_5G)
+        self.assertEqual(device.macaddr, '00-00-00-00-00-03')
+        self.assertIsInstance(device.macaddress, EUI48)
+        self.assertEqual(device.ipaddr, '10.10.10.10')
+        self.assertIsInstance(device.ipaddress, IPv4Address)
+        self.assertEqual(device.hostname, 'ANONYMOUS')
+        self.assertEqual(device.up_speed, 0)
+        self.assertEqual(device.down_speed, 0)
+        self.assertEqual(device.active, True)
+
+        device = status.devices[1]
+        self.assertIsInstance(device, Device)
+        self.assertEqual(device.type, Connection.HOST_2G)
+        self.assertEqual(device.macaddr, '00-00-00-00-00-04')
+        self.assertIsInstance(device.macaddress, EUI48)
+        self.assertEqual(device.ipaddr, '11.11.11.11')
+        self.assertIsInstance(device.ipaddress, IPv4Address)
+        self.assertEqual(device.hostname, 'BANANA-12')
+        self.assertEqual(device.up_speed, 0)
+        self.assertEqual(device.down_speed, 0)
+        self.assertEqual(device.active, True)
+
+    def test_get_led_status(self) -> None:
+        client = TplinkRE330RouterTest('', '')
+        client.authorize()
+
+        client.set_encrypted_response('00000\r\nid 112|1,0,0\r\nenable 1')
+        led_status = client.get_led_status()
+        self.assertEqual(led_status, True)
+
+        client.set_encrypted_response('00000\r\nid 112|1,0,0\r\nenable 0')
+        led_status = client.get_led_status()
+        self.assertEqual(led_status, False)
+
+
+if __name__ == '__main__':
+    main()

tplinkrouterc6u/__init__.py

@@ -2,6 +2,7 @@ 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.mr200 import TPLinkMR200Client
 from tplinkrouterc6u.client.ex import TPLinkEXClient
 from tplinkrouterc6u.client.vr import TPLinkVRClient
 from tplinkrouterc6u.client.c80 import TplinkC80Router
@@ -9,6 +10,7 @@ from tplinkrouterc6u.client.c5400x import TplinkC5400XRouter
 from tplinkrouterc6u.client.c1200 import TplinkC1200Router
 from tplinkrouterc6u.client.xdr import TPLinkXDRClient
 from tplinkrouterc6u.client.wdr import TplinkWDRRouter
+from tplinkrouterc6u.client.re330 import TplinkRE330Router
 from tplinkrouterc6u.provider import TplinkRouterProvider
 from tplinkrouterc6u.common.package_enum import Connection, VPN
 from tplinkrouterc6u.common.dataclass import (

tplinkrouterc6u/client/mr200.py

@@ -0,0 +1,412 @@
+import base64
+from tplinkrouterc6u.client.mr import TPLinkMRClient
+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.dataclass import (
+    Firmware,
+    Status,
+    Device,
+    IPv4Reservation,
+    IPv4DHCPLease,
+    IPv4Status,
+    SMS,
+    LTEStatus,
+    VPNStatus,
+)
+from tplinkrouterc6u.common.exception import ClientException, ClientError, AuthorizeError
+
+
+class TPLinkMR200Client(TPLinkMRClient):
+
+    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)
+        n = int(params["nn"])
+        e = int(params["ee"])
+        pub_key = RSA.construct((n, e))
+
+        # Create an RSA cipher with PKCS#1 v1.5 padding (same as rsa.encrypt)
+        cipher = PKCS1_v1_5.new(pub_key)
+
+        # Encrypt username
+        rsa_username = cipher.encrypt(self.username.encode("utf-8"))
+        rsa_username_hex = hexlify(rsa_username).decode("utf-8")
+
+        # Encrypt password (after base64 encoding, as in your original code)
+        rsa_password = cipher.encrypt(base64.b64encode(self.password.encode("utf-8")))
+        rsa_password_hex = hexlify(rsa_password).decode("utf-8")
+
+        # Send login request
+        self.req.post(
+            f'{self.host}/cgi/login?UserName={rsa_username_hex}&Passwd={rsa_password_hex}&Action=1&LoginStatus=0'
+        )
+
+        # Try to extract token
+        r = self.req.get(self.host)
+        try:
+            self.req.headers["TokenID"] = search(r'var token="(.*)";', r.text).group(1)
+        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'),
+        ]
+        _, 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
+
+        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.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')
+        ]
+
+        response, _ = self.req_act(acts)
+        ret_code = self._parse_ret_val(response)
+
+        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'),
+        ]
+        _, 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 __get_params(self, retry=False):
+        try:
+            r = self.req.get(f"{self.host}/cgi/getParm", timeout=5)
+            result = {}
+            for line in r.text.splitlines()[0:2]:
+                match = search(r"var (.*)=\"(.*)\"", line)
+                result[match.group(1)] = int(match.group(2), 16)
+            return result
+        except Exception:
+            if not retry:
+                return self.__get_params(True)
+            raise ClientException()
+
+    def req_act(self, acts: list):
+        '''
+        Requests ACTs via the cgi_gdpr proxy
+        '''
+        act_types = []
+        act_data = []
+
+        for act in acts:
+            act_types.append(str(act.type))
+            act_data.append('[{}#{}#{}]{},{}\r\n{}\r\n'.format(
+                act.oid,
+                act.stack,
+                act.pstack,
+                len(act_types) - 1,  # index, starts at 0
+                len(act.attrs),
+                '\r\n'.join(act.attrs)
+            ))
+
+        data = ''.join(act_data)
+        url = f"{self.host}/cgi?" + '&'.join(act_types)
+        (code, response) = self.req.post(url, data=data)
+
+        if code != 200:
+            error = 'TplinkRouter - MR200 -  Response with error; Request {} - Response {}'.format(data, response)
+            if self._logger:
+                self._logger.debug(error)
+            raise ClientError(error)
+
+        result = self._merge_response(response)
+
+        return response, result.get('0') if len(result) == 1 and result.get('0') else result

tplinkrouterc6u/client/re330.py

@@ -0,0 +1,423 @@
+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
+from tplinkrouterc6u.common.dataclass import Firmware, Status, IPv4Status, IPv4Reservation
+from tplinkrouterc6u.common.dataclass import IPv4DHCPLease, Device
+from tplinkrouterc6u.client_abstract import AbstractRouter
+
+
+class RouterConstants:
+    AUTH_TOKEN_INDEX1 = 3
+    AUTH_TOKEN_INDEX2 = 4
+
+    HOST_WIFI_2G_REQUEST = '33|1,1,0'
+    HOST_WIFI_5G_REQUEST = '33|2,1,0'
+
+    CONNECTION_REQUESTS_MAP = {
+        Connection.HOST_2G: HOST_WIFI_2G_REQUEST,
+        Connection.HOST_5G: HOST_WIFI_5G_REQUEST,
+    }
+
+    CONNECTION_TYPE_MAP = {
+        '0': 'Dynamic IP',
+        '1': 'Static IP',
+        '2': 'PPPoE',
+        '3': 'L2TP',
+        '4': 'PPTP'
+    }
+
+
+class RouterConfig:
+    """Configuration parameters for the router."""
+    ENCODING: str = ("yLwVl0zKqws7LgKPRQ84Mdt708T1qQ3Ha7xv3H7NyU84p21BriUWBU43odz3iP4rBL3cD02KZciXTysVXiV8"
+                     "ngg6vL48rPJyAUw0HurW20xqxv9aYb4M9wK1Ae0wlro510qXeU07kV57fQMc8L6aLgMLwygtc0F10a0Dg70T"
+                     "OoouyFhdysuRMO51yY5ZlOZZLEal1h0t9YQW0Ko7oBwmCAHoic4HYbUyVeU3sfQ1xtXcPcf1aT303wAQhv66qzW")
+    KEY: str = "RDpbLfCPsJZ7fiv"
+    PAD_CHAR: str = chr(187)
+
+
+@dataclass
+class EncryptionState:
+    """Holds encryption-related state."""
+
+    def __init__(self):
+        self.nn_rsa = ''
+        self.ee_rsa = ''
+        self.seq = ''
+        self.key_aes = ''
+        self.iv_aes = ''
+        self.aes_string = ''
+        self.token = ''
+
+
+# Note: This router doesn't support VPN and up/down speeds per device
+class TplinkRE330Router(AbstractRouter):
+    DATA_REGEX = re.compile(r'id (\d+\|\d,\d,\d)\r\n(.*?)(?=\r\nid \d+\||$)', re.DOTALL)
+
+    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._session = Session()
+        if self._verify_ssl is False:
+            self._session.verify = False
+        self._encryption = EncryptionState()
+        self.host = self.host.rstrip('/')
+        # Mandatory Referer header
+        self._headers = {
+            'Referer': self.host + '/'
+        }
+
+    def _init_session(self) -> None:
+        self._session.get(self.host + "/", headers=self._headers)
+
+    def supports(self) -> bool:
+        try:
+            response = self.request(2, 0, data='50|1,0,0')
+            return response.status_code == 200 and response.text.startswith('00000')
+        except Exception:
+            return False
+
+    def authorize(self) -> None:
+        # Init session and connexion
+        self._init_session()
+        encoded_password = TplinkRE330Router._encrypt_password(self.password)
+
+        # Get token encryption strings and encrypt the password
+        response = self.request(7, 1)
+        self._encryption.token = TplinkRE330Router._encode_token(encoded_password, response)
+
+        # Get RSA exponent, modulus and sequence number
+        response = self.request(16, 0, data='get')
+
+        responseText = response.text.splitlines()
+        if len(responseText) < 4:
+            raise ClientException("Invalid response for RSA keys from router")
+        self._encryption.ee_rsa = responseText[1]
+        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,
+                                                             self._encryption.ee_rsa)
+        # Mandatory intermediate request
+        response = self.request(7, 0, True)
+        # Register AES string for decryption on server side
+        self.request(16, 0, True, data=f'set {aes_string_encrypted}')
+
+    def logout(self) -> None:
+        self.request(11, 0, True)
+
+    def get_firmware(self) -> Firmware:
+        text = '0|1,0,0'
+
+        body = self._encrypt_body(text)
+        response = self.request(2, 1, True, data=body)
+        response_text = self._decrypt_data(response.text)
+        device_datamap = dict(line.split(" ", 1) for line in response_text.split("\r\n")[1:-1])
+
+        return Firmware(parse.unquote(device_datamap['hardVer']), parse.unquote(device_datamap['modelName']),
+                        parse.unquote(device_datamap['softVer']))
+
+    def get_status(self) -> Status:
+        mac_info_request = "1|1,0,0"
+        lan_ip_request = "4|1,0,0"
+        wan_ip_request = "23|1,0,0"
+        device_data_request = '13|1,0,0'
+        all_requests = [
+            mac_info_request, lan_ip_request, wan_ip_request, device_data_request,
+            RouterConstants.HOST_WIFI_2G_REQUEST, RouterConstants.HOST_WIFI_5G_REQUEST
+        ]
+        request_text = '#'.join(all_requests)
+        body = self._encrypt_body(request_text)
+
+        response = self.request(2, 1, True, data=body)
+        response_text = self._decrypt_data(response.text)
+
+        matches = TplinkRE330Router.DATA_REGEX.findall(response_text)
+
+        data_blocks = {match[0]: match[1].strip().split("\r\n") for match in matches}
+
+        def extract_value(response_list, prefix):
+            return next((s.split(prefix, 1)[1] for s in response_list if s.startswith(prefix)), None)
+
+        network_info = {
+            'lan_mac': extract_value(data_blocks[mac_info_request], "mac 0 "),
+            'wan_mac': extract_value(data_blocks[mac_info_request], "mac 1 "),
+            'lan_ip': extract_value(data_blocks[lan_ip_request], "ip "),
+            'wan_ip': extract_value(data_blocks[wan_ip_request], "ip "),
+            'gateway_ip': extract_value(data_blocks[wan_ip_request], "gateway "),
+            'uptime': extract_value(data_blocks[wan_ip_request], "upTime ")
+        }
+
+        wifi_status = {}
+        for key, request in RouterConstants.CONNECTION_REQUESTS_MAP.items():
+            value = data_blocks.get(request)
+            wifi_status[key] = extract_value(data_blocks.get(request), "bEnable ") == '1' if value else None
+
+        device_data_response = data_blocks[device_data_request]
+
+        mapped_devices = self._parse_devices(device_data_response)
+
+        status = Status()
+        status._wan_macaddr = EUI48(network_info['wan_mac'])
+        status._lan_macaddr = EUI48(network_info['lan_mac'])
+        status._lan_ipv4_addr = IPv4Address(network_info['lan_ip'])
+        status._wan_ipv4_addr = IPv4Address(network_info['wan_ip'])
+        status._wan_ipv4_gateway = IPv4Address(network_info['gateway_ip'])
+        status.wan_ipv4_uptime = int(network_info['uptime']) // 100
+
+        status.wifi_2g_enable = wifi_status[Connection.HOST_2G]
+        status.wifi_5g_enable = wifi_status[Connection.HOST_5G]
+
+        status.wired_total = sum(1 for device in mapped_devices if device.type == Connection.WIRED)
+        status.wifi_clients_total = sum(1 for device in mapped_devices
+                                        if device.type in (Connection.HOST_2G, Connection.HOST_5G))
+        status.guest_clients_total = sum(1 for device in mapped_devices
+                                         if device.type in (Connection.GUEST_2G, Connection.GUEST_5G))
+        status.iot_clients_total = sum(1 for device in mapped_devices
+                                       if device.type in (Connection.IOT_2G, Connection.IOT_5G))
+        status.clients_total = (status.wired_total + status.wifi_clients_total +
+                                status.guest_clients_total + status.iot_clients_total)
+
+        status.devices = mapped_devices
+        return status
+
+    def set_led_status(self, status: bool) -> None:
+        text = f'id 112|1,0,0\r\nenable {1 if status else 0}\r\n'
+        body = self._encrypt_body(text)
+        self.request(1, 0, True, data=body)
+
+    def get_led_status(self) -> bool:
+        text = '112|1,0,0'
+        body = self._encrypt_body(text)
+        response = self.request(2, 0, True, data=body)
+
+        response_text = self._decrypt_data(response.text)
+        response_text = response_text.splitlines()
+        if len(response_text) < 3:
+            raise ClientException("Invalid response for LED status from router")
+
+        return response_text[2][-1:] == '1'
+
+    def reboot(self) -> None:
+        self.request(6, 1, True)
+
+    def set_wifi(self, wifi: Connection, enable: bool) -> None:
+        enable_string = f'bEnable {int(enable)}'
+        text = f'id {RouterConstants.CONNECTION_REQUESTS_MAP[wifi]}\r\n{enable_string}'
+        body = self._encrypt_body(text)
+        self.request(1, 0, True, data=body)
+
+    def get_ipv4_status(self) -> IPv4Status:
+        mac_info_request = "1|1,0,0"
+        lan_ip_request = "4|1,0,0"
+        dhcp_request = "8|1,0,0"
+        link_type_request = "22|1,0,0"
+        wan_ip_request = "23|1,0,0"
+        static_ip_request = "24|1,0,0"
+        all_requests = [
+            mac_info_request, lan_ip_request, dhcp_request, link_type_request, wan_ip_request, static_ip_request]
+        request_text = '#'.join(all_requests)
+        body = self._encrypt_body(request_text)
+
+        response = self.request(2, 1, True, data=body)
+        response_text = self._decrypt_data(response.text)
+
+        matches = TplinkRE330Router.DATA_REGEX.findall(response_text)
+
+        data_blocks = {match[0]: match[1].strip().split("\r\n") for match in matches}
+
+        network_info = {
+            'lan_mac': self._extract_value(data_blocks[mac_info_request], "mac 0 "),
+            'wan_mac': self._extract_value(data_blocks[mac_info_request], "mac 1 "),
+            'lan_ip': self._extract_value(data_blocks[lan_ip_request], "ip "),
+            'wan_ip': self._extract_value(data_blocks[wan_ip_request], "ip "),
+            'gateway_ip': self._extract_value(data_blocks[wan_ip_request], "gateway "),
+            'uptime': self._extract_value(data_blocks[wan_ip_request], "upTime "),
+            'wan_mask': self._extract_value(data_blocks[wan_ip_request], "mask "),
+            'lan_mask': self._extract_value(data_blocks[lan_ip_request], "mask "),
+            'dns_1': self._extract_value(data_blocks[wan_ip_request], "dns 0 "),
+            'dns_2': self._extract_value(data_blocks[wan_ip_request], "dns 1 "),
+            'dhcp_enabled': self._extract_value(data_blocks[dhcp_request], "enable "),
+            'link_type': self._extract_value(data_blocks[link_type_request], "linkType "),
+        }
+
+        ipv4status = IPv4Status()
+        ipv4status._wan_macaddr = EUI48(network_info['wan_mac'])
+        ipv4status._wan_ipv4_ipaddr = IPv4Address(network_info['wan_ip'])
+        ipv4status._wan_ipv4_gateway = IPv4Address(network_info['gateway_ip'])
+        ipv4status._wan_ipv4_conntype = RouterConstants.CONNECTION_TYPE_MAP[network_info['link_type']]
+        ipv4status._wan_ipv4_netmask = IPv4Address(network_info['wan_mask'])
+        ipv4status._wan_ipv4_pridns = IPv4Address(network_info['dns_1'])
+        ipv4status._wan_ipv4_snddns = IPv4Address(network_info['dns_2'])
+        ipv4status._lan_macaddr = EUI48(network_info['lan_mac'])
+        ipv4status._lan_ipv4_ipaddr = IPv4Address(network_info['lan_ip'])
+        ipv4status.lan_ipv4_dhcp_enable = network_info['dhcp_enabled'] == '1'
+        ipv4status._lan_ipv4_netmask = IPv4Address(network_info['lan_mask'])
+        return ipv4status
+
+    def get_ipv4_reservations(self) -> list[IPv4Reservation]:
+        body = self._encrypt_body('12|1,0,0')
+
+        response = self.request(2, 1, True, data=body)
+        response_text = self._decrypt_data(response.text)
+        matches = TplinkRE330Router.DATA_REGEX.findall(response_text)
+
+        data_blocks = {match[0]: match[1].strip().split("\r\n") for match in matches}
+        filtered_reservations = self._parse_response_to_dict(data_blocks['12|1,0,0'])
+
+        mapped_reservations: list[IPv4Reservation] = []
+        for reservation in filtered_reservations:
+            reservation_to_add = IPv4Reservation(EUI48(reservation['mac']), IPv4Address(reservation['ip']),
+                                                 reservation['name'], reservation['dhcpsEnable'] == '1')
+            mapped_reservations.append(reservation_to_add)
+        return mapped_reservations
+
+    def get_dhcp_leases(self) -> list[IPv4DHCPLease]:
+        body = self._encrypt_body('9|1,0,0')
+
+        response = self.request(2, 1, True, data=body)
+        response_text = self._decrypt_data(response.text)
+        matches = TplinkRE330Router.DATA_REGEX.findall(response_text)
+
+        data_blocks = {match[0]: match[1].strip().split("\r\n") for match in matches}
+
+        filtered_leases = self._parse_response_to_dict(data_blocks['9|1,0,0'])
+
+        mapped_leases: list[IPv4DHCPLease] = []
+        for lease in filtered_leases:
+            lease_to_add = IPv4DHCPLease(EUI48(lease['mac']), IPv4Address(lease['ip']),
+                                         lease['hostName'], f'expires {lease["expires"]}')
+            mapped_leases.append(lease_to_add)
+
+        return mapped_leases
+
+    def _parse_devices(self, device_data_response: list[str]) -> list[Device]:
+        filtered_devices = self._parse_response_to_dict(device_data_response)
+
+        device_type_to_connection = {
+            0: Connection.WIRED,
+            1: Connection.HOST_2G, 2: Connection.GUEST_2G,
+            3: Connection.HOST_5G, 4: Connection.GUEST_5G,
+            13: Connection.IOT_2G, 14: Connection.IOT_5G
+        }
+
+        mapped_devices = []
+        for device in filtered_devices:
+            if device['online'] == '1':
+                device_type = int(device['type'])
+                connection_type = device_type_to_connection.get(device_type, Connection.UNKNOWN)
+            else:
+                connection_type = Connection.UNKNOWN
+
+            device_to_add = Device(connection_type, EUI48(device['mac']), IPv4Address(device['ip']), device['name'])
+            device_to_add.up_speed = 0  # Not supported by the router
+            device_to_add.down_speed = 0  # Not supported by the router
+            device_to_add.active = device['online'] == '1'
+            mapped_devices.append(device_to_add)
+        return mapped_devices
+
+    def _parse_response_to_dict(self, response_data: list[str]) -> list[dict]:
+        result_dict = defaultdict(dict)
+        for entry in response_data:
+            parts = entry.split(' ', 2)
+            key, id_str = parts[0], parts[1]
+            value = parts[2] if len(parts) == 3 else ''
+            result_dict[int(id_str)][key] = value
+
+        return [v for _, v in result_dict.items() if v.get("ip") != "0.0.0.0"]
+
+    @staticmethod
+    def _encrypt_password(pwd: str, key: str = RouterConfig.KEY, encoding: str = RouterConfig.ENCODING) -> str:
+        max_len = max(len(key), len(pwd))
+        pwd = pwd.ljust(max_len, RouterConfig.PAD_CHAR)
+        key = key.ljust(max_len, RouterConfig.PAD_CHAR)
+
+        result = []
+        for i in range(max_len):
+            result.append(encoding[(ord(pwd[i]) ^ ord(key[i])) % len(encoding)])
+
+        return "".join(result)
+
+    @staticmethod
+    def _encode_token(encoded_password: str, response: requests.Response) -> str:
+        response_text = response.text.splitlines()
+        auth_info1 = response_text[RouterConstants.AUTH_TOKEN_INDEX1]
+        auth_info2 = response_text[RouterConstants.AUTH_TOKEN_INDEX2]
+
+        encoded_token = TplinkRE330Router._encrypt_password(encoded_password, auth_info1, auth_info2)
+        return parse.quote(encoded_token, safe='!()*')
+
+    def _get_signature(self, datalen: int) -> str:
+        encryption = self._encryption
+        r = f'{encryption.aes_string}&s={str(int(encryption.seq) + datalen)}'
+        e = ''
+        n = 0
+        while n < len(r):
+            e += EncryptionWrapper.rsa_encrypt(r[n:53], encryption.nn_rsa, encryption.ee_rsa)
+            n += 53
+        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()
+
+        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")
+
+    def _extract_value(self, response_list, prefix):
+        return next((s.split(prefix, 1)[1] for s in response_list if s.startswith(prefix)), None)
+
+    def request(self, code: int, asyn: int, use_token: bool = False, data: str = None):
+        url = f"{self.host}/?code={code}&asyn={asyn}"
+        if use_token:
+            url += f"&id={self._encryption.token}"
+        try:
+            response = self._session.post(url, data=data, timeout=self.timeout,
+                                          verify=self._verify_ssl, headers=self._headers)
+            # Raises exception for 4XX/5XX status codes for all requests except 1st in authorize
+            if not (code == 7 and asyn == 1 and use_token is False and data is None):
+                response.raise_for_status()
+            return response
+        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/provider.py

@@ -12,6 +12,7 @@ from tplinkrouterc6u.client.c1200 import TplinkC1200Router
 from tplinkrouterc6u.client.c80 import TplinkC80Router
 from tplinkrouterc6u.client.vr import TPLinkVRClient
 from tplinkrouterc6u.client.wdr import TplinkWDRRouter
+from tplinkrouterc6u.client.re330 import TplinkRE330Router
 
 
 class TplinkRouterProvider:
@@ -19,7 +20,7 @@ class TplinkRouterProvider:
     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]:
+                       TPLinkXDRClient, TplinkRouter, TplinkC80Router, TplinkWDRRouter, TplinkRE330Router]:
             router = client(host, password, username, logger, verify_ssl, timeout)
             if router.supports():
                 return router

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tplinkrouterc6u
-Version: 5.10.2
+Version: 5.11.0
 Summary: TP-Link Router API (supports also Mercusys Router)
 Home-page: https://github.com/AlexandrErohin/TP-Link-Archer-C6U
 Author: Alex Erohin
@@ -343,7 +343,7 @@ or you have TP-link C5400X or similar router you need to get web encrypted passw
 - Archer MR200 (v5, v5.3, v6.0)
 - Archer MR550 v1
 - Archer MR600 (v1, v2, v3)
-- Archer NX200
+- Archer NX200 v2.0
 - Archer VR400 v3
 - Archer VR600 v3
 - Archer VR900v
@@ -382,6 +382,7 @@ or you have TP-link C5400X or similar router you need to get web encrypted passw
 - VX420-G2h v1.1
 - VX800v v1
 - XC220-G3v v2.30
+- RE330 v1
 ### <a id="mercusys">MERCUSYS routers</a>
 - MR47BE v1.0
 - MR50G 1.0

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

@@ -5,11 +5,12 @@ 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=Kg6svEKtyGAfyF9yrLh2qZa2tK1mlEBJJwXRsq1MAjo,26591
 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=DDy6XVFH8Ne5C9JToRWNzRqevUfNutLUTlDhvIMsebo,1006
+tplinkrouterc6u/__init__.py,sha256=WHMzO1mOGJqx7n89jHfNtieehlE3JEF17gtFmyZrqRM,1124
 tplinkrouterc6u/client_abstract.py,sha256=3UYzmll774S_Gb5E0FTVO_rI3-XFM7PSklg1-V-2jls,1419
-tplinkrouterc6u/provider.py,sha256=bzH0WW2peC66f8NqfiI3t_niX6MFO8SAdKP9WZL-IV4,2152
+tplinkrouterc6u/provider.py,sha256=uv7AjDVOnud-hiXJdjoAbzy9UWPtiwHRIHRenjkVO_o,2230
 tplinkrouterc6u/client/__init__.py,sha256=KBy3fmtA9wgyFrb0Urh2x4CkKtWVnESdp-vxmuOvq0k,27
 tplinkrouterc6u/client/c1200.py,sha256=4XEYidEGmVIJk0YQLvmTnd0Gqa7glH2gUWvjreHpWrk,3178
 tplinkrouterc6u/client/c5400x.py,sha256=9E0omBSbWY_ljrs5MTCMu5brmrLtzsDB5O62Db8lP8Q,4329
@@ -18,6 +19,8 @@ tplinkrouterc6u/client/c80.py,sha256=ArVhza_fnXcEO-_fsQOd1l2QvmSfsswtohKxrZxEnoU
 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/vr.py,sha256=7Tbu0IrWtr4HHtyrnLFXEJi1QctzhilciL7agtwQ0R8,5025
 tplinkrouterc6u/client/wdr.py,sha256=i54PEifjhfOScDpgNBXygw9U4bfsVtle846_YjnDoBs,21679
 tplinkrouterc6u/client/xdr.py,sha256=QaZ_5vCaf8BV_JEs3S2Nz-QDREBYHGh3OUWIVS-fefY,10406
@@ -27,8 +30,8 @@ tplinkrouterc6u/common/encryption.py,sha256=4HelTxzN6esMfDZRBt3m8bwB9Nj_biKijnCn
 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.10.2.dist-info/licenses/LICENSE,sha256=YF6QR6Vjxcg5b_sYIyqkME7FZYau5TfEUGTG-0JeRK0,35129
-tplinkrouterc6u-5.10.2.dist-info/METADATA,sha256=H6GhpsW1U050iXJUTCs52FYTOTnh0tRM8DP3WUQ6Noo,16647
-tplinkrouterc6u-5.10.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tplinkrouterc6u-5.10.2.dist-info/top_level.txt,sha256=1iSCCIueqgEkrTxtQ-jiHe99jAB10zqrVdBcwvNfe_M,21
-tplinkrouterc6u-5.10.2.dist-info/RECORD,,
+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,,