diff options
Diffstat (limited to 'plugins')
| -rw-r--r-- | plugins/Makefile.am | 2 | ||||
| -rw-r--r-- | plugins/pyoida/pyoida.c | 3 | ||||
| -rw-r--r-- | plugins/theseus/Makefile.am | 14 | ||||
| -rw-r--r-- | plugins/theseus/theseus.c | 620 | ||||
| -rw-r--r-- | plugins/theseus/theseus.h | 49 |
5 files changed, 687 insertions, 1 deletions
diff --git a/plugins/Makefile.am b/plugins/Makefile.am index 379beaa..63811b0 100644 --- a/plugins/Makefile.am +++ b/plugins/Makefile.am @@ -1,2 +1,2 @@ -SUBDIRS = pyoida stackvars +SUBDIRS = pyoida stackvars theseus diff --git a/plugins/pyoida/pyoida.c b/plugins/pyoida/pyoida.c index 82f9980..4a79bfd 100644 --- a/plugins/pyoida/pyoida.c +++ b/plugins/pyoida/pyoida.c @@ -95,6 +95,9 @@ bool init_plugin(GObject *ref) add_to_env_var("PYTHONPATH", "/home/ocb/prog/openida/plugins/python", ";"); + return false; + + Py_Initialize(); initpyoida(); 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 */ |