Kekik 1.5.0__tar.gz → 1.5.2__tar.gz

kekik-1.5.2/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-1.5.0 → kekik-1.5.2}/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
+    Paroladan türetilmiş anahtar ile AES/CBC/PKCS7Padding şifreleme ve şifre çözme işlemleri için bir sınıf.
+    CryptoJS AES yöntemine uygundur.
+    ! » https://gist.github.com/thackerronak/554c985c3001b16810af5fc0eb5c358f
     """
     KEY_SIZE    = 32
     IV_SIZE     = 16
@@ -17,6 +19,7 @@ class CryptoJS:
 
     @staticmethod
     def evp_kdf(password, salt, key_size=32, iv_size=16, iterations=1, hash_algorithm="md5"):
+        """Paroladan Anahtar ve IV oluşturmak için bir KDF fonksiyonu."""
         target_key_size = key_size + iv_size
         derived_bytes   = b""
         block           = None
@@ -37,8 +40,23 @@ class CryptoJS:
 
         return derived_bytes[:key_size], derived_bytes[key_size:key_size + iv_size]
 
+    @staticmethod
+    def encrypt(password, plain_text):
+        """Verilen metni AES/CBC/PKCS7Padding şifreleme yöntemi ile şifreler."""
+        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):
+        """Verilen şifreli metni AES/CBC/PKCS7Padding şifreleme yöntemi ile çözer."""
         ct_bytes          = base64.b64decode(cipher_text)
         salt              = ct_bytes[8:16]
         cipher_text_bytes = ct_bytes[16:]
@@ -50,6 +68,20 @@ class CryptoJS:
 
         return CryptoJS._unpad(plain_text).decode("utf-8")
 
+    @staticmethod
+    def _pad(s):
+        """Veriyi AES blok boyutuna göre doldurur (PKCS7)."""
+        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:])]
+        """Dolguyu kaldırır (PKCS7)."""
+        return s[:-ord(s[-1:])]
+
+    @staticmethod
+    def generate_salt(length):
+        """Belirtilen uzunlukta rastgele bir tuz oluşturur."""
+        return get_random_bytes(length)

kekik-1.5.2/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-1.5.2/Kekik/Sifreleme/Packer.py

@@ -0,0 +1,62 @@
+# ! Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+import re
+
+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
+
+    @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:
+            raise ValueError("Invalid P.A.C.K.E.R. source format.")
+
+        payload, radix, count, symtab = match.groups()
+
+        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)))
+
+    @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
+
+    @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)
+
+        payload, symtab, radix, count = Packer.extract_arguments(source)
+
+        if count != len(symtab):
+            raise ValueError("Malformed P.A.C.K.E.R. symtab.")
+
+        return re.sub(r"\b\w+\b", lambda match: Packer.lookup_symbol(match, symtab, radix), payload)
+
+    @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-1.5.2/Kekik/Sifreleme/__init__.py

@@ -0,0 +1,7 @@
+# Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
+
+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 → kekik-1.5.2}/Kekik.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Kekik
-Version: 1.5.0
+Version: 1.5.2
 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 → kekik-1.5.2}/Kekik.egg-info/SOURCES.txt

@@ -32,9 +32,10 @@ Kekik.egg-info/dependency_links.txt
 Kekik.egg-info/entry_points.txt
 Kekik.egg-info/requires.txt
 Kekik.egg-info/top_level.txt
-Kekik/Sifreleme/Aes.py
+Kekik/Sifreleme/AESManager.py
 Kekik/Sifreleme/AtobRtt.py
 Kekik/Sifreleme/CryptoJS.py
+Kekik/Sifreleme/HexCodec.py
 Kekik/Sifreleme/Packer.py
 Kekik/Sifreleme/__init__.py
 Kekik/kisi_ver/__init__.py

{kekik-1.5.0 → kekik-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Kekik
-Version: 1.5.0
+Version: 1.5.2
 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 → kekik-1.5.2}/setup.py

@@ -6,7 +6,7 @@ from io         import open
 setup(
     # ? Genel Bilgiler
     name         = "Kekik",
-    version      = "1.5.0",
+    version      = "1.5.2",
     url          = "https://github.com/keyiflerolsun/Kekik",
     description  = "İşlerimizi kolaylaştıracak fonksiyonların el altında durduğu kütüphane..",
     keywords     = ["Kekik", "KekikAkademi", "keyiflerolsun"],

kekik-1.5.0/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")

kekik-1.5.0/Kekik/Sifreleme/Packer.py

@@ -1,43 +0,0 @@
-# ! Bu araç @keyiflerolsun tarafından | @KekikAkademi için yazılmıştır.
-
-import re
-
-def unpack_packer(source: str) -> str:
-    """https://github.com/beautifier/js-beautify/blob/main/python/jsbeautifier/unpackers/packer.py"""
-
-    def clean_escape_sequences(source: str) -> str:
-        source = re.sub(r'\\\\', r'\\', source)
-        source = source.replace("\\'", "'")
-        source = source.replace('\\"', '"')
-        return source
-
-    source = clean_escape_sequences(source)
-
-    def extract_arguments(source: str) -> tuple[str, list[str], int, int]:
-        match = re.search(r"}\('(.*)',(\d+),(\d+),'(.*)'\.split\('\|'\)", source, re.DOTALL)
-
-        if not match:
-            raise ValueError("Invalid P.A.C.K.E.R. source format.")
-
-        payload, radix, count, symtab = match.groups()
-
-        return payload, symtab.split("|"), int(radix), int(count)
-
-    def convert_base(s: str, base: int) -> int:
-        alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-
-        return sum(alphabet.index(char) * (base**idx) for idx, char in enumerate(reversed(s)))
-
-    payload, symtab, radix, count = extract_arguments(source)
-
-    if count != len(symtab):
-        raise ValueError("Malformed P.A.C.K.E.R. symtab.")
-
-    def lookup_symbol(match: re.Match) -> str:
-        word = match[0]
-
-        return symtab[convert_base(word, radix)] or word
-
-    unpacked_source = re.sub(r"\b\w+\b", lookup_symbol, payload)
-
-    return unpacked_source

kekik-1.5.0/Kekik/Sifreleme/__init__.py

@@ -1,6 +0,0 @@
-# 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