Obfuscation AST avancée
CFG flattening, inlining, string splitting

Limites de l'obfuscation basique

Renommer les variables et les fonctions est la forme d'obfuscation la plus simple — et la plus contournée. Un décompilateur moderne comme pycdc ou decompile3 restaure du code lisible en quelques secondes. Pour ralentir sérieusement le reverse engineering, il faut agir sur la structure du code, pas seulement sur les noms.

L'objectif de l'obfuscation avancée n'est pas de rendre le code illisible — c'est de le rendre incompréhensible. Un attaquant peut lire chaque instruction et ne pas comprendre ce que le programme fait globalement.

CFG Flattening — Aplatissement du graphe de contrôle

Le CFG flattening transforme une structure de contrôle naturelle (if/else, boucles) en une machine à états pilotée par une variable de dispatch. Le flux logique devient opaque même pour un analyste expérimenté :

# Code original
def calcul(x):
    if x > 0:
        y = x * 2
    else:
        y = x - 1
    return y + 10

# Après CFG flattening
def calcul(x):
    _s, _r = 0, None
    while True:
        if _s == 0:
            _s = 1 if x > 0 else 2
        elif _s == 1:
            _x0a3f = x * 2; _s = 3
        elif _s == 2:
            _x0a3f = x - 1; _s = 3
        elif _s == 3:
            _r = _x0a3f + 10; break
    return _r

Inlining de constantes

Remplacer les constantes par des expressions calculées qui produisent le même résultat à l'exécution :

import ast, random

class ConstantInliner(ast.NodeTransformer):
    def visit_Constant(self, node):
        if isinstance(node.value, int) and -1000 < node.value < 1000:
            k = random.randint(1, 999)
            v = node.value
            # Remplace 42 par (42 + k - k)
            return ast.BinOp(
                left=ast.BinOp(
                    left=ast.Constant(value=v + k),
                    op=ast.Sub(),
                    right=ast.Constant(value=k)
                ),
                op=ast.Add(),
                right=ast.Constant(value=0)
            )
        return node

String splitting

Les chaînes de caractères sensibles (URLs, clés, chemins) sont découpées en fragments et reconstituées à l'exécution :

# Original
url = "https://licences.monapp.fr/activate"

# Après string splitting
_p0 = "htt"; _p1 = "ps://"; _p2 = "licences."
_p3 = "monapp"; _p4 = ".fr"; _p5 = "/activate"
url = _p0 + _p1 + _p2 + _p3 + _p4 + _p5

# Ou via XOR encoding
_enc = [0x68^0x42, 0x74^0x42, 0x74^0x42]  # ...
url = "".join(chr(c ^ 0x42) for c in _enc)

Prédicats opaques

Un prédicat opaque est une condition toujours vraie (ou toujours fausse) mais difficile à prouver statiquement pour un analyseur :

# Toujours vrai : n*(n+1) est toujours pair
def _op(n): return (n * (n + 1)) % 2 == 0

if _op(random.randint(1, 9999)):  # toujours True
    # code réel
    do_real_work()
else:
    # code mort jamais exécuté, mais analysé par le reverse engineer
    send_to_server(fake_key)

Faux blocs de code

Insérer du code mort qui ressemble à du code réel (fausses vérifications de licence, fausses requêtes réseau) noie les vrais mécanismes de protection dans du bruit :

# Faux check de licence (jamais exécuté)
if _op_always_false():
    _fake_hw = "DEADBEEF-0000-0000-0000-000000000000"
    _fake_sig = verify_signature(_fake_hw, b"")
    if _fake_sig:
        activate_premium_mode()
# L'attaquant perd du temps à analyser ce chemin

Combiner les techniques

L'efficacité maximale vient de la combinaison : CFG flattening + string splitting + prédicats opaques + faux blocs. IronLock v2 applique ces transformations automatiquement lors du packaging avec --obfuscation-level high :

ironlock encrypt app.py   --obfuscation-level high   --cfg-flatten   --string-split   --opaque-predicates   --dead-code-injection   --output dist/

Conclusion

L'obfuscation AST avancée transforme un code compréhensible en un labyrinthe — sans changer son comportement. Combinée au chiffrement AES-256-GCM et à l'anti-debug, elle rend l'analyse statique et dynamique simultanément difficile. Chaque couche supplémentaire multiplie le temps nécessaire à un attaquant pour comprendre la logique métier.