bug fixed

iptv.code-workspace

@@ -7,7 +7,12 @@
 	"settings": {
 		"pylint.cwd": "${workspaceFolder}/src",
 		"terminal.integrated.env.windows": {
-			"PYTHONPATH": "${env:PYTHONPATH};${workspaceFolder}/src"
-		}
+			"PYTHONPATH": "${env:PYTHONPATH};${workspaceFolder}/src;${workspaceFolder}/test"
+		},
+		"python.testing.pytestArgs": [
+			"test"
+		],
+		"python.testing.unittestEnabled": false,
+		"python.testing.pytestEnabled": true
 	}
 }

pytest.ini

@@ -1,2 +1,2 @@
 [pytest]
-pythonpath = src
+pythonpath = src test

src/epg/authenticator.py

@@ -12,13 +12,13 @@
     credential = Credential(...)
     authenticator = Authenticator(
         credential = credential,
-        auth_method = AuthMehod.SALTED_MD5,
+        auth_method = AuthMethod.SALTED_MD5,
         salt = "01234567"
     )
     encrypted_info = authenticator.info
 
 Attributes:
-    AuthMehod (Enum): An enumeration of supported authentication methods.
+    AuthMethod (Enum): An enumeration of supported authentication methods.
     CipherUtils (class): Utility class for cipher-related operations.
     Authenticator (class): Handles authentication processes.
 
@@ -34,7 +34,7 @@
 from epg.credential import Credential
 
 
-class AuthMehod(Enum):
+class AuthMethod(Enum):
     """Enumeration for different authentication methods.
 
     This enumeration defines various methods that can be used for
@@ -130,7 +130,7 @@ class Authenticator:
     Attributes:
         _credential (Credential): The credential object containing user
             credentials.
-        auth_method (AuthMehod): The method to use for authentication.
+        auth_method (AuthMethod): The method to use for authentication.
         salt (str): The salt to use for SALTED_MD5 authentication, if
             applicable.
 
@@ -143,7 +143,7 @@ class Authenticator:
 
     # properties
     _credential: Credential
-    auth_method: AuthMehod
+    auth_method: AuthMethod
     salt: str
 
     # properties @getter/@setter
@@ -152,7 +152,7 @@ class Authenticator:
     def __init__(
         self,
         credential: Credential,
-        auth_method: AuthMehod = AuthMehod.PLAIN,
+        auth_method: AuthMethod = AuthMethod.PLAIN,
         salt: str | None = None,
     ):
         """Initializes the Authenticator with given credentials and method.
@@ -164,18 +164,18 @@ def __init__(
         Args:
             credential (Credential): The credential object containing user
                 credentials.
-            auth_method (AuthMehod, optional): The method to use for
-                authentication. Defaults to AuthMehod.PLAIN.
+            auth_method (AuthMethod, optional): The method to use for
+                authentication. Defaults to AuthMethod.PLAIN.
             salt (str, optional): The salt to use for SALTED_MD5
                 authentication. Required if auth_method is
-                AuthMehod.SALTED_MD5. Defaults to None.
+                AuthMethod.SALTED_MD5. Defaults to None.
 
         Raises:
             TypeError: If 'salt' is required for SALTED_MD5 but not provided.
         """
         self._credential = credential
         self.auth_method = auth_method
-        if auth_method == AuthMehod.SALTED_MD5:
+        if auth_method == AuthMethod.SALTED_MD5:
             if salt is not None:
                 self.salt = salt
             else:
@@ -212,11 +212,11 @@ def info(self) -> str:
         credential = self._credential
 
         match self.auth_method:
-            case AuthMehod.PLAIN:
+            case AuthMethod.PLAIN:
                 key = CipherUtils.pad(credential.password)
-            case AuthMehod.MD5:
+            case AuthMethod.MD5:
                 key = CipherUtils.md5(credential.password)
-            case AuthMehod.SALTED_MD5:
+            case AuthMethod.SALTED_MD5:
                 key = CipherUtils.salted_md5(credential.password, self.salt)
             case _:
                 raise ValueError("Invalid auth key")

src/epg/utils.py

@@ -13,7 +13,7 @@
 
         password = 'password'
         cipertext = 'encrypted_string_here'
-        decrypted_data = reverse(password, cipertext, AuthMehod.MD5)
+        decrypted_data = reverse(password, cipertext, AuthMethod.MD5)
 
     Testing salts using the EvaluateTools class:
 
@@ -26,17 +26,18 @@
     None
 
 """
+
 from multiprocessing import Manager, Process
 
 from epg import crypto
-from epg.authenticator import Authenticator, AuthMehod, CipherUtils
+from epg.authenticator import Authenticator, AuthMethod, CipherUtils
 from epg.credential import Credential
 
 
 def reverse(
     password: str,
     cipertext: str,
-    auth_method: AuthMehod = AuthMehod.PLAIN,
+    auth_method: AuthMethod = AuthMethod.PLAIN,
     salt: str | None = None,
 ) -> Credential:
     """
@@ -48,8 +49,8 @@ def reverse(
         password (str): The password used for generating the key to decrypt the
             ciphertext.
         cipertext (str): The encrypted string that needs to be decrypted.
-        auth_method (AuthMehod, optional): The method of authentication to use
-            for decrypting the ciphertext. Defaults to AuthMehod.PLAIN.
+        auth_method (AuthMethod, optional): The method of authentication to use
+            for decrypting the ciphertext. Defaults to AuthMethod.PLAIN.
         salt (str | None, optional): An optional salt that is required if the
             authentication method is salted. Defaults to None.
 
@@ -61,14 +62,14 @@ def reverse(
     Returns:
         Credential: The Credential object generated from the decrypted data.
     """
-    if auth_method == AuthMehod.SALTED_MD5 and salt is None:
+    if auth_method == AuthMethod.SALTED_MD5 and salt is None:
         raise TypeError("missing required positional argument: 'salt'")
     match auth_method:
-        case AuthMehod.PLAIN:
+        case AuthMethod.PLAIN:
             key = CipherUtils.pad(password)
-        case AuthMehod.MD5:
+        case AuthMethod.MD5:
             key = CipherUtils.md5(password)
-        case AuthMehod.SALTED_MD5:
+        case AuthMethod.SALTED_MD5:
             key = CipherUtils.salted_md5(password, salt)
         case _:
             raise ValueError("Invalid auth method")
@@ -93,6 +94,7 @@ class but rather as a scope for parallel processing of salt testing. This
     The class does not return any objects but serves as a namespace to organize
     related cryptographic operations effectively.
     """
+
     _credential: Credential
     _cipertext: str
     _max_digitals: int
@@ -147,12 +149,12 @@ def _worker(self, result: list, start: int, amount: int) -> None:
                 if (
                     Authenticator(
                         self._credential,
-                        AuthMehod.SALTED_MD5,
+                        AuthMethod.SALTED_MD5,
                         self._pad(location + start),
                     ).info
                     == self._cipertext
                 ):
-                    result.append(location + start)
+                    result.append(self._pad(location + start))
             except ValueError:
                 pass
 
@@ -185,13 +187,13 @@ def test_salt(
         Returns:
             list: A list of salt values that successfully match the ciphertext.
         """
-        self._credential=credential
-        self._cipertext=cipertext
-        self._max_digitals=max_digitals
-        self._padding=padding
+        self._credential = credential
+        self._cipertext = cipertext
+        self._max_digitals = max_digitals
+        self._padding = padding
         total = 10**max_digitals
         divided_batch = total // processes
-        remaining=total%processes
+        remaining = total % processes
         with Manager() as manager:
             result = manager.list()
             tasks = [

test/config.py

@@ -0,0 +1,2 @@
+# pylint: disable=missing-module-docstring
+TEST_DATA = "test_data.json"

test/epg/test_crypto.py

@@ -1,4 +1,4 @@
-# pylint: disable=missing-module-docstring, missing-function-docstring, redefined-outer-name
+# pylint: disable=missing-module-docstring, missing-class-docstring, missing-function-docstring, redefined-outer-name
 
 import pytest
 
@@ -66,8 +66,6 @@ def test_invalid_key_length(test_data):
     )
 
 
-
-
 def test_encrypt_decrypt(test_data):
     encrypted_data_utf8_key_8 = encrypt(
         test_data["utf8_data"], test_data["key_8"]

test/epg/test_utils.py

@@ -0,0 +1,51 @@
+# pylint: disable=missing-module-docstring, missing-class-docstring, missing-function-docstring
+import json
+import random
+
+import pytest
+import random_info
+from config import TEST_DATA
+from epg.authenticator import Authenticator, AuthMethod
+from epg.credential import Credential
+from epg.utils import EvaluateTools, reverse
+
+
+def test_reverse():
+    with pytest.raises(TypeError) as excinfo:
+        reverse("", "", AuthMethod.SALTED_MD5)
+    assert "missing required positional argument: 'salt'" in str(excinfo.value)
+    with pytest.raises(ValueError) as excinfo:
+        reverse("", "", -1)
+    assert "Invalid auth method" in str(excinfo.value)
+    with open(TEST_DATA, "r", encoding="utf-8") as file:
+        for authenticator_set in json.loads(file.read()):
+            _credential = authenticator_set["credential"]
+            credential = Credential(
+                _credential["token"],
+                _credential["user_id"],
+                _credential["password"],
+                _credential["ip"],
+                _credential["mac"],
+                _credential["product_id"],
+                _credential["ctc"],
+            )
+            print(AuthMethod[authenticator_set["method"]])
+            print(authenticator_set["salt"])
+            assert Credential.dumps(
+                reverse(
+                    _credential["password"],
+                    authenticator_set["info"],
+                    AuthMethod[authenticator_set["method"]],
+                    authenticator_set["salt"],
+                )
+            ) == Credential.dumps(credential)
+
+
+def test_EvaluateTools():
+    credential = random_info.credential()
+    salt = f"{random.randint(1,9999):05d}"
+    assert salt in EvaluateTools().test_salt(
+        credential,
+        Authenticator(credential, AuthMethod.SALTED_MD5, salt).info,
+        5,
+    )

test/generate_data.py

@@ -1,5 +1,6 @@
 # pylint: disable=missing-module-docstring, missing-class-docstring, missing-function-docstring
+from config import TEST_DATA
 from test_data import batch_generate
 
-with open("test_data.json", "w", encoding="utf-8") as file:
+with open(TEST_DATA, "w", encoding="utf-8") as file:
     file.write(batch_generate())

test/random_info.py

@@ -2,7 +2,7 @@
 import random
 import string
 
-from epg.authenticator import Authenticator, AuthMehod
+from epg.authenticator import Authenticator, AuthMethod
 from epg.credential import Credential
 
 BASIC_SET = (
@@ -79,9 +79,9 @@ def batch_credential(amount: int) -> list:
 
 
 def authenticator() -> dict[Authenticator, str]:
-    method = random.choice(list(AuthMehod))
+    method = random.choice(list(AuthMethod))
     _credential = credential()
-    if method == AuthMehod.SALTED_MD5:
+    if method == AuthMethod.SALTED_MD5:
         salt = f"{random.randint(0,99999999):08d}"
     else:
         salt = None
@@ -94,19 +94,20 @@ def batch_authenticator(amount: int) -> list[dict[Authenticator, str]]:
 
 
 def raw_authenticator() -> dict[str]:
-    method = random.choice(list(AuthMehod))
+    method = random.choice(list(AuthMethod))
     _credential = credential()
-    if method == AuthMehod.SALTED_MD5:
+    if method == AuthMethod.SALTED_MD5:
         salt = f"{random.randint(0,99999999):08d}"
     else:
         salt = None
     _authenticator = Authenticator(_credential, method, salt)
     return {
-        "credential": dict(credential()),
+        "credential": dict(_credential),
         "method": method.name,
         "salt": salt,
         "info": _authenticator.info,
     }
 
+
 def batch_raw_authenticator(amount: int) -> list[dict[Authenticator, str]]:
     return [raw_authenticator() for _ in range(amount)]

test/test_data.py

@@ -2,6 +2,7 @@
 import json
 import random
 
+from config import TEST_DATA
 from random_info import batch_raw_authenticator
 
 
@@ -13,5 +14,5 @@ def batch_generate():
 
 
 def test_data():
-    with open("test_data.json", "r", encoding="utf-8") as file:
+    with open(TEST_DATA, "r", encoding="utf-8") as file:
         assert file.read() == batch_generate()