Frida et DynamoRIO : Instrumentation Binaire

L'instrumentation binaire dynamique (DBI) est une technique fondamentale en rétro-ingénierie et en sécurité offensive qui permet d'observer et de modifier le comportement d'un programme en cours d'exécution, sans accès au code source et sans recompilation. Les deux frameworks dominants — Frida et DynamoRIO — offrent des approches complémentaires : Frida privilégie la simplicité avec une API JavaScript/Python injectable dans les processus, tandis que DynamoRIO fournit un contrôle instruction-level avec une instrumentation C/C++ haute performance. Ce guide technique couvre les architectures internes de ces frameworks, leurs API d'instrumentation, les cas d'usage offensifs (hooking de fonctions, bypass de protections, fuzzing guidé, évasion de détection) et défensifs (analyse de malware, reverse engineering de protocoles), avec des exemples de code complets et des techniques avancées comme le stalking, le code replacement et l'anti-anti-debug.

Frida : Architecture et Injection

Frida injecte un agent JavaScript (runtime QuickJS ou V8) dans le processus cible. L'architecture est client-serveur : le script Python/Node.js côté contrôle communique avec l'agent JavaScript injecté dans le processus cible via un canal IPC. Frida supporte Windows, Linux, macOS, iOS, Android et peut instrumenter des processus natifs, Java (Android/JVM), Objective-C (iOS/macOS) et .NET.

#!/usr/bin/env python3
# Frida — Hooking d'une fonction avec interception des arguments
import frida, sys

# Script JavaScript injecté dans le processus cible
jscode = """
Interceptor.attach(Module.getExportByName('libssl.so', 'SSL_write'), {
    onEnter: function(args) {
        // args[0] = SSL* ctx, args[1] = buffer, args[2] = length
        var len = args[2].toInt32();
        var buf = Memory.readByteArray(args[1], Math.min(len, 256));
        console.log('[SSL_write] ' + len + ' bytes:');
        console.log(hexdump(buf, {header: true, ansi: true}));
        
        // Sauvegarder le contexte pour onLeave
        this.buf = args[1];
        this.len = len;
    },
    onLeave: function(retval) {
        console.log('[SSL_write] returned: ' + retval);
    }
});

// Hooking Java sur Android
Java.perform(function() {
    var TrustManager = Java.use('javax.net.ssl.X509TrustManager');
    TrustManager.checkServerTrusted.implementation = function(chain, authType) {
        console.log('[*] SSL Pinning bypassed!');
        // Ne rien faire = accepter tous les certificats
    };
});
"""

# Attacher au processus
session = frida.attach("target_app")
script = session.create_script(jscode)
script.on('message', lambda msg, data: print(msg))
script.load()
sys.stdin.read()

Frida Stalker : Tracing Instruction-Level

Le Stalker de Frida est un traceur d'instructions qui suit l'exécution instruction par instruction. Il utilise la réécriture de code (code rewriting) : chaque basic block est copié, instrumenté avec du code de tracing, et exécuté à la place de l'original. Le Stalker supporte x86, x64, ARM et ARM64 :

// Frida Stalker — tracer toutes les instructions d'un thread
var mainThread = Process.enumerateThreads()[0];

Stalker.follow(mainThread.id, {
    events: {
        call: true,    // Tracer les CALLs
        ret: true,     // Tracer les RETs
        exec: false,   // Ne pas tracer chaque instruction (performance)
        block: true,   // Tracer les basic blocks
    },
    
    onCallSummary: function(summary) {
        // summary = {target_addr: call_count, ...}
        for (var addr in summary) {
            var sym = DebugSymbol.fromAddress(ptr(addr));
            if (sym.name) {
                console.log(sym.name + ' called ' + summary[addr] + ' times');
            }
        }
    },
    
    transform: function(iterator) {
        var instruction;
        while ((instruction = iterator.next()) !== null) {
            // Modifier les instructions à la volée
            if (instruction.mnemonic === 'rdtsc') {
                // Remplacer rdtsc par des valeurs fixes (anti-timing)
                iterator.putCallout(function(context) {
                    context.eax = 0x12345678;
                    context.edx = 0x00000001;
                });
            } else {
                iterator.keep();
            }
        }
    }
});

DynamoRIO : Instrumentation Haute Performance

DynamoRIO est un framework DBI C/C++ développé par Google, optimisé pour la performance. Contrairement à Frida (injection + scripting), DynamoRIO agit comme un process virtual machine : il traduit chaque basic block du programme avant exécution, insérant l'instrumentation dans le flux de code traduit. Cette approche est plus rapide que le hooking de Frida pour l'instrumentation massive.

// DynamoRIO — Client d'instrumentation : compter les basic blocks
#include "dr_api.h"
#include "drmgr.h"

static int bb_count = 0;
static void *count_mutex;

// Callback appelé pour chaque basic block
static dr_emit_flags_t
event_bb(void *drcontext, void *tag, instrlist_t *bb,
         bool for_trace, bool translating) {
    
    instr_t *first = instrlist_first(bb);
    
    // Insérer un appel à notre fonction de comptage
    dr_insert_clean_call(drcontext, bb, first,
                         (void *)increment_count,
                         false /* no fp save */, 0);
    
    return DR_EMIT_DEFAULT;
}

static void increment_count(void) {
    dr_mutex_lock(count_mutex);
    bb_count++;
    dr_mutex_unlock(count_mutex);
}

DR_EXPORT void dr_client_main(client_id_t id, int argc, const char *argv[]) {
    count_mutex = dr_mutex_create();
    drmgr_init();
    drmgr_register_bb_instrumentation_event(NULL, event_bb, NULL);
    dr_log(NULL, LOG_ALL, 1, "BB counter initialized\n");
}

Cas d'Usage Offensifs

• SSL Pinning Bypass : Frida intercepte les fonctions de validation SSL/TLS (iOS: SecTrustEvaluate, Android: checkServerTrusted) pour accepter tous les certificats — essentiel pour le pentest d'applications mobiles
• Anti-tamper/Anti-debug Bypass : hooker les appels système de détection (ptrace, IsDebuggerPresent, timing checks) pour neutraliser les protections des malwares et des applications protégées
• EDR Evasion Research : instrumenter les hooks EDR userland (ntdll.dll) pour comprendre ce qui est surveillé et identifier les gaps de couverture
• Game Hacking / DRM Bypass : modifier la logique des validations de licence et les protections DRM en mémoire
• Protocol Reversing : tracer les entrées/sorties réseau pour reconstruire des protocoles propriétaires

Fuzzing Guidé par Instrumentation

DynamoRIO et Frida sont utilisés comme backends de couverture pour le fuzzing : au lieu de compiler le programme avec la couverture (source-based), le DBI instrumente le binaire à la volée pour collecter la couverture de code. WinAFL utilise DynamoRIO, Frida-fuzzer utilise le Stalker de Frida. L'avantage : fuzzer des binaires closed-source sans accès au code source ni recompilation.

Frida vs DynamoRIO : Choix du Framework

FAQ — Questions Fréquentes