cipher-crypter 3.0.0__py3-none-any.whl

cipher_crypter/__init__.py

@@ -0,0 +1 @@
+__version__ = "3.0.0"

cipher_crypter/cli.py

@@ -0,0 +1,991 @@
+#!/usr/bin/env python3
+"""
+╔═══════════════════════════════════════════════╗
+║          Cipher Crypter v3.0  —  by JosephX          ║
+║      Gelişmiş Terminal Şifreleme Aracı         ║
+╚═══════════════════════════════════════════════╝
+"""
+
+import time, os, sys, json, random, datetime, hashlib, struct, zlib, hmac
+from dataclasses import dataclass, asdict
+
+# ── Renk kodları ─────────────────────────────────────────────────────────────
+class C:
+    GREEN      = "\033[92m"
+    GREEN_DIM  = "\033[32m"
+    AMBER      = "\033[33m"
+    RED        = "\033[91m"
+    CYAN       = "\033[96m"
+    MAGENTA    = "\033[95m"
+    WHITE      = "\033[97m"
+    GRAY       = "\033[90m"
+    BOLD       = "\033[1m"
+    RESET      = "\033[0m"
+    BLINK      = "\033[5m"
+
+def supports_color():
+    return hasattr(sys.stdout, "isatty") and sys.stdout.isatty()
+
+if not supports_color():
+    for attr in vars(C):
+        if not attr.startswith("_"):
+            setattr(C, attr, "")
+
+# ── Şifreleme seviyeleri ──────────────────────────────────────────────────────
+LEVELS = {
+    1: ("EASY",       C.GREEN,   "░",  "Temel sembol kodlama"),
+    2: ("MEDIUM",     C.CYAN,    "▒",  "Sembol + XOR katmanı"),
+    3: ("HARD",       C.AMBER,   "▓",  "Sembol + XOR + Byte karıştırma"),
+    4: ("DEVIL",      C.RED,     "▲",  "HARD + Vigenere + Tuz"),
+    5: ("IMPOSSIBLE", C.MAGENTA, "☠",  "DEVIL × 3 tur + Padding + Zlib"),
+}
+
+LEVEL_COLORS = {1: C.GREEN, 2: C.CYAN, 3: C.AMBER, 4: C.RED, 5: C.MAGENTA}
+
+# ── Temel sembol seti (base-13) ───────────────────────────────────────────────
+CHARS = "░▒▓╨╬╥╫╤╞╪╩╧╙"
+BASE  = len(CHARS)   # 13
+
+# ── Desteklenen binary uzantılar ──────────────────────────────────────────────
+BINARY_EXTS = {
+    # Video
+    ".mp4", ".mkv", ".avi", ".mov", ".wmv", ".flv", ".webm", ".m4v",
+    # Ses
+    ".mp3", ".wav", ".flac", ".ogg", ".aac", ".m4a", ".wma",
+    # Resim
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".tiff", ".ico", ".svg",
+    # Ofis / Doküman
+    ".pdf", ".docx", ".xlsx", ".pptx", ".odt", ".ods",
+    # Arşiv
+    ".zip", ".rar", ".7z", ".tar", ".gz", ".bz2", ".xz", ".iso",
+    # Veri / DB
+    ".csv", ".json", ".xml", ".db", ".sqlite", ".sql",
+    # Uygulama / Sistem
+    ".exe", ".dll", ".apk", ".bin", ".so", ".dylib",
+    # Font / Diğer
+    ".ttf", ".otf", ".woff", ".woff2",
+}
+
+TEXT_EXTS = {".txt", ".md", ".log", ".py", ".js", ".ts", ".html", ".css",
+             ".sh", ".bat", ".cfg", ".ini", ".yaml", ".yml", ".toml"}
+
+def dosya_tipi(path: str) -> str:
+    """'binary', 'text', veya 'unknown' döndür."""
+    ext = os.path.splitext(path)[1].lower()
+    if ext in BINARY_EXTS: return "binary"
+    if ext in TEXT_EXTS:   return "text"
+    return "unknown"   # bilinmeyen → binary olarak işle
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  ŞİFRELEME ALGORİTMALARI  (bytes → bytes)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _b13_enc(data: bytes) -> bytes:
+    """Her byte'ı 3 CHARS sembolüyle kodla (hızlı lookup table)."""
+    # Lookup table: 256 byte → 3 sembol (UTF-8, her sembol 3 byte = 9 byte/giriş)
+    tbl = []
+    for b in range(256):
+        tbl.append((CHARS[b // (BASE * BASE) % BASE] +
+                    CHARS[(b // BASE) % BASE] +
+                    CHARS[b % BASE]).encode("utf-8"))
+    out = bytearray()
+    for b in data:
+        out += tbl[b]
+    return bytes(out)
+
+def _b13_dec(data: bytes) -> bytes:
+    s = data.decode("utf-8")
+    if len(s) % 3 != 0:
+        raise ValueError("Bozuk veri: uzunluk 3'ün katı değil.")
+    # Ters lookup: sembol → değer
+    rev = {c: i for i, c in enumerate(CHARS)}
+    out = bytearray(len(s) // 3)
+    for i in range(0, len(s), 3):
+        out[i // 3] = rev[s[i]] * BASE * BASE + rev[s[i+1]] * BASE + rev[s[i+2]]
+    return bytes(out)
+
+def _xor(data: bytes, key: bytes) -> bytes:
+    """Hızlı XOR: key'i veri uzunluğuna tileleyip bytearray XOR."""
+    kl = len(key)
+    n  = len(data)
+    # key'i tam kat + kırıntı olarak tile et
+    reps, rem = divmod(n, kl)
+    full_key = bytearray(key * reps + key[:rem])
+    out = bytearray(n)
+    for i in range(n):
+        out[i] = data[i] ^ full_key[i]
+    return bytes(out)
+
+def _make_perm(n: int, seed: int):
+    """Fisher-Yates ile deterministik permütasyon döndür (list[int])."""
+    rng = random.Random(seed)
+    perm = list(range(n))
+    for i in range(n - 1, 0, -1):
+        j = rng.randint(0, i)
+        perm[i], perm[j] = perm[j], perm[i]
+    return perm
+
+def _shuffle(data: bytes, seed: int) -> bytes:
+    """Deterministik byte karıştırma.
+    perm[i] = j  anlamı: orijinal i. byte → çıktıda j. konuma gider.
+    out[perm[i]] = data[i]
+    """
+    n = len(data)
+    perm = _make_perm(n, seed)
+    out = bytearray(n)
+    for i, p in enumerate(perm):
+        out[p] = data[i]
+    return bytes(out)
+
+def _unshuffle(data: bytes, seed: int) -> bytes:
+    """_shuffle'ın tersi.
+    out[i] = data[perm[i]]  ← çünkü out[perm[i]]=data[i] idi
+    """
+    n = len(data)
+    perm = _make_perm(n, seed)
+    out = bytearray(n)
+    for i, p in enumerate(perm):
+        out[i] = data[p]
+    return bytes(out)
+
+def _vigenere_enc(data: bytes, key: bytes) -> bytes:
+    kl = len(key)
+    out = bytearray(len(data))
+    for i, b in enumerate(data):
+        out[i] = (b + key[i % kl]) & 0xFF
+    return bytes(out)
+
+def _vigenere_dec(data: bytes, key: bytes) -> bytes:
+    kl = len(key)
+    out = bytearray(len(data))
+    for i, b in enumerate(data):
+        out[i] = (b - key[i % kl]) & 0xFF
+    return bytes(out)
+
+def _derive_keys(password: str) -> dict:
+    """Şifreden deterministik anahtarlar türet."""
+    h = hashlib.sha256(password.encode("utf-8")).digest()
+    return {
+        "xor":      h[:16],
+        "shuffle":  struct.unpack("<Q", h[16:24])[0],
+        "vigenere": h[8:24],
+        "salt":     h[4:12],
+        "mac":      h,
+    }
+
+# MAC_SIZE: şifreli veriye eklenen imza uzunluğu (byte)
+MAC_SIZE = 16
+
+def _mac_sign(data: bytes, key: bytes) -> bytes:
+    """Verinin HMAC-SHA256 imzasının ilk MAC_SIZE byte'ını döndür."""
+    return hmac.new(key, data, hashlib.sha256).digest()[:MAC_SIZE]
+
+def _mac_verify(data: bytes, key: bytes, tag: bytes) -> bool:
+    """İmzayı doğrula; timing-safe karşılaştırma kullan."""
+    expected = _mac_sign(data, key)
+    return hmac.compare_digest(expected, tag)
+
+# ── Seviyeye göre şifreleme / çözme ──────────────────────────────────────────
+
+def _real_progress(label_text: str, fn, *args, color=C.GREEN):
+    """fn(*args) çalıştırır, aynı anda sahte ama gerçekçi progress gösterir."""
+    import threading
+    result_box = [None]
+    err_box    = [None]
+    done       = threading.Event()
+
+    def worker():
+        try:
+            result_box[0] = fn(*args)
+        except Exception as e:
+            err_box[0] = e
+        finally:
+            done.set()
+
+    t = threading.Thread(target=worker, daemon=True)
+    t.start()
+
+    width = 44
+    filled = 0
+    step   = 0
+    while not done.is_set():
+        # Hızlı başla, yavaşla
+        inc = max(1, (width - filled) // 8) if filled < width * 0.9 else 0
+        filled = min(filled + inc, int(width * 0.97))
+        bar  = "█" * filled + "░" * (width - filled)
+        col  = color if filled / width < 0.8 else C.AMBER
+        print(f"\r  {C.GREEN_DIM}{label_text}{C.RESET} "
+              f"[{col}{bar}{C.RESET}] "
+              f"{C.WHITE}{int(filled/width*100):3d}%{C.RESET}",
+              end="", flush=True)
+        done.wait(timeout=0.15)
+        step += 1
+
+    # 100% göster
+    bar = "█" * width
+    print(f"\r  {C.GREEN_DIM}{label_text}{C.RESET} "
+          f"[{color}{bar}{C.RESET}] "
+          f"{C.WHITE}100%{C.RESET}")
+
+    if err_box[0]:
+        raise err_box[0]
+    return result_box[0]
+
+
+def enc_level(data: bytes, level: int, password: str,
+              show_progress: bool = False) -> bytes:
+    k = _derive_keys(password)
+    col = LEVEL_COLORS.get(level, C.GREEN)
+
+    def _run(label, fn, *args):
+        if show_progress:
+            return _real_progress(label, fn, *args, color=col)
+        return fn(*args)
+
+    if level == 1:
+        result = _run(f"[EASY] Kodlanıyor", _b13_enc, data)
+
+    elif level == 2:
+        d = _run(f"[MEDIUM] XOR", _xor, data, k["xor"])
+        result = _run(f"[MEDIUM] Kodlanıyor", _b13_enc, d)
+
+    elif level == 3:
+        d = _run(f"[HARD] XOR", _xor, data, k["xor"])
+        d = _run(f"[HARD] Karıştırılıyor", _shuffle, d, k["shuffle"])
+        result = _run(f"[HARD] Kodlanıyor", _b13_enc, d)
+
+    elif level == 4:
+        d = _run(f"[DEVIL] Vigenere", _vigenere_enc, data, k["vigenere"])
+        d = _run(f"[DEVIL] XOR", _xor, d, k["xor"])
+        d = _run(f"[DEVIL] Karıştırılıyor", _shuffle, d, k["shuffle"])
+        d = k["salt"] + d
+        result = _run(f"[DEVIL] Kodlanıyor", _b13_enc, d)
+
+    elif level == 5:
+        d = data
+        for turn in range(3):
+            tk = _derive_keys(password + str(turn))
+            d = _run(f"[IMPOSSIBLE] Tur {turn+1}/3 — Vigenere",
+                     _vigenere_enc, d, tk["vigenere"])
+            d = _run(f"[IMPOSSIBLE] Tur {turn+1}/3 — XOR",
+                     _xor, d, tk["xor"])
+            d = _run(f"[IMPOSSIBLE] Tur {turn+1}/3 — Karıştırma",
+                     _shuffle, d, tk["shuffle"])
+            d = tk["salt"] + d
+        pad_len = random.randint(16, 64)
+        pad = bytes(random.randint(0, 255) for _ in range(pad_len))
+        pad_header = struct.pack("<H", pad_len)
+        d = pad_header + pad + d
+        if show_progress:
+            d = _real_progress("[IMPOSSIBLE] Sıkıştırılıyor",
+                               zlib.compress, d, 1, color=col)
+        else:
+            d = zlib.compress(d, level=1)
+        result = _run(f"[IMPOSSIBLE] Son kodlama", _b13_enc, d)
+
+    else:
+        raise ValueError(f"Geçersiz seviye: {level}")
+
+    return _enc_with_mac(result, level, password)
+
+
+def _enc_with_mac(enc_fn_result: bytes, level: int, password: str) -> bytes:
+    """EASY hariç tüm seviyelerde sonuca MAC imzası ekle."""
+    if level == 1:
+        return enc_fn_result   # şifresiz, imza anlamsız
+    k = _derive_keys(password)
+    tag = _mac_sign(enc_fn_result, k["mac"])
+    return tag + enc_fn_result
+
+
+def _dec_verify_mac(data: bytes, level: int, password: str):
+    """MAC'i doğrula ve imzasız veriyi döndür. Hatalı şifrede ValueError fırlatır."""
+    if level == 1:
+        return data
+    if len(data) < MAC_SIZE:
+        raise ValueError("Bozuk veri: çok kısa.")
+    tag  = data[:MAC_SIZE]
+    body = data[MAC_SIZE:]
+    k = _derive_keys(password)
+    if not _mac_verify(body, k["mac"], tag):
+        raise ValueError("Hatalı şifre veya bozuk dosya.")
+    return body
+
+
+def dec_level(data: bytes, level: int, password: str,
+              show_progress: bool = False, has_mac: bool = True) -> bytes:
+    # MAC doğrula — yalnızca yeni format (CIPHERX4) dosyalarda
+    if has_mac:
+        data = _dec_verify_mac(data, level, password)
+
+    k = _derive_keys(password)
+    col = LEVEL_COLORS.get(level, C.GREEN)
+
+    def _run(label, fn, *args):
+        if show_progress:
+            return _real_progress(label, fn, *args, color=col)
+        return fn(*args)
+
+    d = _run(f"[{LEVELS[level][0]}] Çözümleniyor", _b13_dec, data)
+
+    if level == 1:
+        return d
+
+    elif level == 2:
+        return _run(f"[MEDIUM] XOR tersle", _xor, d, k["xor"])
+
+    elif level == 3:
+        d = _run(f"[HARD] Sıra geri al", _unshuffle, d, k["shuffle"])
+        return _run(f"[HARD] XOR tersle", _xor, d, k["xor"])
+
+    elif level == 4:
+        d = d[len(k["salt"]):]
+        d = _run(f"[DEVIL] Sıra geri al", _unshuffle, d, k["shuffle"])
+        d = _run(f"[DEVIL] XOR tersle", _xor, d, k["xor"])
+        return _run(f"[DEVIL] Vigenere tersle", _vigenere_dec, d, k["vigenere"])
+
+    elif level == 5:
+        if show_progress:
+            d = _real_progress("[IMPOSSIBLE] Açılıyor", zlib.decompress, d,
+                               color=col)
+        else:
+            d = zlib.decompress(d)
+        pad_len = struct.unpack("<H", d[:2])[0]
+        d = d[2 + pad_len:]
+        for turn in range(2, -1, -1):
+            tk = _derive_keys(password + str(turn))
+            d = d[len(tk["salt"]):]
+            d = _run(f"[IMPOSSIBLE] Tur {turn+1}/3 — Sıra geri al",
+                     _unshuffle, d, tk["shuffle"])
+            d = _run(f"[IMPOSSIBLE] Tur {turn+1}/3 — XOR tersle",
+                     _xor, d, tk["xor"])
+            d = _run(f"[IMPOSSIBLE] Tur {turn+1}/3 — Vigenere tersle",
+                     _vigenere_dec, d, tk["vigenere"])
+        return d
+
+    raise ValueError(f"Geçersiz seviye: {level}")
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  GÖRSEL & YARDIMCI
+# ─────────────────────────────────────────────────────────────────────────────
+
+ASCII_LOGO = f"""\
+{C.GREEN}{C.BOLD}
+ ██████╗██╗██████╗ ██╗  ██╗███████╗██████╗       ██╗  ██╗
+██╔════╝██║██╔══██╗██║  ██║██╔════╝██╔══██╗      ╚██╗██╔╝
+██║     ██║██████╔╝███████║█████╗  ██████╔╝  ████╗╚███╔╝ 
+██║     ██║██╔═══╝ ██╔══██║██╔══╝  ██╔══██╗  ╚═══╝██╔██╗ 
+╚██████╗██║██║     ██║  ██║███████╗██║  ██║      ██╔╝ ██╗
+ ╚═════╝╚═╝╚═╝     ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝      ╚═╝  ╚═╝
+{C.RESET}{C.GREEN_DIM}          Gelişmiş Terminal Şifreleme Aracı  v3.0{C.RESET}"""
+
+DIVIDER  = f"{C.GREEN_DIM}{'═' * 60}{C.RESET}"
+THIN_DIV = f"{C.GREEN_DIM}{'─' * 60}{C.RESET}"
+
+def clear():
+    os.system("cls" if os.name == "nt" else "clear")
+
+def prompt(text="", color=C.GREEN_DIM):
+    return input(f"{color}{text}root@cipher:~$ {C.RESET}")
+
+def info(msg):    print(f"  {C.GREEN_DIM}► {msg}{C.RESET}")
+def success(msg): print(f"  {C.GREEN}✓ {msg}{C.RESET}")
+def warn(msg):    print(f"  {C.AMBER}⚠ {msg}{C.RESET}")
+def error(msg):   print(f"  {C.RED}✗ {msg}{C.RESET}")
+def label(msg):   print(f"\n  {C.CYAN}{msg}{C.RESET}")
+
+def progress_bar(label_text: str, duration: float = 0.6, width: int = 44, color=C.GREEN):
+    steps = 35
+    for i in range(steps + 1):
+        pct    = i / steps
+        filled = int(width * pct)
+        bar    = "█" * filled + "░" * (width - filled)
+        bar_c  = color if pct < 0.8 else C.AMBER
+        print(f"\r  {C.GREEN_DIM}{label_text}{C.RESET} "
+              f"[{bar_c}{bar}{C.RESET}] "
+              f"{C.WHITE}{int(pct*100):3d}%{C.RESET}", end="", flush=True)
+        time.sleep(duration / steps)
+    print()
+
+def matrix_rain(rows=3, cols=56, duration=0.6):
+    chars = list(CHARS) + list("01░▒▓")
+    end_t = time.time() + duration
+    while time.time() < end_t:
+        for _ in range(rows):
+            line = "".join(random.choice(chars) for _ in range(cols))
+            print(f"  {C.GREEN_DIM}{line}{C.RESET}")
+        time.sleep(0.07)
+        print(f"\033[{rows}A", end="")
+    print(f"\033[{rows}B", end="")
+
+def hacker_animasyon(cozulmus: str, sifreli: str):
+    print()
+    info("Şifre çözme protokolü başlatıldı...")
+    time.sleep(0.3)
+    print()
+    matrix_rain(rows=2, duration=0.5)
+    print()
+    progress_bar("Analiz ediliyor", duration=0.7)
+    print()
+    print(f"  {C.GREEN_DIM}», ", end="", flush=True)
+    for i in range(len(cozulmus) + 1):
+        gorunen = cozulmus[:i]
+        kalan   = sifreli[i*3 : i*3 + min(24, len(sifreli) - i*3)]
+        print(f"\r  {C.GREEN}» {gorunen}{C.GREEN_DIM}{kalan}{' ' * 6}",
+              end="", flush=True)
+        time.sleep(0.06)
+    print(f"\r  {C.GREEN}» {cozulmus}{' ' * 30}{C.RESET}")
+    print()
+
+def devil_animasyon(level: int):
+    """Seviyeye özel başlangıç animasyonu."""
+    name, col, sym, _ = LEVELS[level]
+    if level <= 2:
+        progress_bar(f"[{name}] Şifreleniyor", duration=0.5, color=col)
+    elif level == 3:
+        print()
+        matrix_rain(rows=2, duration=0.4)
+        progress_bar(f"[{name}] Karıştırılıyor", duration=0.7, color=col)
+    elif level == 4:
+        print()
+        matrix_rain(rows=3, duration=0.6)
+        progress_bar(f"[{name}] Katmanlar uygulanıyor", duration=1.0, color=col)
+    elif level == 5:
+        print()
+        for _ in range(3):
+            matrix_rain(rows=2, duration=0.4)
+            time.sleep(0.1)
+        progress_bar(f"[{name}] Tur 1/3", duration=0.8, color=col)
+        progress_bar(f"[{name}] Tur 2/3", duration=0.8, color=col)
+        progress_bar(f"[{name}] Tur 3/3", duration=0.8, color=col)
+        progress_bar(f"[{name}] Finalize", duration=0.5, color=col)
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  DOSYA OKUMA / YAZMA
+# ─────────────────────────────────────────────────────────────────────────────
+
+def oku_dosya(path: str) -> bytes:
+    """Her türlü dosyayı bytes olarak oku."""
+    with open(path, "rb") as f:
+        return f.read()
+
+def yaz_dosya(path: str, data: bytes):
+    with open(path, "wb") as f:
+        f.write(data)
+
+def temizle_yol(p: str) -> str:
+    return p.strip().strip('"').strip("'")
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  .CIPHERX DOSYA FORMATI
+#  CIPHERX3 (eski): CIPHERX3:<seviye>:<ext>:<tip>\n  + şifreli veri (MAC yok)
+#  CIPHERX4 (yeni): CIPHERX4:<seviye>:<ext>:<tip>\n  + şifreli veri (MAC tag dahil)
+# ─────────────────────────────────────────────────────────────────────────────
+
+MAGIC_V3 = "CIPHERX3"   # geriye uyumluluk (MAC yok)
+MAGIC_V4 = "CIPHERX4"   # yeni format (MAC tag gömülü)
+MAGIC    = MAGIC_V4      # yeni dosyalar için
+
+def build_header(level: int, ext: str, tip: str) -> bytes:
+    return f"{MAGIC}:{level}:{ext}:{tip}\n".encode("utf-8")
+
+def parse_header(raw: bytes) -> tuple:
+    """(level, ext, tip, rest_data, has_mac) döndür."""
+    try:
+        nl = raw.index(b"\n")
+        header = raw[:nl].decode("utf-8")
+        rest   = raw[nl+1:]
+        parts  = header.split(":")
+        if len(parts) < 4:
+            raise ValueError()
+        magic = parts[0]
+        if magic == MAGIC_V4:
+            has_mac = True
+        elif magic == MAGIC_V3:
+            has_mac = False
+        else:
+            raise ValueError()
+        return int(parts[1]), parts[2], parts[3], rest, has_mac
+    except Exception:
+        raise ValueError("Geçersiz veya eski format CIPHERX dosyası.")
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  ŞİFRE SEÇİM MENÜSÜ
+# ─────────────────────────────────────────────────────────────────────────────
+
+def sifre_sec_ekran() -> tuple[int, str]:
+    """(level, password) döndür. İptal için (0, '') """
+    print()
+    print(f"  {THIN_DIV}")
+    print(f"  {C.BOLD}{C.WHITE}  Şifreleme Seviyesi Seç:{C.RESET}")
+    print(f"  {THIN_DIV}")
+    for lvl, (name, col, sym, desc) in LEVELS.items():
+        print(f"  {col}[{lvl}] {sym} {name:<12}{C.RESET}  {C.GRAY}{desc}{C.RESET}")
+    print(f"  {C.GRAY}[0] İptal{C.RESET}")
+    print(f"  {THIN_DIV}")
+    print()
+
+    while True:
+        secim = prompt("Seviye (1-5): ").strip()
+        if secim == "0": return 0, ""
+        if secim.isdigit() and 1 <= int(secim) <= 5:
+            level = int(secim)
+            break
+        warn("Geçersiz seviye.")
+
+    name, col, sym, _ = LEVELS[level]
+    print()
+
+    if level == 1:
+        info(f"{col}{name}{C.RESET} — şifre gerektirmez, Enter'a bas.")
+        password = ""
+    else:
+        import getpass
+        print(f"  {col}{sym} {name} seviyesi için şifre belirle:{C.RESET}")
+        while True:
+            try:
+                pw1 = getpass.getpass(f"  {C.GREEN_DIM}Şifre: {C.RESET}")
+                pw2 = getpass.getpass(f"  {C.GREEN_DIM}Tekrar: {C.RESET}")
+            except Exception:
+                # getpass desteklenmiyorsa
+                pw1 = prompt("Şifre: ")
+                pw2 = pw1
+            if pw1 == pw2 and pw1:
+                password = pw1
+                break
+            warn("Şifreler eşleşmedi veya boş, tekrar dene.")
+
+    print()
+    return level, password
+
+def sifre_gir_ekran(level: int) -> str:
+    """Çözme için şifre gir."""
+    name, col, sym, _ = LEVELS[level]
+    if level == 1:
+        return ""
+    import getpass
+    print(f"  {col}{sym} {name} — Şifreyi gir:{C.RESET}")
+    try:
+        return getpass.getpass(f"  {C.GREEN_DIM}Şifre: {C.RESET}")
+    except Exception:
+        return prompt("Şifre: ")
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  İSTATİSTİK & GEÇMİŞ
+# ─────────────────────────────────────────────────────────────────────────────
+
+@dataclass
+class GirdiCikti:
+    tip: str
+    girdi: str
+    cikti: str
+    zaman: str
+    seviye: str = "?"
+
+HISTORY_FILE = os.path.join(os.path.expanduser("~"), ".cipher_crypter_history.json")
+stats = {"enc": 0, "dec": 0, "bytes": 0}
+history: list[GirdiCikti] = []
+
+def load_history():
+    global history
+    if os.path.exists(HISTORY_FILE):
+        try:
+            with open(HISTORY_FILE, "r", encoding="utf-8") as f:
+                raw = json.load(f)
+            history = []
+            for item in raw:
+                if isinstance(item, dict):
+                    item.setdefault("seviye", "?")
+                    history.append(GirdiCikti(**item))
+        except Exception:
+            history = []
+
+def save_history():
+    try:
+        with open(HISTORY_FILE, "w", encoding="utf-8") as f:
+            json.dump([asdict(h) for h in history[-100:]], f,
+                      ensure_ascii=False, indent=2)
+    except Exception:
+        pass
+
+def add_to_history(tip, girdi, cikti, seviye="?"):
+    history.append(GirdiCikti(
+        tip=tip, girdi=girdi, cikti=cikti,
+        zaman=datetime.datetime.now().strftime("%d.%m.%Y %H:%M:%S"),
+        seviye=seviye,
+    ))
+    save_history()
+
+def show_stats():
+    print(f"\n  {THIN_DIV}")
+    print(f"  {C.GREEN_DIM}  ŞİFRELENEN {C.GREEN}{stats['enc']:>5}{C.RESET}"
+          f"  {C.GREEN_DIM}ÇÖZÜLEN {C.GREEN}{stats['dec']:>5}{C.RESET}"
+          f"  {C.GREEN_DIM}TOPLAM {C.GREEN}{stats['bytes']/1024:>8.1f} KB{C.RESET}")
+    print(f"  {THIN_DIV}\n")
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  MENÜ & HEADER
+# ─────────────────────────────────────────────────────────────────────────────
+
+def draw_header():
+    clear()
+    print(ASCII_LOGO)
+    print(DIVIDER)
+    show_stats()
+
+def show_menu():
+    print(f"  {C.GREEN}[1]{C.RESET} {C.WHITE}Şifrele{C.RESET}  "
+          f"{C.GRAY}(metin · txt · mp4 · mp3 · zip · docx · bilinmeyen...){C.RESET}")
+    print(f"  {C.GREEN}[2]{C.RESET} {C.WHITE}Şifre Çöz{C.RESET}  "
+          f"{C.GRAY}(.cipherx dosyası veya şifreli metin){C.RESET}")
+    print(f"  {C.GREEN}[3]{C.RESET} {C.WHITE}Hızlı Test{C.RESET}  "
+          f"{C.GRAY}(Şifrele → Çöz → Doğrula){C.RESET}")
+    print(f"  {C.GREEN}[4]{C.RESET} {C.WHITE}Geçmiş{C.RESET}")
+    print(f"  {C.GREEN}[5]{C.RESET} {C.WHITE}Hakkında{C.RESET}")
+    print(f"  {C.RED}[0]{C.RESET} {C.GRAY}Çıkış{C.RESET}")
+    print()
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  EKRANLAR
+# ─────────────────────────────────────────────────────────────────────────────
+
+def ekran_sifrele():
+    draw_header()
+    label("ŞİFRELEME MODU")
+    print(THIN_DIV)
+    girdi = prompt("Dosya yolu veya şifrelenecek metin: ")
+    if not girdi:
+        warn("Boş girdi."); time.sleep(1); return
+
+    girdi = temizle_yol(girdi)
+
+    # Dosya mı, metin mi?
+    if os.path.exists(girdi):
+        tip = dosya_tipi(girdi)
+        try:
+            data = oku_dosya(girdi)
+        except Exception as exc:
+            error(f"Dosya okunamadı: {exc}"); time.sleep(2); return
+        orijinal_ext = os.path.splitext(girdi)[1].lower() or ".bin"
+        kaynak_etiket = f"{girdi}  ({len(data)/1024:.1f} KB, {tip})"
+        is_file = True
+    else:
+        # Metin girişi
+        data = girdi.encode("utf-8")
+        orijinal_ext = ".txt"
+        tip = "text"
+        kaynak_etiket = f"metin ({len(data)} byte)"
+        is_file = False
+
+    info(f"Kaynak: {kaynak_etiket}")
+    print()
+
+    # Seviye & şifre seç
+    level, password = sifre_sec_ekran()
+    if level == 0: return
+
+    name, col, sym, _ = LEVELS[level]
+    print()
+    # devil_animasyon artık enc_level içinde gerçek progress olarak gösteriliyor
+
+    try:
+        sifreli_data = enc_level(data, level, password, show_progress=True)
+    except Exception as exc:
+        error(f"Şifreleme hatası: {exc}"); time.sleep(2); return
+
+    header = build_header(level, orijinal_ext, tip)
+    son_veri = header + sifreli_data
+
+    # Çıktı yolu
+    if is_file:
+        default_out = os.path.splitext(girdi)[0] + ".cipherx"
+    else:
+        default_out = os.path.join(os.getcwd(), "output.cipherx")
+
+    out_yol = prompt(f"Çıktı dosyası [Enter = {default_out}]: ").strip().strip('"').strip("'")
+    if not out_yol: out_yol = default_out
+    if not out_yol.lower().endswith(".cipherx"):
+        out_yol += ".cipherx"
+
+    try:
+        yaz_dosya(out_yol, son_veri)
+    except Exception as exc:
+        error(f"Kaydedilemedi: {exc}"); time.sleep(2); return
+
+    print()
+    success(f"Şifreleme tamamlandı!")
+    info(f"Seviye  : {col}{sym} {name}{C.RESET}")
+    info(f"Çıktı   : {out_yol}")
+    info(f"Boyut   : {len(data)/1024:.1f} KB → {len(son_veri)/1024:.1f} KB")
+    print()
+    stats["enc"] += 1
+    stats["bytes"] += len(data)
+    add_to_history("ENC", girdi[:60], out_yol, name)
+    input(f"  {C.GRAY}[ Devam için Enter ]{C.RESET} ")
+
+
+def ekran_coz():
+    draw_header()
+    label("ŞİFRE ÇÖZME MODU")
+    print(THIN_DIV)
+    girdi = prompt("Şifreli metin veya .cipherx dosya yolu: ")
+    if not girdi:
+        warn("Boş girdi."); time.sleep(1); return
+
+    girdi = temizle_yol(girdi)
+
+    # .cipherx dosyası mı?
+    if girdi.lower().endswith(".cipherx") or (os.path.exists(girdi) and _is_cipherx(girdi)):
+        if not os.path.exists(girdi):
+            error(f"Dosya bulunamadı: {girdi}"); time.sleep(2); return
+        _coz_dosya(girdi)
+        return
+
+    # Eski format metin mi? (EASY seviyesi, şifresiz)
+    _coz_metin(girdi)
+
+
+def _is_cipherx(path: str) -> bool:
+    try:
+        with open(path, "rb") as f:
+            start = f.read(len(MAGIC))
+        return start == MAGIC.encode("utf-8")
+    except Exception:
+        return False
+
+
+def _coz_dosya(dosya_yolu: str):
+    try:
+        raw = oku_dosya(dosya_yolu)
+    except Exception as exc:
+        error(f"Dosya okunamadı: {exc}"); time.sleep(2); return
+
+    try:
+        level, orijinal_ext, tip, sifreli_data, has_mac = parse_header(raw)
+    except ValueError as exc:
+        error(str(exc)); time.sleep(2); return
+
+    name, col, sym, _ = LEVELS.get(level, (str(level), C.WHITE, "?", ""))
+    info(f"Seviye algılandı: {col}{sym} {name}{C.RESET}")
+    info(f"Orijinal uzantı : {orijinal_ext}  |  Tip: {tip}")
+    print()
+
+    password = sifre_gir_ekran(level)
+    print()
+
+    try:
+        orijinal_data = dec_level(sifreli_data, level, password, show_progress=True, has_mac=has_mac)
+    except ValueError as exc:
+        msg = str(exc)
+        if "Hatalı şifre" in msg:
+            print()
+            error("╔══════════════════════════════════════════╗")
+            error("║   ✗  HATALI ŞİFRE — Çözme iptal edildi  ║")
+            error("╚══════════════════════════════════════════╝")
+        else:
+            error(f"Çözme hatası: {exc}")
+        time.sleep(2); return
+    except Exception as exc:
+        error(f"Çözme hatası: {exc}"); time.sleep(2); return
+
+    base = os.path.splitext(dosya_yolu)[0]
+    default_out = base + ".recovered" + orijinal_ext
+    out_yol = prompt(f"Çıktı dosyası [Enter = {default_out}]: ").strip().strip('"').strip("'")
+    if not out_yol: out_yol = default_out
+
+    try:
+        yaz_dosya(out_yol, orijinal_data)
+    except Exception as exc:
+        error(f"Kaydedilemedi: {exc}"); time.sleep(2); return
+
+    print()
+    success(f"Çözme tamamlandı!")
+    info(f"Seviye  : {col}{sym} {name}{C.RESET}")
+    info(f"Çıktı   : {out_yol}")
+    info(f"Boyut   : {len(orijinal_data)/1024:.1f} KB kurtarıldı")
+
+    # Metin ise ekrana da göster
+    if tip == "text" and len(orijinal_data) < 2000:
+        try:
+            metin_str = orijinal_data.decode("utf-8")
+            print()
+            hacker_animasyon(metin_str, sifreli_data.decode("utf-8", errors="replace"))
+        except Exception:
+            pass
+    print()
+    stats["dec"] += 1
+    stats["bytes"] += len(orijinal_data)
+    add_to_history("DEC", dosya_yolu, out_yol, name)
+    input(f"  {C.GRAY}[ Devam için Enter ]{C.RESET} ")
+
+
+def _coz_metin(sifreli_str: str):
+    """Eski tarz düz metin şifresi çöz (seviye 1 varsayılan)."""
+    info("Düz metin modu (EASY seviyesi varsayılıyor)...")
+    print()
+    progress_bar("Analiz ediliyor", duration=0.5)
+    try:
+        # Önce EASY dene
+        data = sifreli_str.encode("utf-8")
+        orijinal = dec_level(data, 1, "")
+        metin = orijinal.decode("utf-8")
+    except Exception:
+        error("Geçersiz şifreli veri! Semboller tanınamadı veya format hatalı.")
+        info("Not: Şifre korumalı dosyalar için .cipherx formatını kullanın.")
+        time.sleep(2); return
+
+    hacker_animasyon(metin, sifreli_str)
+    print()
+    out_yol = prompt("Çıktı dosyası [boş = ekrana yaz]: ").strip().strip('"').strip("'")
+    if out_yol:
+        try:
+            yaz_dosya(out_yol, metin.encode("utf-8"))
+            success(f"Kaydedildi: {out_yol}")
+        except Exception as exc:
+            error(f"Kaydedilemedi: {exc}")
+    else:
+        success(f"Çözülen metin ({len(metin)} karakter):")
+        print(f"  {C.WHITE}{metin}{C.RESET}")
+    print()
+    stats["dec"] += 1
+    stats["bytes"] += len(metin)
+    add_to_history("DEC", sifreli_str[:40], metin[:40], "EASY")
+    input(f"  {C.GRAY}[ Devam için Enter ]{C.RESET} ")
+
+
+def ekran_hizli_test():
+    draw_header()
+    label("HIZLI TEST MODU")
+    print(THIN_DIV)
+
+    metin = prompt("Test Metni: ")
+    if not metin:
+        warn("Boş metin."); time.sleep(1); return
+
+    level, password = sifre_sec_ekran()
+    if level == 0: return
+
+    name, col, sym, _ = LEVELS[level]
+    data = metin.encode("utf-8")
+    print()
+
+    info(f"Adım 1/3 — {col}{sym} {name}{C.RESET} şifreleniyor...")
+    progress_bar("", duration=0.5, color=col)
+    try:
+        enc = enc_level(data, level, password)
+    except Exception as exc:
+        error(f"Şifreleme hatası: {exc}"); time.sleep(2); return
+    preview = enc[:60].decode("utf-8", errors="replace")
+    success(f"Şifreli: {preview}{'…' if len(enc) > 60 else ''}")
+    print()
+
+    info("Adım 2/3 — Çözülüyor...")
+    progress_bar("", duration=0.5, color=col)
+    try:
+        dec_data = dec_level(enc, level, password)
+        dec = dec_data.decode("utf-8")
+    except Exception as exc:
+        error(f"Çözme hatası: {exc}"); time.sleep(2); return
+    success(f"Çözülen: {dec[:60]}{'…' if len(dec) > 60 else ''}")
+    print()
+
+    info("Adım 3/3 — Doğrulanıyor...")
+    progress_bar("", duration=0.3)
+    ok = dec == metin
+    print()
+    if ok:
+        success(f"TEST BAŞARILI ✓  — {col}{sym} {name}{C.RESET} tutarlı!")
+    else:
+        error("TEST BAŞARISIZ ✗  — Tutarsızlık tespit edildi!")
+    print()
+    info(f"Orijinal boyut : {len(data)} byte")
+    info(f"Şifreli boyut  : {len(enc)} byte  ({len(enc)/len(data):.1f}x)")
+    print()
+    input(f"  {C.GRAY}[ Devam için Enter ]{C.RESET} ")
+
+
+def ekran_gecmis():
+    draw_header()
+    label("GEÇMİŞ")
+    print(THIN_DIV)
+    if not history:
+        info("Geçmiş boş.")
+        input(f"\n  {C.GRAY}[ Devam için Enter ]{C.RESET} ")
+        return
+    gorunen = history[-15:][::-1]
+    for i, h in enumerate(gorunen, 1):
+        tip_str = f"{C.GREEN}ŞİF{C.RESET}" if "ENC" in h.tip else f"{C.AMBER}ÇÖZ{C.RESET}"
+        sev_col = next((LEVEL_COLORS[k] for k,v in LEVELS.items() if v[0]==h.seviye), C.GRAY)
+        plain_k = h.girdi[:30] + ("…" if len(h.girdi) > 30 else "")
+        print(f"  {C.GRAY}{i:>2}.{C.RESET} [{tip_str}] "
+              f"{sev_col}[{h.seviye:<10}]{C.RESET}  "
+              f"{C.WHITE}{plain_k:<33}{C.RESET}  "
+              f"{C.GRAY}{h.zaman}{C.RESET}")
+    print()
+    input(f"  {C.GRAY}[ Devam için Enter ]{C.RESET} ")
+
+
+def ekran_hakkinda():
+    draw_header()
+    label("HAKKINDA")
+    print(THIN_DIV)
+    lines = [
+        ("Cipher Crypter v3.0",                         C.WHITE),
+        ("Gelişmiş Terminal Şifreleme Aracı",      C.GREEN_DIM),
+        ("", ""),
+        ("SEVİYELER:", C.CYAN),
+        (f"  {C.GREEN}[1] ░ EASY      {C.GRAY}Temel sembol kodlama (şifresiz)", ""),
+        (f"  {C.CYAN}[2] ▒ MEDIUM    {C.GRAY}Sembol + XOR katmanı", ""),
+        (f"  {C.AMBER}[3] ▓ HARD      {C.GRAY}Sembol + XOR + Byte karıştırma", ""),
+        (f"  {C.RED}[4] ▲ DEVIL     {C.GRAY}HARD + Vigenere + Tuz", ""),
+        (f"  {C.MAGENTA}[5] ☠ IMPOSSIBLE{C.GRAY} DEVIL × 3 tur + Padding + Zlib", ""),
+        ("", ""),
+        ("DOSYA DESTEĞİ:", C.CYAN),
+        ("  mp4 · mp3 · wav · flac · ogg  (ses/video)",    C.GRAY),
+        ("  png · jpg · gif · webp · svg  (resim)",        C.GRAY),
+        ("  zip · rar · 7z · tar · gz · iso  (arşiv)",    C.GRAY),
+        ("  pdf · docx · xlsx · pptx  (ofis)",             C.GRAY),
+        ("  csv · json · xml · db · sqlite  (veri)",       C.GRAY),
+        ("  exe · apk · bin · dll  (uygulama)",            C.GRAY),
+        ("  + bilinmeyen uzantılar otomatik binary olarak şifrelenir", C.GREEN_DIM),
+        ("", ""),
+        ("FORMAT:", C.CYAN),
+        ("  .cipherx — Tüm metadata header'da saklanır.", C.GRAY),
+        ("  Çözerken seviye & uzantı otomatik algılanır.", C.GRAY),
+        ("", ""),
+        ("Geliştirici:",                C.GREEN_DIM),
+        ("JosephX", C.GREEN),
+    ]
+    for text, color in lines:
+        if text == "":
+            print()
+        else:
+            print(f"  {color}{text}{C.RESET}")
+    print()
+    input(f"  {C.GRAY}[ Devam için Enter ]{C.RESET} ")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+#  ANA DÖNGÜ
+# ─────────────────────────────────────────────────────────────────────────────
+
+def main():
+    load_history()
+    while True:
+        draw_header()
+        show_menu()
+        secim = prompt().strip()
+        if   secim == "1": ekran_sifrele()
+        elif secim == "2": ekran_coz()
+        elif secim == "3": ekran_hizli_test()
+        elif secim == "4": ekran_gecmis()
+        elif secim == "5": ekran_hakkinda()
+        elif secim == "0":
+            clear()
+            print(f"\n  {C.GREEN}İyi günler!{C.RESET}\n")
+            sys.exit(0)
+        else:
+            warn("Geçersiz seçim."); time.sleep(0.8)
+
+if __name__ == "__main__":
+    main()

cipher_crypter-3.0.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.1
+Name: cipher-crypter
+Version: 3.0.0
+Summary: Gelişmiş Terminal Şifreleme Aracı
+Author: JosephX
+Requires-Python: >=3.6
+

cipher_crypter-3.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+cipher_crypter/__init__.py,sha256=pKtrXU-VRct109vbaZQ0DAvZOVVUyX9Ty63Xl1nsAy4,23
+cipher_crypter/cli.py,sha256=a8wXqeQccJC-h-MzC72AnXGZF6x4BhNzHOsl8sEt9WE,39988
+cipher_crypter-3.0.0.dist-info/METADATA,sha256=BapyotD77tFHaOvHG_1x0GfZrjcbPJOhsWlL6DzPz5I,152
+cipher_crypter-3.0.0.dist-info/WHEEL,sha256=51RkbunBAw4BWsgaQWTpPhg4Diwp3c9P5iaLk67Hdtg,92
+cipher_crypter-3.0.0.dist-info/entry_points.txt,sha256=h5hpTQcTnbPjGiFRybQYVBj09OXYCASbrxQOH_dZxFA,59
+cipher_crypter-3.0.0.dist-info/top_level.txt,sha256=pQNLRrMcL7J1mSOU6UV_RpVzqS7TgeMZySAKK3xTKeY,15
+cipher_crypter-3.0.0.dist-info/RECORD,,

cipher_crypter-3.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.47.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cipher_crypter-3.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cipher-crypter = cipher_crypter.cli:main

cipher_crypter-3.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cipher_crypter