absfuyu 4.2.0__py3-none-any.whl → 5.0.0__py3-none-any.whl

absfuyu/tools/obfuscator.py

@@ -3,38 +3,121 @@ Absfuyu: Obfuscator
 -------------------
 Obfuscate code
 
-Version: 2.0.2
-Date updated: 05/04/2024 (dd/mm/yyyy)
+Version: 5.0.0
+Date updated: 23/02/2025 (dd/mm/yyyy)
 """
 
 # Module level
-###########################################################################
-__all__ = ["Obfuscator"]
+# ---------------------------------------------------------------------------
+__all__ = ["Obfuscator", "StrShifter"]
 
 
 # Library
-###########################################################################
+# ---------------------------------------------------------------------------
 import base64
 import codecs
 import random
 import zlib
+from collections import deque
+from string import Template
+from typing import ClassVar
 
-from absfuyu.general.data_extension import Text
-from absfuyu.general.generator import Charset
-from absfuyu.general.generator import Generator as gen
+from absfuyu.core import BaseClass, ShowAllMethodsMixin, versionadded
+from absfuyu.dxt import Text
+from absfuyu.general.generator import Charset, Generator
 from absfuyu.logger import logger
 
 
 # Class
-###########################################################################
-class ObfuscatorLibraryList:
-    BASE64_ONLY = ["base64"]
-    FULL = ["base64", "codecs", "zlib"]
+# ---------------------------------------------------------------------------
+@versionadded("5.0.0")
+class StrShifter(BaseClass):
+    """Shift characters in a string by a specified number of positions."""
 
+    __slots__ = ("_str_to_shift", "shift_by")
 
-class Obfuscator:
+    def __init__(self, str_to_shift: str, shift_by: int = 5) -> None:
+        """
+        Initialize the StrShifter with the string to shift and the shift amount.
+
+        Parameters
+        ----------
+        str_to_shift : str
+            The string whose characters will be shifted.
+
+        shift_by : int, optional
+            The number of positions to shift the characters, by default ``5``.
+        """
+        if not isinstance(str_to_shift, str):
+            raise TypeError("Value must be an instance of str")
+        self._str_to_shift = str_to_shift
+        self.shift_by = shift_by
+
+    def _make_convert_table(self) -> dict[str, str]:
+        """
+        Create a translation table for shifting characters.
+
+        Returns
+        -------
+        dict[str, str]
+            A dictionary mapping each character to its shifted counterpart.
+        """
+        data = self._str_to_shift  # Make a copy
+
+        unique_char_sorted = deque(sorted(list(set(data))))
+        translate = unique_char_sorted.copy()
+        translate.rotate(self.shift_by)
+        convert_table = dict(zip(unique_char_sorted, translate))
+
+        return convert_table
+
+    def _use_convert_table(self, convert_table: dict[str, str]) -> str:
+        """
+        Convert the original string using the provided conversion table.
+
+        Parameters
+        ----------
+        convert_table : dict[str, str]
+            The conversion table mapping original characters to shifted characters.
+
+        Returns
+        -------
+        str
+            The transformed string after applying the conversion table.
+        """
+        return "".join([convert_table[char] for char in list(self._str_to_shift)])
+
+    def shift(self) -> str:
+        """
+        Shift the characters in the string and return the new string.
+
+        Returns
+        -------
+        str
+            The resulting string after shifting.
+        """
+        return self._use_convert_table(self._make_convert_table())
+
+
+class Obfuscator(ShowAllMethodsMixin):
     """Obfuscate code"""
 
+    # Var
+    LIB_BASE64_ONLY: ClassVar[list[str]] = ["base64"]
+    LIB_FULL: ClassVar[list[str]] = ["base64", "codecs", "zlib"]
+
+    # Template
+    SINGLE_LINE_TEMPLATE: ClassVar[Template] = Template(
+        "exec(bytes.fromhex('$one_line_code').decode('utf-8'))"
+    )
+    PRE_HEX_B64_TEMPLATE: ClassVar[Template] = Template(
+        "eval(compile(base64.b64decode($encoded_string),$type_var,$execute))"
+    )
+    PRE_HEX_FULL_TEMPLATE: ClassVar[Template] = Template(
+        "eval(compile(base64.b64decode(zlib.decompress(base64.b64decode(codecs."
+        "encode($encoded_string,$codec_to_decode).encode()))),$type_var,$execute))"
+    )
+
     def __init__(
         self,
         code: str,
@@ -45,56 +128,73 @@ class Obfuscator:
         fake_data: bool = False,
     ) -> None:
         """
-        code: Code text
-        base64_only: False: base64, compress, rot13 (default) | True: encode in base64 form only
-        split_every: Split the long line of code every `x` character
-        variable_length: Length of variable name (when data string split). Minimum is 7
-        fake_data: Generate additional meaningless data
+        Obfuscator
+
+        Parameters
+        ----------
+        code : str
+            Code text
+
+        base64_only : bool, optional
+            - ``True``: encode in base64 form only
+            - ``False``: base64, compress, rot13 (default)
+
+        split_every : int, optional
+            Split the long line of code every ``x`` character.
+            Minimum is ``1``, by default ``60``
+
+        variable_length : int, optional
+            Length of variable name (when data string split).
+            Minimum is ``7``, by default ``12``
+
+        fake_data : bool, optional
+            Generate additional meaningless data, by default ``False``
         """
         self.base_code = code
         self.base64_only = base64_only
-        self.split_every_length = split_every
-        self.variable_length = variable_length if variable_length > 6 else 7
+        self.split_every_length = max(1, split_every)
+        self.variable_length = max(7, variable_length)
         self.fake_data = fake_data
 
         # Setting
         self._library_import_variable_length = self.variable_length - 1
         self._splited_variable_length = self.variable_length
         self._decode_variable_length = self.variable_length + 3
-        # logger.debug("Class initiated.")
 
     def __str__(self) -> str:
-        # temp = self.__dict__
-        temp = {
+        return self.__repr__()
+
+    def __repr__(self) -> str:
+        repr_out_dict = {
             "base_code": "...",
             "base64_only": self.base64_only,
             "split_every_length": self.split_every_length,
             "variable_length": self.variable_length,
             "fake_data": self.fake_data,
         }
-        return f"{self.__class__.__name__}({temp})"
-
-    def __repr__(self) -> str:
-        return self.__str__()
+        repr_out = ", ".join([f"{k}={repr(v)}" for k, v in repr_out_dict.items()])
+        return f"{self.__class__.__name__}({repr_out})"
 
     def to_single_line(self) -> str:
         """
         Convert multiple lines of code into one line
 
-        :returns: Converted code
-        :rtype: str
+        Returns
+        -------
+        str
+            Converted code.
         """
         newcode = self.base_code.encode("utf-8").hex()
-        logger.debug(newcode)
-        output = f"exec(bytes.fromhex('{newcode}').decode('utf-8'))"
+        output = self.SINGLE_LINE_TEMPLATE.substitute(one_line_code=newcode)
         return output
 
+    # Obfuscate original code
     def _obfuscate(self) -> str:
         """
         Convert multiple lines of code through multiple transformation
         (base64 -> compress -> base64 -> caesar (13))
         """
-        code = self.base_code
+        code = self.base_code  # Make a copy
         logger.debug("Encoding...")
 
         b64_encode = base64.b64encode(code.encode())
@@ -102,12 +202,12 @@ class Obfuscator:
             output = b64_encode.decode()
         else:
             compressed_data = zlib.compress(b64_encode)
-            # log_debug(compressed_data)
-            logger.debug(f"Compressed data: {compressed_data}")  # type: ignore
-            b64_encode_2 = base64.b64encode(compressed_data)
-            # log_debug(b64_encode_2)
-            logger.debug(f"Base64 encode 2: {b64_encode_2}")  # type: ignore
-            caesar_data = codecs.encode(b64_encode_2.decode(), "rot_13")
+            logger.debug(
+                f"Compressed data: {str(compressed_data)} | Len: {len(str(compressed_data))}"
+            )
+            b64_encode_2 = base64.b64encode(compressed_data).decode()
+            logger.debug(f"Base64 encode 2: {b64_encode_2} | Len: {len(b64_encode_2)}")
+            caesar_data = codecs.encode(b64_encode_2, "rot_13")
             output = caesar_data
 
         logger.debug(f"Output: {output}")
@@ -122,16 +222,100 @@ class Obfuscator:
         text: Code that need to convert
         raw: Return hex form only
         """
-        encode_codec = "rot_13"
-        b64_encode_codec = base64.b64encode(encode_codec.encode()).decode()
-        b64_decode_codec = f"base64.b64decode('{b64_encode_codec}'.encode())"
+        b64_encode_codec = base64.b64encode(text.encode()).decode()
+        b64_decode_codec = f"base64.b64decode('{b64_encode_codec}'.encode()).decode()"
         hex = Text(b64_decode_codec).to_hex()
-        out = f"eval('{hex}').decode()"
+        out = f"eval('{hex}')"
         if raw:
             return hex
         return out
 
-    def _obfuscate_out(self) -> list:  # type: ignore
+    # Generate output (decode obfuscated code)
+    def _make_output_lib(self) -> list[str]:
+        """Obfuscate the `import <lib>`"""
+        output = []
+
+        # Make import lib
+        library_list = self.LIB_BASE64_ONLY if self.base64_only else self.LIB_FULL
+        imports = [f"import {lib}" for lib in library_list]
+        logger.debug(f"Lib: {imports}")
+
+        # Convert to hex
+        lib_hex = Text("\n".join(imports)).to_hex()
+        output.append(f"exec('{lib_hex}')")
+        logger.debug(f"Current output (import library): {output}")
+
+        return output
+
+    def _make_prep_for_decode_var(self) -> tuple[list[str], list[str]]:
+        """
+        ``<var> = "rot_13"``
+        ``<var> = "<string>"``
+        ``<var> = "exec"``
+
+        Returns
+        -------
+        tuple[list[str], list[str]]
+            - tuple[0]: output
+            - tuple[1]: decode var name
+        """
+        output = []
+
+        # Make variables for "rot_13", "<string>", "exec"
+        dc_name_lst: list[str] = Generator.generate_string(
+            charset=Charset.ALPHABET,
+            size=self._decode_variable_length,
+            times=3,
+            unique=True,
+        )
+
+        # Assign and convert to hex
+        encode_codec = "rot_13"  # full
+        if not self.base64_only:  # full
+            hex_0 = self._convert_to_base64_decode(encode_codec)
+            output.append(f"{dc_name_lst[0]}={hex_0}")
+
+        for i, x in enumerate(["<string>", "exec"], start=1):
+            # hex_str = Text(x).to_hex()
+            hex_str = self._convert_to_base64_decode(x)
+            output.append(f"{dc_name_lst[i]}={hex_str}")
+        logger.debug(f"Current output (decode variables): {output}")
+
+        return output, dc_name_lst
+
+    def _make_fake_output(self, input_size: int) -> list[str]:
+        """Fake data"""
+        output = []
+
+        f1 = Generator.generate_string(
+            charset=Charset.DEFAULT,
+            size=input_size,
+            times=1,
+            string_type_if_1=True,
+        )  # Generate fake data with len of original data
+        f2 = Text(f1).divide_with_variable(
+            self.split_every_length, self._splited_variable_length
+        )
+        output.extend(f2[:-1])
+
+        # Random data
+        bait_lst = Generator.generate_string(
+            charset=Charset.ALPHABET, size=self._splited_variable_length, times=25
+        )
+        for x in bait_lst:
+            output.append(
+                f"{x}='{Generator.generate_string(charset=Charset.DEFAULT, size=self.split_every_length, times=1, string_type_if_1=True)}'"
+            )
+
+        random_eval_text = str(random.randint(1, 100))
+        for _ in range(random.randint(10, 50)):
+            random_eval_text += f"+{random.randint(1, 100)}"
+        random_eval_text_final = Text(random_eval_text).to_hex()
+        output.append(f"eval('{random_eval_text_final}')")
+
+        return output
+
+    def _make_obfuscate_output(self) -> list[str]:
         """
         Convert multiple lines of code through multiple transformation
         (base64 -> compress -> base64 -> caesar (13))
@@ -146,16 +330,7 @@ class Obfuscator:
         output = []
 
         # Import library
-        library_list = (
-            ObfuscatorLibraryList.BASE64_ONLY
-            if self.base64_only
-            else ObfuscatorLibraryList.FULL
-        )
-        temp = [f"import {lib}" for lib in library_list]
-        logger.debug(f"Lib: {temp}")
-        lib_hex = Text("\n".join(temp)).to_hex()  # Convert to hex
-        output.append(f"exec('{lib_hex}')")
-        logger.debug(f"Current output (import library): {output}")
+        output.extend(self._make_output_lib())
 
         # Append divided long text list
         input_list = input_str.divide_with_variable(
@@ -167,64 +342,30 @@ class Obfuscator:
         logger.debug(f"Current output (encoded code): {output}")
 
         # Decode: encoded_str
-        dc_name_lst = gen.generate_string(
-            charset=Charset.ALPHABET, size=self._decode_variable_length, times=3
-        )
-        encode_codec = "rot_13"  # full
-        if not self.base64_only:  # full
-            hex_0 = self._convert_to_base64_decode(encode_codec)
-            output.append(f"{dc_name_lst[0]}={hex_0}")
-        hex_1 = Text("<string>").to_hex()
-        output.append(f"{dc_name_lst[1]}='{hex_1}'")
-        hex_2 = Text("exec").to_hex()
-        output.append(f"{dc_name_lst[2]}='{hex_2}'")
-        logger.debug(f"Current output (decode variables): {output}")
+        dc_out, dc_name_lst = self._make_prep_for_decode_var()
+        output.extend(dc_out)
 
         if self.base64_only:  # b64
-            pre_hex = (
-                f"eval(compile(base64."
-                f"b64decode({encoded_str}),{dc_name_lst[1]},"
-                f"{dc_name_lst[2]}))"
+            pre_hex = self.PRE_HEX_B64_TEMPLATE.substitute(
+                encoded_string=encoded_str,
+                type_var=dc_name_lst[1],
+                execute=dc_name_lst[2],
             )
         else:  # full
-            pre_hex = (
-                f"eval(compile(base64."
-                f"b64decode(zlib.decompress(base64."
-                f"b64decode(codecs."
-                f"encode({encoded_str},{dc_name_lst[0]})."
-                f"encode()))),{dc_name_lst[1]},{dc_name_lst[2]}))"
+            pre_hex = self.PRE_HEX_FULL_TEMPLATE.substitute(
+                encoded_string=encoded_str,
+                codec_to_decode=dc_name_lst[0],
+                type_var=dc_name_lst[1],
+                execute=dc_name_lst[2],
             )
+
         t_hex = Text(pre_hex).to_hex()
         output.append(f"exec('{t_hex}')")
         logger.debug(f"Current output (decode code): {output}")
 
         # Fake data
         if self.fake_data:
-            f1 = gen.generate_string(
-                charset=Charset.DEFAULT,
-                size=len(input_str),
-                times=1,
-                string_type_if_1=True,
-            )  # Generate fake data with len of original data
-            f2 = Text(f1).divide_with_variable(
-                self.split_every_length, self._splited_variable_length
-            )
-            output.extend(f2[:-1])
-
-            # Random data
-            bait_lst = gen.generate_string(
-                charset=Charset.ALPHABET, size=self._splited_variable_length, times=25
-            )
-            for x in bait_lst:
-                output.append(
-                    f"{x}='{gen.generate_string(charset=Charset.DEFAULT, size=self.split_every_length, times=1, string_type_if_1=True)}'"
-                )
-
-            random_eval_text = str(random.randint(1, 100))
-            for _ in range(random.randint(10, 50)):
-                random_eval_text += f"+{random.randint(1, 100)}"
-            random_eval_text_final = Text(random_eval_text).to_hex()
-            output.append(f"eval('{random_eval_text_final}')")
+            output.extend(self._make_fake_output(len(input_str)))
 
         logger.debug("Code obfuscated.")
         return output
@@ -233,16 +374,9 @@ class Obfuscator:
         """
         Obfuscate code
 
-        :returns: Obfuscated code
-        :rtype: str
+        Returns
+        -------
+        str
+            Obfuscated code
         """
-        return "\n".join(self._obfuscate_out())
-
-
-# Run
-###########################################################################
-if __name__ == "__main__":
-    logger.setLevel(10)
-    code = "print('Hello World')"
-    test = Obfuscator(code, fake_data=True)
-    print(test.obfuscate())
+        return "\n".join(self._make_obfuscate_output())

absfuyu/tools/passwordlib.py

@@ -3,34 +3,36 @@ Absfuyu: Passwordlib
 --------------------
 Password library
 
-Version: 1.0.0
-Date updated: 11/02/2025 (dd/mm/yyyy)
+Version: 5.0.0
+Date updated: 19/02/2025 (dd/mm/yyyy)
 """
 
 # Module level
-###########################################################################
-__all__ = ["PasswordGenerator"]
+# ---------------------------------------------------------------------------
+__all__ = ["PasswordGenerator", "TOTP"]
 
 
 # Library
-###########################################################################
+# ---------------------------------------------------------------------------
 import hashlib
-import lzma
 import os
 import random
 import re
-from typing import NamedTuple, Optional
+from typing import ClassVar, Literal, NamedTuple
+from urllib.parse import quote, urlencode
 
-from absfuyu.general.data_extension import DictExt, Text
+from absfuyu.core import BaseClass, deprecated, versionadded
+from absfuyu.dxt import DictExt, Text
 from absfuyu.general.generator import Charset, Generator
 from absfuyu.logger import logger
-from absfuyu.pkg_data import DataList
+from absfuyu.pkg_data import DataList, DataLoader
 from absfuyu.util import set_min
-from absfuyu.util.pkl import Pickler
 
 
 # Function
-###########################################################################
+# ---------------------------------------------------------------------------
+@deprecated("5.0.0")
+@versionadded("4.2.0")
 def _password_check(password: str) -> bool:
     """
     Verify the strength of ``password``.
@@ -84,21 +86,19 @@ def _password_check(password: str) -> bool:
 
 
 # Class
-###########################################################################
+# ---------------------------------------------------------------------------
 class PasswordHash(NamedTuple):
     salt: bytes
     key: bytes
 
 
-class PasswordGenerator:
+@versionadded("4.2.0")
+class PasswordGenerator(BaseClass):
     """Password Generator"""
 
     def __str__(self) -> str:
         return f"{self.__class__.__name__}()"
 
-    def __repr__(self) -> str:
-        return self.__str__()
-
     @staticmethod
     def password_hash(password: str) -> PasswordHash:
         """
@@ -111,15 +111,12 @@ class PasswordGenerator:
             salt=salt,
             iterations=100000,
         )
-        # out = {
-        #     "salt": salt,
-        #     "key": key,
-        # }
         out = PasswordHash(salt, key)
         return out
 
     @staticmethod
     def password_check(password: str) -> dict:
+        """Check password's characteristic"""
         data = Text(password).analyze()
         data = DictExt(data).apply(lambda x: True if x > 0 else False)  # type: ignore
         data.__setitem__("length", len(password))
@@ -175,7 +172,7 @@ class PasswordGenerator:
             check += 1
 
         if include_special:
-            charset += r"[ !#$%&'()*+,-./[\\\]^_`{|}~" + r'"]'
+            charset += r"[!#$%&'()*+,-./]^_`{|}~\""
             check += 1
 
         while True:
@@ -196,7 +193,7 @@ class PasswordGenerator:
     @staticmethod
     def generate_passphrase(
         num_of_blocks: int = 5,
-        block_divider: Optional[str] = None,
+        block_divider: str | None = None,
         first_letter_cap: bool = True,
         include_number: bool = True,
         *,
@@ -234,12 +231,12 @@ class PasswordGenerator:
         Myomectomies7-Sully4-Torpedomen7-Netful2-Begaud8
         """
         words: list[str] = (
-            (lzma.decompress(Pickler.load(DataList.PASSWORDLIB)).decode().split(","))  # type: ignore
+            DataLoader(DataList.PASSWORDLIB).load().decode().split(",")
             if not custom_word_list
             else custom_word_list
         )
 
-        if not block_divider:
+        if block_divider is None:
             block_divider = "-"
 
         dat = [random.choice(words) for _ in range(num_of_blocks)]
@@ -248,13 +245,86 @@ class PasswordGenerator:
             dat = list(map(lambda x: x.title(), dat))
 
         if include_number:
-            idx = random.choice(range(5))
+            idx = random.choice(range(num_of_blocks))
             dat[idx] += str(random.choice(range(10)))
 
         return block_divider.join(dat)
 
 
-# Run
-###########################################################################
-if __name__ == "__main__":
-    logger.setLevel(10)
+@versionadded("5.0.0")
+class TOTP(BaseClass):
+    """
+    A class to represent a Time-based One-Time Password (TOTP) generator.
+    """
+
+    URL_SCHEME: ClassVar[str] = "otpauth://totp/"
+
+    def __init__(
+        self,
+        secret: str,
+        name: str | None = None,
+        issuer: str | None = None,
+        algorithm: Literal["SHA1", "SHA256", "SHA512"] = "SHA1",
+        digit: int = 6,
+        period: int = 30,
+    ) -> None:
+        """
+        Initializes a TOTP instance.
+
+        Parameters
+        ----------
+        secret : str
+            The shared secret key used to generate the TOTP.
+
+        name : str, optional
+            The name associated with the TOTP. If not provided, defaults to ``"None"``.
+
+        issuer : str, optional
+            The issuer of the TOTP.
+
+        algorithm : Literal["SHA1", "SHA256", "SHA512"], optional
+            The hashing algorithm used to generate the TOTP.
+            Must be one of ``"SHA1"``, ``"SHA256"``, or ``"SHA512"``.
+            Defaults to ``"SHA1"``.
+
+        digit : int, optional
+            The number of digits in the generated TOTP. Must be greater than 0.
+            Defaults to ``6``.
+
+        period : int, optional
+            The time step in seconds for TOTP generation. Must be greater than 0.
+            Defaults to ``30``.
+        """
+        self.secret = secret.upper()
+        self.name = name if name else "None"
+        self.issuer = issuer
+        self.algorithm = algorithm.upper()
+        self.digit = max(digit, 1)  # digit must be larger than 0
+        self.period = max(period, 1)  # period must be larger than 0
+
+    def to_url(self) -> str:
+        """
+        Generates a URL for the TOTP in the otpauth format.
+
+        The URL format is as follows:
+            ``otpauth://totp/<name>?secret=<secret>&issuer=<issuer>&algorithm=<algorithm>&digit=<digit>&period=<period>``
+
+        Returns
+        -------
+        str
+            A URL representing the TOTP in otpauth format.
+        """
+        params = {
+            "secret": self.secret,
+            "issuer": self.issuer,
+            "algorithm": self.algorithm,
+            "digit": self.digit,
+            "period": self.period,
+        }
+        # Filter out None values from the params dictionary
+        filtered_params = {k: v for k, v in params.items() if v is not None}
+        # filtered_params = {k: v for k, v in self.__dict__.items() if v is not None}
+
+        name = quote(self.name)
+        tail = urlencode(filtered_params, quote_via=quote)
+        return f"{self.URL_SCHEME}{name}?{tail}"