Created a plugin to follow the control.

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@149 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

3 files changed, 683 insertions, 0 deletions

diff --git a/plugins/theseus/Makefile.am b/plugins/theseus/Makefile.am
new file mode 100644
index 0000000..8040bb4
--- /dev/null
+++ b/plugins/theseus/Makefile.am
@@ -0,0 +1,14 @@
+
+lib_LTLIBRARIES = libtheseus.la
+
+libtheseus_la_SOURCES =					\
+	theseus.h theseus.c
+
+libtheseus_la_CFLAGS = $(AM_CFLAGS)
+
+
+INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) -I../../src
+
+AM_CPPFLAGS = 
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
diff --git a/plugins/theseus/theseus.c b/plugins/theseus/theseus.c
new file mode 100644
index 0000000..aec5353
--- /dev/null
+++ b/plugins/theseus/theseus.c
@@ -0,0 +1,620 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * theseus.c - décompilation en fonction du flot d'exécution
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "theseus.h"
+
+
+#include <analysis/exporter.h>
+#include <analysis/line_code.h>
+#include <arch/artificial.h>
+
+
+/* Traite en premier lieu les adresses marquées "impératives". */
+static bool register_white_list(GOpenidaBinary *);
+
+/* Indique si une ligne peut faire l'objet d'un nouveau suivi. */
+static bool can_line_be_followed(const GRenderingLine *);
+
+/* Indique si une ligne a déjà été traitée lors d'un suivi. */
+static bool can_line_be_processed(const GRenderingLine *);
+
+/* Marque une ligne comme ayant été traitée. */
+static void mark_line_as_done(GRenderingLine *, bool);
+
+/* Suit le flot d'exécution à partir d'un point donné. */
+static bool follow_flow_from_line(GOpenidaBinary *, vmpa_t);
+
+/* Désassemble une nouvelle instruction à partir d'une adresse. */
+static GRenderingLine *disassemble_target_address(GOpenidaBinary *, GRenderingLine *, vmpa_t);
+
+/* Insère dans le flux existant les nouvelles lignes crées. */
+static bool insert_new_lines_into_flow(GOpenidaBinary *, GRenderingLine *, GRenderingLine *);
+
+
+
+
+
+/*
+mov	edx, 0x80480fb
+call	[edx]
+mov	edx, 0x80480fb
+add	edx, 0x8
+call	[edx]
+mov	edx, 0x80480fb
+add	edx, 0x10
+call	[edx]
+mov	edx, 0x80480fb
+add	edx, 0xc
+call	[edx]
+mov	edx, 0x80480fb
+add	edx, 0x14
+call	[edx]
+mov	edx, 0x80480fb
+add	edx, 0x4
+call	[edx]
+*/
+
+
+static const vmpa_t _white_list[] = {
+    0x80480fbull,
+    0x8048103ull,
+    0x804810bull,
+    0x8048107ull,
+    0x804810full,
+    0x80480ffull
+};
+
+static const size_t _white_list_count = 6;
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ref = espace de référencement global.                        *
+*                                                                             *
+*  Description : Initialise le greffon pour les bornes de routine.            *
+*                                                                             *
+*  Retour      : true.                                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+G_MODULE_EXPORT bool init_plugin(GObject *ref)
+{
+    return true;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Fournit une indication sur le type d'opération(s) menée(s).  *
+*                                                                             *
+*  Retour      : Description d'une action.                                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+G_MODULE_EXPORT PluginAction get_plugin_action(void)
+{
+    return PGA_CODE_PROCESS;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = représentation binaire à traiter.                   *
+*                action = action attendue.                                    *
+*                                                                             *
+*  Description : Exécute une action définie sur un binaire chargé.            *
+*                                                                             *
+*  Retour      : true si une action a été menée, false sinon.                 *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+G_MODULE_EXPORT bool execute_action_on_binary(GOpenidaBinary *binary, PluginAction action)
+{
+    bool result;                            /* Bilan à retourner           */
+    GRenderingLine *lines;                  /* Lignes désassemblées        */
+    GExeFormat *format;                     /* Format du binaire traité    */
+    vmpa_t start;                           /* Point de départ de l'action */
+
+
+
+    GRenderingOptions *options;
+    GRenderingLine *iter;
+
+
+    lines = g_openida_binary_get_lines(binary);
+
+
+
+
+    format = g_openida_binary_get_format(binary);
+
+    start = g_exe_format_get_entry_point(format);
+
+    result = register_white_list(binary);
+
+    result &= follow_flow_from_line(binary, start);
+
+
+    //follow_flow_from_line(binary, 0x0804810bull);
+
+
+
+
+
+    options = g_openida_binary_get_options(binary);
+
+    for (iter = lines; iter != NULL; iter = g_rendering_line_get_next_iter(lines, iter, NULL))
+    {
+
+        printf(" >>>>>> %c%c  ",
+               g_object_get_data(G_OBJECT(iter), "theseus_white") != NULL ? '!' : ' ',
+               g_object_get_data(G_OBJECT(iter), "theseus_done") != NULL ? '*' : ' ');
+        g_content_exporter_add_text(G_CONTENT_EXPORTER(iter), options, 0/*MRD_BLOCK*/, stdout);
+        fflush(stdout);
+        printf("\n");
+
+
+    }
+
+
+
+    //exit(-1);
+
+
+
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = représentation binaire à traiter.                   *
+*                                                                             *
+*  Description : Traite en premier lieu les adresses marquées "impératives".  *
+*                                                                             *
+*  Retour      : true si le déroulement s'est bien effectué, false sinon.     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool register_white_list(GOpenidaBinary *binary)
+{
+    bool result;                            /* Bilan à retourner           */
+    GRenderingLine *lines;                  /* Lignes désassemblées        */
+    size_t i;                               /* Boucle de parcours          */
+    GRenderingLine *target;                 /* Ligne à transformer ?       */
+    GRenderingLine *last;                   /* Nouvelle ligne principale   */
+    GRenderingLine *new;                    /* Nouvelles lignes de rendu   */
+
+    result = true;
+
+    lines = g_openida_binary_get_lines(binary);
+
+    for (i = 0; i < _white_list_count && result; i++)
+    {
+        target = g_rendering_line_find_by_address(lines, NULL, _white_list[i]);
+        target = g_rendering_line_loop_for_code(target, NULL);
+
+        new = disassemble_target_address(binary, target, _white_list[i]);
+
+        last = g_rendering_line_get_last_iter(new, NULL);
+        mark_line_as_done(last, true);
+
+        result = insert_new_lines_into_flow(binary, target, new);
+
+        result &= follow_flow_from_line(binary, _white_list[i]);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = ligne de rendu à analyser.                            *
+*                                                                             *
+*  Description : Indique si une ligne peut faire l'objet d'un nouveau suivi.  *
+*                                                                             *
+*  Retour      : true si le suivi peut continuer, false sinon.                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool can_line_be_followed(const GRenderingLine *line)
+{
+    bool result;                            /* Bilan d'analyse à renvoyer  */
+
+    result = true;
+
+    if (g_object_get_data(G_OBJECT(line), "theseus_done") != NULL)
+        result = (g_object_get_data(G_OBJECT(line), "theseus_white") != NULL);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line = ligne de rendu à analyser.                            *
+*                                                                             *
+*  Description : Indique si une ligne a déjà été traitée lors d'un suivi.     *
+*                                                                             *
+*  Retour      : true si le suivi peut continuer, false sinon.                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool can_line_be_processed(const GRenderingLine *line)
+{
+    return (g_object_get_data(G_OBJECT(line), "theseus_done") == NULL);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : line  = ligne de rendu à traiter.                            *
+*                white = type de marquage à apposer (liste blanche ou normal).*
+*                                                                             *
+*  Description : Marque une ligne comme ayant été traitée.                    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void mark_line_as_done(GRenderingLine *line, bool white)
+{
+    if (white)
+        g_object_set_data(G_OBJECT(line), "theseus_white", line);
+    else
+        g_object_set_data(G_OBJECT(line), "theseus_done", line);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = représentation binaire à traiter.                   *
+*                start  = point de départ de la procédure.                    *
+*                                                                             *
+*  Description : Suit le flot d'exécution à partir d'un point donné.          *
+*                                                                             *
+*  Retour      : true si le déroulement s'est bien effectué, false sinon.     *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool follow_flow_from_line(GOpenidaBinary *binary, vmpa_t start)
+{
+    bool result;                            /* Bilan de opérations         */
+    GRenderingLine *lines;                  /* Lignes désassemblées        */
+    GRenderingLine *first;                  /* Première ligne à traiter    */
+    vmpa_t addr;                            /* Adresse référencée          */
+    GRenderingLine *new;                    /* Nouvelles lignes de rendu   */
+    GRenderingLine *iter;                   /* Boucle de parcours          */
+    GArchInstruction *instr;                /* Instruction à ausculter     */
+    InstructionLinkType type;               /* Type de référence           */
+    GRenderingLine *target;                 /* Ligne visée par la référence*/
+
+    lines = g_openida_binary_get_lines(binary);
+
+    first = g_rendering_line_find_by_address(lines, NULL, start);
+    first = g_rendering_line_loop_for_code(first, NULL);
+
+    if (!can_line_be_followed(first))
+        return true;
+
+    //if (start != 0x0804810bull) return true;
+
+    printf("###################################### Passage\n");
+
+    /* Alignement sur le point d'entrée */
+
+    result = true;
+
+    addr = get_rendering_line_address(first);
+
+    if (addr < start)
+    {
+        new = disassemble_target_address(binary, first, start);
+
+        result = insert_new_lines_into_flow(binary, target, new);
+
+        first = g_rendering_line_find_by_address(lines, NULL, start);
+
+        //return true;
+
+    }
+    else g_object_set_data(G_OBJECT(first), "theseus_done", binary);
+
+
+
+
+    printf("Analyse :: 0x%016llx\n", get_rendering_line_address(first));
+
+
+
+
+
+    /* Poursuite du suivi du flot... */
+
+    for (iter = g_rendering_line_get_next_iter(lines, first, NULL);
+         iter != NULL/* && result*/;
+         iter = g_rendering_line_get_next_iter(lines, iter, NULL))
+    {
+        /* On ne traite que du code ici ! */
+        if (!G_IS_CODE_LINE(iter)) continue;
+
+        /*
+        printf("testing... 0x%08llx => %d\n",
+               get_rendering_line_address(iter),
+               can_line_be_processed(iter));
+        */
+
+        if (!can_line_be_processed(iter))
+            break;
+
+        instr = g_code_line_get_instruction(G_CODE_LINE(iter));
+
+        /* Si le code n'es pas désassemblé ! */
+        if (G_IS_DB_INSTRUCTION(instr))
+        {
+            new = disassemble_target_address(binary, iter, get_rendering_line_address(iter));
+            result = insert_new_lines_into_flow(binary, iter, new);
+
+            if (!result)
+            {
+                mark_line_as_done(iter, false);
+                break;
+            }
+            else
+            {
+                iter = new;
+                mark_line_as_done(iter, false);
+
+                instr = g_code_line_get_instruction(G_CODE_LINE(iter));
+                if (!G_IS_DB_INSTRUCTION(instr)) break;
+
+            }
+
+        }
+        else mark_line_as_done(iter, false);
+
+        type = g_arch_instruction_get_link(instr, &addr);
+
+        if (get_rendering_line_address(iter) ==  0x0804811aull)
+            printf(" == got it !! ==\n");
+
+
+        switch (type)
+        {
+            case ILT_JUMP:
+            case ILT_JUMP_IF_FALSE:
+            case ILT_JUMP_IF_TRUE:
+                result = follow_flow_from_line(binary, addr);
+                break;
+
+           default:
+               break;
+
+        }
+
+        if (get_rendering_line_address(iter) ==  0x0804811aull)
+            printf(" == continue ? %d\n", result);
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = représentation binaire à traiter.                   *
+*                old    = ligne contenant l'adresse visée à remplacer.        *
+*                target = adresse de la nouvelle instruction à voir.          *
+*                                                                             *
+*  Description : Désassemble une nouvelle instruction à partir d'une adresse. *
+*                                                                             *
+*  Retour      : Nouvelle(s) ligne(s) en place ou NULL en cas d'échec.        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static GRenderingLine *disassemble_target_address(GOpenidaBinary *binary, GRenderingLine *old, vmpa_t target)
+{
+    GRenderingLine *result;                 /* Lignes en place à renvoyer  */
+    GExeFormat *format;                     /* Format du binaire fourni    */
+    GArchProcessor *proc;                   /* Architecture du binaire     */
+    GRenderingOptions *options;             /* Options de désassemblage    */
+    bin_t *data;                            /* Données binaires chargées   */
+    off_t length;                           /* Taille du code binaire      */
+    vmpa_t old_addr;                        /* Adresse de ligne à casser   */
+    off_t offset;                           /* Position dans le contenu    */
+    vmpa_t i;                               /* Boucle de parcours          */
+    GArchInstruction *instr;                /* Instruction décodée         */
+    GRenderingLine *line;                   /* Nouvelle ligne de rendu     */
+
+    result = NULL;
+
+    format = g_openida_binary_get_format(binary);
+    proc = get_arch_processor_from_format(format);
+    options = g_openida_binary_get_options(binary);
+
+    data = g_openida_binary_get_data(binary, &length);
+
+    old_addr = get_rendering_line_address(old);
+    if (!g_exe_format_translate_address_into_offset(format, old_addr, &offset))
+        return NULL;
+
+    /* Si on doit laisser sur le carreau quelques octets perdus... */
+    for (i = 0; i < (target - old_addr); i++)
+    {
+        instr = g_db_instruction_new_from_data(data, &offset, length, 0/*base*/, proc);
+        g_arch_instruction_set_location(instr, 0/*base*/ + offset - 1, 1, old_addr + i);
+
+        line = g_code_line_new(old_addr + i, instr, options);
+        g_rendering_line_add_to_lines(&result, line);
+
+    }
+
+    /* Décodage des instructions */
+
+    instr = g_arch_processor_decode_instruction(proc, data,
+                                                &offset, length, 0/*offset*/, target);
+
+    line = g_code_line_new(target, instr, options);
+    g_rendering_line_add_to_lines(&result, line);
+
+    mark_line_as_done(line, false);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary = représentation binaire à traiter.                   *
+*                old    = ancienne ligne, point de départ des remplacements.  *
+*                new    = nouvelle(s) ligne(s) de représentation.             *
+*                                                                             *
+*  Description : Insère dans le flux existant les nouvelles lignes crées.     *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool insert_new_lines_into_flow(GOpenidaBinary *binary, GRenderingLine *old, GRenderingLine *new)
+{
+    bool result;                            /* Bilan de opérations         */
+    GExeFormat *format;                     /* Format du binaire fourni    */
+    GArchProcessor *proc;                   /* Architecture du binaire     */
+    GRenderingOptions *options;             /* Options de désassemblage    */
+    bin_t *data;                            /* Données binaires chargées   */
+    off_t length;                           /* Taille du code binaire      */
+    GRenderingLine **root;                  /* Racine des lignes de rendu  */
+    GRenderingLine *iter;                   /* Boucle de parcours          */
+    vmpa_t start;                           /* Adresse de début du bloc    */
+    vmpa_t end;                             /* Adresse de fin du bloc      */
+    vmpa_t max;                             /* Adresse de fin de ligne     */
+    vmpa_t i;                               /* Boucle de parcours          */
+    off_t offset;                           /* Position dans le contenu    */
+    GArchInstruction *instr;                /* Instruction décodée         */
+    GRenderingLine *line;                   /* Nouvelle ligne de rendu     */
+    GRenderingLine *last;                   /* Dernière ligne à vérifier   */
+
+    format = g_openida_binary_get_format(binary);
+    proc = get_arch_processor_from_format(format);
+    options = g_openida_binary_get_options(binary);
+
+    data = g_openida_binary_get_data(binary, &length);
+
+    /* Etendue du bloc de remplacement */
+
+    iter = g_rendering_line_get_last_iter(new, NULL);
+
+    start = get_rendering_line_address(new);
+
+    end = get_rendering_line_address(iter);
+    end += get_rendering_line_length(iter) - 1;
+
+    /* Bourrage nécessaire ? */
+
+    root = g_openida_binary_get_lines_root(binary);
+
+    iter = g_rendering_line_find_by_address(*root, NULL, end);
+
+    max = get_rendering_line_address(iter);
+    max += get_rendering_line_length(iter);
+
+    for (i = end + 1; i < max; i++)
+    {
+        if (!g_exe_format_translate_address_into_offset(format, i, &offset))
+            /**
+             * Comme les adresses proviennent à l'origine de partie valide,
+             * on considère que l'appel est toujours un succès.
+             * Cela permet d'avoir deux bilan possible : procédure bien déroulée,
+             * ou bien remplacement impossible pour cause de place déjà prise.
+             */
+            /*return false*/;
+
+        instr = g_db_instruction_new_from_data(data, &offset, length, 0/*base*/, proc);
+        g_arch_instruction_set_location(instr, 0/*base*/ + offset - 1, 1, i);
+
+        line = g_code_line_new(i, instr, options);
+        g_rendering_line_add_to_lines(&new, line);
+
+    }
+
+    /* S'assure qu'on ne touche à rien de sacré */
+
+    result = true;
+
+    last = g_rendering_line_find_by_address(*root, NULL, end);
+
+    for (iter = g_rendering_line_find_by_address(*root, NULL, start);
+         iter != NULL && result;
+         iter = g_rendering_line_get_next_iter(*root, iter, last))
+    {
+        result = can_line_be_processed(iter);
+    }
+
+    /* Remplacement en bonne et due forme */
+
+    if (result)
+    {
+        g_rendering_line_remove_range(root, start, end);
+        g_rendering_line_insert_lines(root, &new);
+    }
+
+    return result;
+
+}
diff --git a/plugins/theseus/theseus.h b/plugins/theseus/theseus.h
new file mode 100644
index 0000000..2fa4ac1
--- /dev/null
+++ b/plugins/theseus/theseus.h
@@ -0,0 +1,49 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * theseus.h - prototypes pour la décompilation en fonction du flot d'exécution
+ *
+ * Copyright (C) 2010 Cyrille Bagard
+ *
+ *  This file is part of OpenIDA.
+ *
+ *  OpenIDA is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  OpenIDA is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _PLUGINS_THESEUS_THESEUS_H
+#define _PLUGINS_THESEUS_THESEUS_H
+
+
+#include <glib-object.h>
+#include <gmodule.h>
+#include <stdbool.h>
+
+
+#include <analysis/binary.h>
+#include <plugins/plugin-def.h>
+
+
+
+/* Initialise le greffon pour les bornes de routine. */
+G_MODULE_EXPORT bool init_plugin(GObject *);
+
+/* Fournit une indication sur le type d'opération(s) menée(s). */
+G_MODULE_EXPORT PluginAction get_plugin_action(void);
+
+/* Exécute une action définie sur un binaire chargé. */
+G_MODULE_EXPORT bool execute_action_on_binary(GOpenidaBinary *, PluginAction);
+
+
+
+#endif  /* _PLUGINS_THESEUS_THESEUS_H */