Kekik 1.5.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

Kekik/Sifreleme/AESManager.py

@@ -0,0 +1,66 @@
+# ! Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+from json                import loads, dumps
+from Crypto.Hash         import MD5
+from Crypto.Cipher       import AES
+from Crypto.Random       import get_random_bytes
+from Crypto.Util.Padding import pad, unpad
+from base64              import b64encode, b64decode
+
+class AESManager:
+    """
+    AES/CBC/PKCS5Padding şifreleme ve çözme işlemleri için bir sınıf.
+    """
+    @staticmethod
+    def generate_key_and_iv(password, salt, key_length=32, iv_length=16, iterations=1):
+        """Anahtar ve IV oluşturmak için bir KDF fonksiyonu."""
+        derived_key_iv = b""
+        previous_block = b""
+
+        while len(derived_key_iv) < key_length + iv_length:
+            current_block = MD5.new(previous_block + password.encode() + salt).digest()
+
+            for _ in range(1, iterations):
+                current_block = MD5.new(current_block).digest()
+
+            derived_key_iv += current_block
+            previous_block = current_block
+
+        key = derived_key_iv[:key_length]
+        iv  = derived_key_iv[key_length:key_length + iv_length]
+
+        return key, iv
+
+    @staticmethod
+    def hex_to_bytes(hex_str):
+        """Hex string'i byte array'e çevirir."""
+        return bytes.fromhex(hex_str)
+
+    @staticmethod
+    def encrypt(plain_text, password):
+        """Verilen metni AES/CBC/PKCS5Padding şifreleme yöntemi ile şifreler."""
+        salt    = get_random_bytes(8)
+        key, iv = AESManager.generate_key_and_iv(password, salt)
+
+        cipher   = AES.new(key, AES.MODE_CBC, iv)
+        ct_bytes = cipher.encrypt(pad(plain_text.encode("utf-8"), AES.block_size))
+        
+        return dumps({
+            "ct" : b64encode(ct_bytes).decode("utf-8"),
+            "iv" : iv.hex(),
+            "s"  : salt.hex()
+        })
+
+    @staticmethod
+    def decrypt(crypted_data, password):
+        """Verilen şifreli metni AES/CBC/PKCS5Padding şifreleme yöntemi ile çözer."""
+        data = loads(crypted_data)
+        salt = AESManager.hex_to_bytes(data["s"])
+        iv   = AESManager.hex_to_bytes(data["iv"])
+        
+        key, iv = AESManager.generate_key_and_iv(password, salt, iv_length=len(iv))
+
+        cipher    = AES.new(key, AES.MODE_CBC, iv)
+        decrypted = unpad(cipher.decrypt(b64decode(data["ct"])), AES.block_size)
+
+        return decrypted.decode("utf-8")

Kekik/Sifreleme/CryptoJS.py

@@ -1,12 +1,14 @@
 # ! Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
 from Crypto.Cipher import AES
+from Crypto.Random import get_random_bytes
 import hashlib, base64
 
 class CryptoJS:
     """
     AES-256 encryption and decryption with key derivation from a password using a KDF (Key Derivation Function).
-    Source: https://gist.github.com/thackerronak/554c985c3001b16810af5fc0eb5c358f
+    Conforms to CryptoJS AES method.
+    ! » https://gist.github.com/thackerronak/554c985c3001b16810af5fc0eb5c358f
     """
     KEY_SIZE    = 32
     IV_SIZE     = 16
@@ -37,6 +39,19 @@ class CryptoJS:
 
         return derived_bytes[:key_size], derived_bytes[key_size:key_size + iv_size]
 
+    @staticmethod
+    def encrypt(password, plain_text):
+        salt    = CryptoJS.generate_salt(8)
+        key, iv = CryptoJS.evp_kdf(password.encode("utf-8"), salt, key_size=CryptoJS.KEY_SIZE, iv_size=CryptoJS.IV_SIZE)
+
+        cipher      = AES.new(key, CryptoJS.AES_MODE, iv)
+        cipher_text = cipher.encrypt(CryptoJS._pad(plain_text.encode("utf-8")))
+
+        # Create CryptoJS-like encrypted output
+        encrypted_data = CryptoJS.APPEND + salt + cipher_text
+
+        return base64.b64encode(encrypted_data).decode("utf-8")
+
     @staticmethod
     def decrypt(password, cipher_text):
         ct_bytes          = base64.b64decode(cipher_text)
@@ -50,6 +65,17 @@ class CryptoJS:
 
         return CryptoJS._unpad(plain_text).decode("utf-8")
 
+    @staticmethod
+    def _pad(s):
+        block_size = AES.block_size
+        padding    = block_size - len(s) % block_size
+
+        return s + bytes([padding] * padding)
+
     @staticmethod
     def _unpad(s):
-        return s[:-ord(s[-1:])]
+        return s[:-ord(s[-1:])]
+
+    @staticmethod
+    def generate_salt(length):
+        return get_random_bytes(length)

Kekik/Sifreleme/HexCodec.py

@@ -0,0 +1,23 @@
+# ! Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+class HexCodec:
+    @staticmethod
+    def encode(utf8_string: str) -> str:
+        """
+        UTF-8 stringini kaçış dizileriyle birlikte hex stringine dönüştürür.
+        """
+        byte_data   = utf8_string.encode("utf-8")
+        hex_string  = byte_data.hex()
+        escaped_hex = "\\x".join(hex_string[i:i+2] for i in range(0, len(hex_string), 2))
+
+        return f"\\x{escaped_hex}"
+
+    @staticmethod
+    def decode(escaped_hex: str) -> str:
+        """
+        Kaçış dizileri içeren bir hex stringini UTF-8 formatındaki stringe dönüştürür.
+        """
+        hex_string = escaped_hex.replace("\\x", "")
+        byte_data  = bytes.fromhex(hex_string)
+
+        return byte_data.decode("utf-8")

Kekik/Sifreleme/Packer.py

@@ -2,18 +2,22 @@
 
 import re
 
-def unpack_packer(source: str) -> str:
-    """https://github.com/beautifier/js-beautify/blob/main/python/jsbeautifier/unpackers/packer.py"""
-
+class Packer:
+    """
+    P.A.C.K.E.R. sıkıştırma ve çözme işlemleri için bir sınıf.
+    ! » https://github.com/beautifier/js-beautify/blob/main/python/jsbeautifier/unpackers/packer.py
+    """
+    @staticmethod
     def clean_escape_sequences(source: str) -> str:
+        """Kaçış dizilerini temizler."""
         source = re.sub(r'\\\\', r'\\', source)
         source = source.replace("\\'", "'")
         source = source.replace('\\"', '"')
         return source
 
-    source = clean_escape_sequences(source)
-
+    @staticmethod
     def extract_arguments(source: str) -> tuple[str, list[str], int, int]:
+        """P.A.C.K.E.R. formatındaki kaynak koddan argümanları çıkarır."""
         match = re.search(r"}\('(.*)',(\d+),(\d+),'(.*)'\.split\('\|'\)", source, re.DOTALL)
 
         if not match:
@@ -23,21 +27,36 @@ def unpack_packer(source: str) -> str:
 
         return payload, symtab.split("|"), int(radix), int(count)
 
+    @staticmethod
     def convert_base(s: str, base: int) -> int:
+        """Bir sayıyı belirli bir tabandan ondalık tabana çevirir."""
         alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
         return sum(alphabet.index(char) * (base**idx) for idx, char in enumerate(reversed(s)))
 
-    payload, symtab, radix, count = extract_arguments(source)
+    @staticmethod
+    def lookup_symbol(match: re.Match, symtab: list[str], radix: int) -> str:
+        """Sembolleri arar ve yerine koyar."""
+        word  = match[0]
+
+        return symtab[Packer.convert_base(word, radix)] or word
 
-    if count != len(symtab):
-        raise ValueError("Malformed P.A.C.K.E.R. symtab.")
+    @staticmethod
+    def unpack(source: str) -> str:
+        """P.A.C.K.E.R. formatındaki sıkıştırılmış bir kaynağı çözer."""
+        source = Packer.clean_escape_sequences(source)
 
-    def lookup_symbol(match: re.Match) -> str:
-        word = match[0]
+        payload, symtab, radix, count = Packer.extract_arguments(source)
 
-        return symtab[convert_base(word, radix)] or word
+        if count != len(symtab):
+            raise ValueError("Malformed P.A.C.K.E.R. symtab.")
 
-    unpacked_source = re.sub(r"\b\w+\b", lookup_symbol, payload)
+        return re.sub(r"\b\w+\b", lambda match: Packer.lookup_symbol(match, symtab, radix), payload)
 
-    return unpacked_source
+    @staticmethod
+    def pack(source: str, radix: int = 62) -> str:
+        """Bir metni P.A.C.K.E.R. formatında sıkıştırır."""
+        # Bu işlev, simgeleri ve sıkıştırılmış metni yeniden oluşturmak için bir yol sağlar.
+        # Ancak bu, belirli bir algoritma veya sıkıştırma tekniğine bağlıdır.
+        # Gerçekleştirilmesi zor olabilir çünkü P.A.C.K.E.R.'ın spesifik sıkıştırma mantığını takip etmek gerekir.
+        raise NotImplementedError("Packing function is not implemented.")

Kekik/Sifreleme/__init__.py

@@ -1,6 +1,7 @@
 # Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
 
-from .AtobRtt  import atob, rtt
-from .Aes      import decrypt_aes_with_custom_kdf
-from .Packer   import unpack_packer
-from .CryptoJS import CryptoJS
+from .AtobRtt    import atob, rtt
+from .AESManager import AESManager
+from .Packer     import Packer
+from .CryptoJS   import CryptoJS
+from .HexCodec   import HexCodec

{Kekik-1.5.0.dist-info → Kekik-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Kekik
-Version: 1.5.0
+Version: 1.5.1
 Summary: İşlerimizi kolaylaştıracak fonksiyonların el altında durduğu kütüphane..
 Home-page: https://github.com/keyiflerolsun/Kekik
 Author: keyiflerolsun

{Kekik-1.5.0.dist-info → Kekik-1.5.1.dist-info}/RECORD

@@ -22,18 +22,19 @@ Kekik/terminal_baslik.py,sha256=sE8jmQprBcz8KaYTwxGOSJCDNjMNwl-ZzHi1s2_M-zA,733
 Kekik/txt_fetis.py,sha256=MC-L1g3TnqCeDTXoleKSHiLbU-_zievF-qmWXqHQC2g,2611
 Kekik/unicode_tr.py,sha256=OUHfbVyKrt0IckyVy-d92gY3JZVkqgBpMZJLon2rCi0,1092
 Kekik/zaman_donustur.py,sha256=x-h85vS9D_xJ0jJO9svjIX8gCKYyGb_03AIzUjMk7tI,595
-Kekik/Sifreleme/Aes.py,sha256=V2sdoEkVlcC2Oquz6FXUQrwZFigm8gOWBLDdBWdWrhM,1517
+Kekik/Sifreleme/AESManager.py,sha256=eYgbHANtYrWFJgLeUuj63tlL0Yn8gyPCJYbXfWlpNbo,2389
 Kekik/Sifreleme/AtobRtt.py,sha256=6xsSmZVsTT3tJ0oivm9leZFuKlnsaDenuIvoVNJHoV4,463
-Kekik/Sifreleme/CryptoJS.py,sha256=4EqCh4HlI_xnYVoiG6Y-2AaU_BqvqOpHFYDFrBLzJ70,1821
-Kekik/Sifreleme/Packer.py,sha256=cCQZMliq1xuggKkKEs244T5SclU4Q-V4XXVFY_5zHHU,1475
-Kekik/Sifreleme/__init__.py,sha256=t0VhObE9cebxYCg6TcTb0EhjsNQv83rChNG3OblL_Dg,226
+Kekik/Sifreleme/CryptoJS.py,sha256=ZOcm7HYM5kA0HIwWv9kwBbe12105x1XDbTqmjlATJN8,2699
+Kekik/Sifreleme/HexCodec.py,sha256=1vQowAuC9zyqLPu7AFBMkz1CjeWxGJJohSXFTz-sy5Y,799
+Kekik/Sifreleme/Packer.py,sha256=4DWFMyhqsZvVKIUjZNruR8RwHSjuPKJi8WDCUTBGWCQ,2600
+Kekik/Sifreleme/__init__.py,sha256=Mxx9uYTYbApjWEXRwlTHdwhNvEDBsrRpe36uiXyvuEU,243
 Kekik/kisi_ver/__init__.py,sha256=gH613YZC3ziE7f67dViefRSuwDwsHyVvXHpM5CzZ2q4,1386
 Kekik/kisi_ver/biyografiler.py,sha256=5Xv1ixaDGHGtl5Nf92jo9dPgF3jDXOGEPmWgoEsn9j8,189486
 Kekik/kisi_ver/isimler.py,sha256=zHVimWL_4TvoLE3qzWQslDBc8-IJZSB02s0vRwsVM1g,88066
 Kekik/kisi_ver/soyisimler.py,sha256=YQJYp2SjENgwOaCa9mmShxPYeeUll2cq8Vox-d8_kB8,78485
-Kekik-1.5.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-Kekik-1.5.0.dist-info/METADATA,sha256=wL3E_tmOOqWBwyCHRvp7sonWhyRlleE9i47vY_QiHI4,11793
-Kekik-1.5.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-Kekik-1.5.0.dist-info/entry_points.txt,sha256=yjBifxtRlqfg8lPkH4Bu-urSa5ecptCHsuth-DcyWcg,59
-Kekik-1.5.0.dist-info/top_level.txt,sha256=NotddscfgxawvuRyAa7xkgnMhyteFDcBxb5aU5GY3BM,6
-Kekik-1.5.0.dist-info/RECORD,,
+Kekik-1.5.1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+Kekik-1.5.1.dist-info/METADATA,sha256=Guk6X4sEWceUlnRa1t9rFGkdi1G9BbBj3SD6Z5VlSgE,11793
+Kekik-1.5.1.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+Kekik-1.5.1.dist-info/entry_points.txt,sha256=yjBifxtRlqfg8lPkH4Bu-urSa5ecptCHsuth-DcyWcg,59
+Kekik-1.5.1.dist-info/top_level.txt,sha256=NotddscfgxawvuRyAa7xkgnMhyteFDcBxb5aU5GY3BM,6
+Kekik-1.5.1.dist-info/RECORD,,

Kekik/Sifreleme/Aes.py

@@ -1,39 +0,0 @@
-# ! Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
-
-from json                import loads
-from Crypto.Hash         import MD5
-from Crypto.Cipher       import AES
-from Crypto.Util.Padding import unpad
-from base64              import b64decode
-
-def decrypt_aes_with_custom_kdf(crypted_data, password) -> str:
-    """
-    AES/CBC/PKCS5Padding şifreleme şemasını kullanarak şifre çözme işlemi yapar.
-
-    :param crypted_data: JSON formatında şifrelenmiş veri (ct, iv, s içerir).
-    :param password: Anahtar türetmede kullanılacak şifre.
-    :return: Çözülmüş veri (string olarak).
-    """
-
-    def generate_key_and_iv(password, salt, key_length=32, iv_length=16, iterations=1):
-        """Anahtar ve IV oluşturmak için bir KDF fonksiyonu."""
-        d = d_i = b""
-        while len(d) < key_length + iv_length:
-            d_i = MD5.new(d_i + password + salt).digest()
-            for _ in range(1, iterations):
-                d_i = MD5.new(d_i).digest()
-            d += d_i
-        return d[:key_length], d[key_length : key_length + iv_length]
-
-    def hex_to_bytes(hex_str):
-        """Hex string'i byte array'e çevirir."""
-        return bytes.fromhex(hex_str)
-
-    data      = loads(crypted_data)
-
-    key, iv   = generate_key_and_iv(password, hex_to_bytes(data["s"]), iv_length=len(data["iv"]) // 2)
-
-    cipher    = AES.new(key, AES.MODE_CBC, iv)
-    decrypted = unpad(cipher.decrypt(b64decode(data["ct"])), AES.block_size)
-
-    return decrypted.decode("utf-8")