metadidomi-builder 1.4.171125 → 1.4.201125

package/build_tools_py/pyMetadidomi/pyMetadidomi.py

@@ -1,18 +1,1678 @@
-# --- Loader natif par pyMetadidomi (pymloader) ---
-import base64, zlib, marshal
+# === 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
 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:
-    import pymloader
-    payload = base64.b64decode("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")
-    key = base64.b64decode("BEbICjtlnM+beGm1TrFepYBavzAvnA8BVBt+vaUGHq8=")
-    iv = base64.b64decode("B6PCXnH5JQLNxIHNCtNOOA==")
-    def unpad(data):
-        return data[:-data[-1]]
+    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
     cipher = AES.new(key, AES.MODE_CBC, iv)
-    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)
+    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()