diff options
Diffstat (limited to 'src/analysis')
| -rwxr-xr-x | src/analysis/Makefile.am | 3 | ||||
| -rwxr-xr-x | src/analysis/binaries/Makefile.am | 18 | ||||
| -rw-r--r-- | src/analysis/binaries/file.c | 328 | ||||
| -rw-r--r-- | src/analysis/binaries/file.h | 61 | ||||
| -rw-r--r-- | src/analysis/binary-int.h | 84 | ||||
| -rw-r--r-- | src/analysis/binary.c | 728 | ||||
| -rw-r--r-- | src/analysis/binary.h | 74 | ||||
| -rw-r--r-- | src/analysis/decomp/decompiler.c | 10 | ||||
| -rw-r--r-- | src/analysis/decomp/decompiler.h | 2 | ||||
| -rw-r--r-- | src/analysis/disass/disassembler.c | 14 | ||||
| -rw-r--r-- | src/analysis/disass/disassembler.h | 2 | ||||
| -rw-r--r-- | src/analysis/disass/fetch.c | 6 | ||||
| -rw-r--r-- | src/analysis/disass/fetch.h | 2 |
13 files changed, 689 insertions, 643 deletions
diff --git a/src/analysis/Makefile.am b/src/analysis/Makefile.am index e59b648..b5b345f 100755 --- a/src/analysis/Makefile.am +++ b/src/analysis/Makefile.am @@ -16,6 +16,7 @@ libanalysis_la_SOURCES = \ variable.h variable.c libanalysis_la_LIBADD = \ + binaries/libanalysisbinaries.la \ decomp/libanalysisdecomp.la \ disass/libanalysisdisass.la @@ -28,4 +29,4 @@ AM_CPPFLAGS = AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) -SUBDIRS = decomp disass +SUBDIRS = binaries decomp disass diff --git a/src/analysis/binaries/Makefile.am b/src/analysis/binaries/Makefile.am new file mode 100755 index 0000000..f065070 --- /dev/null +++ b/src/analysis/binaries/Makefile.am @@ -0,0 +1,18 @@ + +noinst_LTLIBRARIES = libanalysisbinaries.la + +libanalysisbinaries_la_SOURCES = \ + file.h file.c + +libanalysisbinaries_la_LIBADD = + +libanalysisbinaries_la_LDFLAGS = + + +INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) + +AM_CPPFLAGS = + +AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) + +SUBDIRS = diff --git a/src/analysis/binaries/file.c b/src/analysis/binaries/file.c new file mode 100644 index 0000000..0be1fd7 --- /dev/null +++ b/src/analysis/binaries/file.c @@ -0,0 +1,328 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * file.h - prototypes pour la prise en charge des binaires sous forme de fichier + * + * Copyright (C) 2012 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 "file.h" + + +#include <string.h> + + +#include "../binary-int.h" +#include "../../common/extstr.h" +#include "../../gui/panels/log.h" + + + +/* Description de fichier binaire (instance) */ +struct _GFileBinary +{ + GLoadedBinary parent; /* A laisser en premier */ + + char *filename; /* Fichier chargé en mémoire */ + +}; + +/* Description de fichier binaire (classe) */ +struct _GFileBinaryClass +{ + GLoadedBinaryClass parent; /* A laisser en premier */ + +}; + + +/* Initialise la classe des descriptions de fichier binaire. */ +static void g_file_binary_class_init(GFileBinaryClass *); + +/* Initialise une description de fichier binaire. */ +static void g_file_binary_init(GFileBinary *); + +/* Procède à la libération totale de la mémoire. */ +static void g_file_binary_finalize(GFileBinary *); + +/* Ecrit une sauvegarde du binaire dans un fichier XML. */ +static bool g_file_binary_save(const GFileBinary *, xmlDocPtr, xmlXPathContextPtr, const char *); + +/* Fournit le fichier correspondant à l'élément binaire. */ +static const char *g_file_binary_get_filename(const GFileBinary *, bool); + + + +/* Indique le type défini pour une description de fichier binaire. */ +G_DEFINE_TYPE(GFileBinary, g_file_binary, G_TYPE_LOADED_BINARY); + + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des descriptions de fichier binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_file_binary_class_init(GFileBinaryClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + + object = G_OBJECT_CLASS(klass); + + object->finalize = (GObjectFinalizeFunc)g_file_binary_finalize; + +} + + +/****************************************************************************** +* * +* Paramètres : binary = instance à initialiser. * +* * +* Description : Initialise une description de fichier binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_file_binary_init(GFileBinary *binary) +{ + GLoadedBinary *loaded; /* Version parente */ + + loaded = G_LOADED_BINARY(binary); + + loaded->save = (save_binary_fc)g_file_binary_save; + loaded->get_filename = (get_binary_filename_fc)g_file_binary_get_filename; + +} + + +/****************************************************************************** +* * +* Paramètres : binary = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_file_binary_finalize(GFileBinary *binary) +{ + gpointer obj_class; /* Classe parente */ + + free(binary->filename); + + /* On passe le relai */ + + obj_class = g_type_class_peek_parent(G_FILE_BINARY_GET_CLASS(binary)); + + G_OBJECT_CLASS(obj_class)->finalize(G_OBJECT(binary)); + +} + + +/****************************************************************************** +* * +* Paramètres : filename = nom du fichier à charger. * +* * +* Description : Charge en mémoire le contenu d'un fichier. * +* * +* Retour : Adresse de la représentation ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GLoadedBinary *g_file_binary_new_from_file(const char *filename) +{ + GFileBinary *result; /* Adresse à retourner */ + GLoadedBinary *loaded; /* Version parente */ + char *tmp; /* Nom de fichier modifiable */ + + result = g_object_new(G_TYPE_FILE_BINARY, NULL); + loaded = G_LOADED_BINARY(result); + + log_variadic_message(LMT_PROCESS, _("Opening '%s' file..."), filename); + + result->filename = strdup(filename); + + tmp = strdup(filename); + loaded->format = G_EXE_FORMAT(load_new_format(FMT_EXEC, tmp, + &loaded->bin_data, &loaded->bin_length)); + free(tmp); + + if (loaded->format == NULL) + { + log_simple_message(LMT_INFO, _("Unknown binary format")); + goto lbf_error; + } + + switch (g_exe_format_get_target_machine(loaded->format)) + { + case FTM_ARM: + log_simple_message(LMT_INFO, _("Detected architecture: ARM")); + break; + case FTM_DALVIK: + log_simple_message(LMT_INFO, _("Detected architecture: Dalvik Virtual Machine")); + break; + case FTM_JVM: + log_simple_message(LMT_INFO, _("Detected architecture: Java Virtual Machine")); + break; + case FTM_MIPS: + log_simple_message(LMT_INFO, _("Detected architecture: Microprocessor without Interlocked Pipeline Stages")); + break; + case FTM_386: + log_simple_message(LMT_INFO, _("Detected architecture: i386")); + break; + default: + log_simple_message(LMT_INFO, _("Unknown architecture")); + goto lbf_error; + break; + } + + loaded->proc = get_arch_processor_from_format(loaded->format); + + return G_LOADED_BINARY(result); + + lbf_error: + + g_object_unref(G_OBJECT(result)); + + return NULL; + +} + + +/****************************************************************************** +* * +* Paramètres : context = contexte pour les recherches XPath. * +* path = chemin d'accès au noeud XML à lire. * +* * +* Description : Charge en mémoire le contenu d'un fichier à partir d'XML. * +* * +* Retour : Adresse de la représentation ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GLoadedBinary *g_file_binary_new_from_xml(xmlXPathContextPtr context, const char *path) +{ + GLoadedBinary *result; /* Adresse à retourner */ + char *access; /* Chemin pour une sous-config.*/ + char *filename; /* Chemin du binaire à charger */ + + result = NULL; + + /* Chemin du fichier à retrouver */ + + access = strdup(path); + access = stradd(access, "/Filename"); + + filename = get_node_text_value(context, access); + + free(access); + + /* Chargement */ + + if (filename != NULL) + { + result = g_file_binary_new_from_file(filename); + free(filename); + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : binary = élément binaire à traiter. * +* xdoc = structure XML en cours d'édition. * +* context = contexte à utiliser pour les recherches. * +* path = chemin d'accès réservé au binaire. * +* * +* Description : Ecrit une sauvegarde du binaire dans un fichier XML. * +* * +* Retour : true si l'opération a bien tourné, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_file_binary_save(const GFileBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path) +{ + bool result; /* Bilan à faire remonter */ + char *access; /* Chemin d'accès à un élément */ + + result = true; + + /* Type */ + + result &= add_string_attribute_to_node(xdoc, context, path, "type", "file"); + + /* Nom du fichier associé */ + + access = strdup(path); + access = stradd(access, "/Filename"); + + result &= add_content_to_node(xdoc, context, access, binary->filename); + + free(access); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : binary = élément binaire à consulter. * +* full = précise s'il s'agit d'une version longue ou non. * +* * +* Description : Fournit le fichier correspondant à l'élément binaire. * +* * +* Retour : Nom de fichier avec chemin absolu. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static const char *g_file_binary_get_filename(const GFileBinary *binary, bool full) +{ + const char *result; /* Description à retourner */ + + if (full) + result = binary->filename; + else + result = strrchr(binary->filename, G_DIR_SEPARATOR) + 1; + + return result; + +} diff --git a/src/analysis/binaries/file.h b/src/analysis/binaries/file.h new file mode 100644 index 0000000..3bff0a2 --- /dev/null +++ b/src/analysis/binaries/file.h @@ -0,0 +1,61 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * file.h - prototypes pour la prise en charge des binaires sous forme de fichier + * + * Copyright (C) 2012 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 _ANALYSIS_BINARIES_FILE_H +#define _ANALYSIS_BINARIES_FILE_H + + +#include <glib-object.h> + + +#include "../binary.h" +#include "../../common/xml.h" + + + +#define G_TYPE_FILE_BINARY g_file_binary_get_type() +#define G_FILE_BINARY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_file_binary_get_type(), GFileBinary)) +#define G_IS_FILE_BINARY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_file_binary_get_type())) +#define G_FILE_BINARY_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_file_binary_get_type(), GFileBinaryIface)) +#define G_FILE_BINARY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_FILE_BINARY, GFileBinaryClass)) + + +/* Description de fichier binaire (instance) */ +typedef struct _GFileBinary GFileBinary; + +/* Description de fichier binaire (classe) */ +typedef struct _GFileBinaryClass GFileBinaryClass; + + +/* Indique le type défini pour une description de fichier binaire. */ +GType g_file_binary_get_type(void); + +/* Charge en mémoire le contenu d'un fichier. */ +GLoadedBinary *g_file_binary_new_from_file(const char *); + +/* Charge en mémoire le contenu d'un fichier à partir d'XML. */ +GLoadedBinary *g_file_binary_new_from_xml(xmlXPathContextPtr, const char *); + + + +#endif /* _ANALYSIS_BINARIES_FILE_H */ diff --git a/src/analysis/binary-int.h b/src/analysis/binary-int.h new file mode 100644 index 0000000..c9be0bf --- /dev/null +++ b/src/analysis/binary-int.h @@ -0,0 +1,84 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * binary-int.h - prototypes pour la définition interne des binaires + * + * Copyright (C) 2012 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 _ANALYSIS_BINARY_INT_H +#define _ANALYSIS_BINARY_INT_H + + +#include "binary.h" + + +#include "../format/format.h" + + + +/* Ecrit une sauvegarde du binaire dans un fichier XML. */ +typedef bool (* save_binary_fc) (const GLoadedBinary *, xmlDocPtr, xmlXPathContextPtr, const char *); + +/* Fournit le fichier correspondant à l'élément binaire. */ +typedef const char * (* get_binary_filename_fc) (const GLoadedBinary *, bool); + + +/* Description de fichier binaire (instance) */ +struct _GLoadedBinary +{ + GObject parent; /* A laisser en premier */ + + save_binary_fc save; /* Sauvegarde au format XML */ + get_binary_filename_fc get_filename; /* Obtention d'une description */ + + off_t bin_length; /* Taille des données brutes */ + bin_t *bin_data; /* Données binaires brutes */ + + GExeFormat *format; /* Format du binaire */ + GArchProcessor *proc; /* Architecture du binaire */ + + BinaryPartModel model; /* Modèle de sélection */ + GBinPart **parts[BPM_COUNT]; /* Parties binaires à analyser */ + size_t parts_count[BPM_COUNT]; /* Quantité de ces parties */ + + GArchInstruction *instrs; /* Instructions d'assemblage */ + GCodeBuffer *disass_buffer; /* Instructions lisibles */ + GCodeBuffer **dec_buffers; /* Sources sous forme de texte */ + size_t decbuf_count; /* Taille des tableaux */ + size_t defsrc; /* Fichier source principal */ + + bool text_display[2]; /* Position et code binaire #1 */ + bool lines_display; /* Affichage des lignes */ + +}; + +/* Description de fichier binaire (classe) */ +struct _GLoadedBinaryClass +{ + GObjectClass parent; /* A laisser en premier */ + + /* Signaux */ + + void (* disassembly_done) (GLoadedBinary *); + +}; + + + +#endif /* _ANALYSIS_BINARY_INT_H */ diff --git a/src/analysis/binary.c b/src/analysis/binary.c index 73070b1..fe8188b 100644 --- a/src/analysis/binary.c +++ b/src/analysis/binary.c @@ -24,118 +24,56 @@ #include "binary.h" -#include <fcntl.h> #include <malloc.h> #include <stdio.h> #include <stdlib.h> #include <string.h> -#include <unistd.h> -#include <sys/mman.h> -#include <sys/stat.h> #include <sys/types.h> #include <i18n.h> -#include "line_code.h" /* TODO : supprimer ? */ -#include "line_comment.h" /* TODO : supprimer ? */ -#include "line_prologue.h" +#include "binary-int.h" #include "routine.h" +#include "binaries/file.h" #include "decomp/decompiler.h" #include "disass/disassembler.h" -#include "../common/cpp.h" #include "../common/extstr.h" -#include "../debug/break.h" -#include "../format/format.h" -#include "../gui/panels/log.h" -#include "../plugins/pglist.h" /* TODO : supprimer ? */ - - -#include "../format/dbg_format.h" - - /* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */ -/* Description de fichier binaire (instance) */ -struct _GOpenidaBinary -{ - GObject parent; /* A laisser en premier */ - - char *filename; /* Fichier chargé en mémoire */ - - off_t bin_length; /* Taille des données brutes */ - bin_t *bin_data; /* Données binaires brutes */ - - GExeFormat *format; /* Format du binaire */ - GArchProcessor *proc; /* Architecture du binaire */ - - BinaryPartModel model; /* Modèle de sélection */ - GBinPart **parts[BPM_COUNT]; /* Parties binaires à analyser */ - size_t parts_count[BPM_COUNT]; /* Quantité de ces parties */ - - GRenderingLine *lines; /* Lignes de rendu en place */ - GRenderingOptions *options; /* Options de désassemblage */ - - GArchInstruction *instrs; /* Instructions d'assemblage */ - GCodeBuffer *disass_buffer; /* Instructions lisibles */ - GCodeBuffer **dec_buffers; /* Sources sous forme de texte */ - size_t decbuf_count; /* Taille des tableaux */ - size_t defsrc; /* Fichier source principal */ - - bool text_display[2]; /* Position et code binaire #1 */ - bool lines_display; /* Affichage des lignes */ - - GBreakGroup **brk_groups; /* Groupes de points d'arrêt */ - size_t brk_count; /* Taille de cette liste */ - GBreakGroup *brk_default; /* Groupe par défaut */ - -}; - -/* Description de fichier binaire (classe) */ -struct _GOpenidaBinaryClass -{ - GObjectClass parent; /* A laisser en premier */ - - /* Signaux */ - - void (* disassembly_done) (GOpenidaBinary *); - -}; - /* Initialise la classe des descriptions de fichier binaire. */ -static void g_openida_binary_class_init(GOpenidaBinaryClass *); +static void g_loaded_binary_class_init(GLoadedBinaryClass *); /* Initialise une description de fichier binaire. */ -static void g_openida_binary_init(GOpenidaBinary *); - -/* Charge en mémoire le contenu d'un fichier. */ -bin_t *map_binary_file(const char *, off_t *); - -/* Acquitte la fin d'un désasemblage différé et complet. */ -void ack_completed_disassembly(void/*GDelayedDisassembly*/ *, GOpenidaBinary *); +static void g_loaded_binary_init(GLoadedBinary *); +/* Supprime toutes les références externes. */ +static void g_loaded_binary_dispose(GLoadedBinary *); +/* Procède à la libération totale de la mémoire. */ +static void g_loaded_binary_finalize(GLoadedBinary *); +/* Charge les parties intéressantes du binaire à partir d'XML. */ +static bool g_loaded_binary_load_parts_from_xml(GLoadedBinary *, xmlXPathContextPtr, const char *); +/* Ecrit les parties de valeur du binaire dans un fichier XML. */ +static bool g_loaded_binary_save_parts(const GLoadedBinary *, xmlDocPtr, xmlXPathContextPtr, const char *); -/* ------------------------------ ELEMENTS DE DEBOGAGE ------------------------------ */ +/* Acquitte la fin d'un désasemblage différé et complet. */ +void ack_completed_disassembly(void/*GDelayedDisassembly*/ *, GLoadedBinary *); -/* Réagit à une nouvelle création de point d'arrêt. */ -static void g_openida_binary_breakpoint_added(GBreakGroup *, GBreakPoint *, GOpenidaBinary *); -/* Réagit à une suppression de point d'arrêt. */ -static void g_openida_binary_breakpoint_removed(GBreakGroup *, GBreakPoint *, GOpenidaBinary *); /* Indique le type défini pour une description de fichier binaire. */ -G_DEFINE_TYPE(GOpenidaBinary, g_openida_binary, G_TYPE_OBJECT); +G_DEFINE_TYPE(GLoadedBinary, g_loaded_binary, G_TYPE_OBJECT); /****************************************************************************** @@ -150,12 +88,19 @@ G_DEFINE_TYPE(GOpenidaBinary, g_openida_binary, G_TYPE_OBJECT); * * ******************************************************************************/ -static void g_openida_binary_class_init(GOpenidaBinaryClass *klass) +static void g_loaded_binary_class_init(GLoadedBinaryClass *klass) { + GObjectClass *object; /* Autre version de la classe */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_loaded_binary_dispose; + object->finalize = (GObjectFinalizeFunc)g_loaded_binary_finalize; + g_signal_new("disassembly-done", - G_TYPE_OPENIDA_BINARY, + G_TYPE_LOADED_BINARY, G_SIGNAL_RUN_LAST, - G_STRUCT_OFFSET(GOpenidaBinaryClass, disassembly_done), + G_STRUCT_OFFSET(GLoadedBinaryClass, disassembly_done), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); @@ -175,133 +120,143 @@ static void g_openida_binary_class_init(GOpenidaBinaryClass *klass) * * ******************************************************************************/ -static void g_openida_binary_init(GOpenidaBinary *binary) +static void g_loaded_binary_init(GLoadedBinary *binary) { binary->text_display[0] = true; binary->text_display[1] = true; binary->lines_display = true; - /* FIXME : à replacer ailleurs */ - g_openida_binary_add_break_group(binary, _("default")); - } /****************************************************************************** * * -* Paramètres : filename = nom du fichier à charger. * +* Paramètres : binary = instance d'objet GLib à traiter. * * * -* Description : Charge en mémoire le contenu d'un fichier. * +* Description : Supprime toutes les références externes. * * * -* Retour : Adresse de la représentation ou NULL en cas d'échec. * +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -GOpenidaBinary *g_openida_binary_new_from_file(const char *filename) +static void g_loaded_binary_dispose(GLoadedBinary *binary) { - GOpenidaBinary *result; /* Adresse à retourner */ - GPluginModule **pglist; /* Liste de greffons */ - size_t pgcount; /* Taille de cette liste */ - size_t i; /* Boucle de parcours */ - + gpointer obj_class; /* Classe parente */ - char *file = strdup(filename); + g_object_unref(G_OBJECT(binary->format)); + g_object_unref(G_OBJECT(binary->proc)); - result = g_object_new(G_TYPE_OPENIDA_BINARY, NULL); + /* TODO... */ + /* On passe le relai */ + obj_class = g_type_class_peek_parent(G_FILE_BINARY_GET_CLASS(binary)); + G_OBJECT_CLASS(obj_class)->dispose(G_OBJECT(binary)); - printf("%s\n", filename); +} +/****************************************************************************** +* * +* Paramètres : binary = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ - pglist = get_all_plugins_for_action(PGA_FORMAT_MATCHER, &pgcount); +static void g_loaded_binary_finalize(GLoadedBinary *binary) +{ + gpointer obj_class; /* Classe parente */ - if (pgcount > 0) - { - printf("===>>>> FOUND :: %d\n", pgcount); + /* TODO */ + /* On passe le relai */ - /* - for (i = 0; i < pgcount; i++) - g_plugin_module_execute_action_on_binary(pglist[i], binary, PGA_CODE_PROCESS); - */ - free(pglist); + obj_class = g_type_class_peek_parent(G_FILE_BINARY_GET_CLASS(binary)); - } + G_OBJECT_CLASS(obj_class)->finalize(G_OBJECT(binary)); +} +/****************************************************************************** +* * +* Paramètres : context = contexte pour les recherches XPath. * +* path = chemin d'accès au noeud XML à lire. * +* * +* Description : Charge en mémoire le contenu d'un fichier à partir d'XML. * +* * +* Retour : Adresse de la représentation ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ +GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr context, const char *path) +{ + GLoadedBinary *result; /* Adresse à retourner */ + char *type; /* Tupe de binaire à charger */ + result = NULL; + type = get_node_prop_value(context, path, "type"); + if (strcmp(type, "file") == 0) + result = g_loaded_binary_new_from_xml(context, path); + free(type); - log_variadic_message(LMT_PROCESS, _("Opening '%s' file..."), filename); + if (result == NULL) + return NULL; - result->filename = strdup(filename); + if (!g_loaded_binary_load_parts_from_xml(result, context, path)) + goto glbnfx_error; - /* - result->bin_data = map_binary_file(filename, &result->bin_length); - if (result->bin_data == NULL) goto lbf_error; - */ + return result; - result->format = G_EXE_FORMAT(load_new_format(FMT_EXEC, file, - &result->bin_data, &result->bin_length)); - if (result->format == NULL) - { - log_simple_message(LMT_INFO, _("Unknown binary format")); - goto lbf_error; - } + glbnfx_error: - /* FIXME : à déplacer dans arch/... */ - switch (g_exe_format_get_target_machine(result->format)) - { - case FTM_ARM: - log_simple_message(LMT_INFO, _("Detected architecture: ARM")); - break; - case FTM_DALVIK: - log_simple_message(LMT_INFO, _("Detected architecture: Dalvik Virtual Machine")); - break; - case FTM_JVM: - log_simple_message(LMT_INFO, _("Detected architecture: Java Virtual Machine")); - break; - case FTM_MIPS: - log_simple_message(LMT_INFO, _("Detected architecture: Microprocessor without Interlocked Pipeline Stages")); - break; - case FTM_386: - log_simple_message(LMT_INFO, _("Detected architecture: i386")); - break; - default: - log_simple_message(LMT_INFO, _("Unknown architecture")); - goto lbf_error; - break; - } + g_object_unref(G_OBJECT(result)); - result->lines = NULL; + return NULL; - result->proc = get_arch_processor_from_format(result->format); +} - result->options = g_rendering_options_new(result->format); - g_rendering_options_show_address(result->options, MRD_BLOCK, true); - g_rendering_options_show_code(result->options, MRD_BLOCK, true); +/****************************************************************************** +* * +* Paramètres : binary = élément binaire à traiter. * +* xdoc = structure XML en cours d'édition. * +* context = contexte à utiliser pour les recherches. * +* path = chemin d'accès réservé au binaire. * +* * +* Description : Ecrit une sauvegarde du binaire dans un fichier XML. * +* * +* Retour : true si l'opération a bien tourné, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ - g_rendering_options_show_address(result->options, MRD_GRAPH, true); - g_rendering_options_show_code(result->options, MRD_GRAPH, false); +bool g_loaded_binary_save(const GLoadedBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path) +{ + bool result; /* Bilan à faire remonter */ - return result; + result = binary->save(binary, xdoc, context, path); - lbf_error: + /* Parties à désassembler */ - //unload_binary_file(result); + result = g_loaded_binary_save_parts(binary, xdoc, context, path); - return NULL; + return result; } @@ -311,21 +266,18 @@ GOpenidaBinary *g_openida_binary_new_from_file(const char *filename) * Paramètres : context = contexte pour les recherches XPath. * * path = chemin d'accès au noeud XML à lire. * * * -* Description : Charge en mémoire le contenu d'un fichier à partir d'XML. * +* Description : Charge les parties intéressantes du binaire à partir d'XML. * * * -* Retour : Adresse de la représentation ou NULL en cas d'échec. * +* Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ -GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const char *path) +static bool g_loaded_binary_load_parts_from_xml(GLoadedBinary *binary, xmlXPathContextPtr context, const char *path) { - GOpenidaBinary *result; /* Adresse à retourner */ - char *type; /* Tupe de binaire à charger */ - size_t access_len; /* Taille d'un chemin interne */ + bool result; /* Bilan à retourner */ char *access; /* Chemin pour une sous-config.*/ - char *filename; /* Chemin du binaire à charger */ xmlXPathObjectPtr xobjects; /* Cible d'une recherche */ int i; /* Boucle de parcours */ GBinPart *part; /* Partie binaire à traiter */ @@ -334,33 +286,6 @@ GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const result = NULL; - /* Type */ - - type = get_node_prop_value(context, path, "type"); - - printf("###type### %s\n", type); - - free(type); - - /* Chemin du fichier à retrouver */ - - access = strdup(path); - access = stradd(access, "/Filename"); - - filename = get_node_text_value(context, access); - - free(access); - - /* Chargement */ - - if (filename != NULL) - { - result = g_openida_binary_new_from_file(filename); - free(filename); - } - - if (result == NULL) return NULL; - /* Parties à désassembler : default */ access = strdup(path); @@ -376,29 +301,29 @@ GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const { g_binary_part_get_values(part, &offset, NULL, NULL); - if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(result->format), offset, &addr)) + if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(binary->format), offset, &addr)) { g_object_unref(G_OBJECT(part)); continue; } - result->parts_count[BPM_DEFAULT]++; - result->parts[BPM_DEFAULT] = (GBinPart **)realloc(result->parts[BPM_DEFAULT], - result->parts_count[BPM_DEFAULT] * sizeof(GBinPart *)); + binary->parts_count[BPM_DEFAULT]++; + binary->parts[BPM_DEFAULT] = (GBinPart **)realloc(binary->parts[BPM_DEFAULT], + binary->parts_count[BPM_DEFAULT] * sizeof(GBinPart *)); - result->parts[BPM_DEFAULT][result->parts_count[BPM_DEFAULT] - 1] = part; + binary->parts[BPM_DEFAULT][binary->parts_count[BPM_DEFAULT] - 1] = part; } } - if(xobjects != NULL) /* FIXME */ + if(xobjects != NULL) xmlXPathFreeObject(xobjects); free(access); - qsort(result->parts[BPM_DEFAULT], result->parts_count[BPM_DEFAULT], - sizeof(GBinPart *), g_binary_part_compare); + qsort(binary->parts[BPM_DEFAULT], binary->parts_count[BPM_DEFAULT], + sizeof(GBinPart *), (__compar_fn_t)g_binary_part_compare); /* Parties à désassembler : routines */ @@ -415,30 +340,30 @@ GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const { g_binary_part_get_values(part, &offset, NULL, NULL); - if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(result->format), offset, &addr)) + if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(binary->format), offset, &addr)) { g_object_unref(G_OBJECT(part)); continue; } else g_binary_part_set_address(part, addr); - result->parts_count[BPM_ROUTINES]++; - result->parts[BPM_ROUTINES] = (GBinPart **)realloc(result->parts[BPM_ROUTINES], - result->parts_count[BPM_ROUTINES] * sizeof(GBinPart *)); + binary->parts_count[BPM_ROUTINES]++; + binary->parts[BPM_ROUTINES] = (GBinPart **)realloc(binary->parts[BPM_ROUTINES], + binary->parts_count[BPM_ROUTINES] * sizeof(GBinPart *)); - result->parts[BPM_ROUTINES][result->parts_count[BPM_ROUTINES] - 1] = part; + binary->parts[BPM_ROUTINES][binary->parts_count[BPM_ROUTINES] - 1] = part; } } - if(xobjects != NULL) /* FIXME */ + if(xobjects != NULL) xmlXPathFreeObject(xobjects); free(access); - qsort(result->parts[BPM_ROUTINES], result->parts_count[BPM_ROUTINES], - sizeof(GBinPart *), g_binary_part_compare); + qsort(binary->parts[BPM_ROUTINES], binary->parts_count[BPM_ROUTINES], + sizeof(GBinPart *), (__compar_fn_t)g_binary_part_compare); /* Parties à désassembler : utilisateur */ @@ -455,34 +380,29 @@ GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const { g_binary_part_get_values(part, &offset, NULL, NULL); - if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(result->format), offset, &addr)) + if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(binary->format), offset, &addr)) { g_object_unref(G_OBJECT(part)); continue; } - result->parts_count[BPM_USER]++; - result->parts[BPM_USER] = (GBinPart **)realloc(result->parts[BPM_USER], - result->parts_count[BPM_USER] * sizeof(GBinPart *)); + binary->parts_count[BPM_USER]++; + binary->parts[BPM_USER] = (GBinPart **)realloc(binary->parts[BPM_USER], + binary->parts_count[BPM_USER] * sizeof(GBinPart *)); - result->parts[BPM_USER][result->parts_count[BPM_USER] - 1] = part; + binary->parts[BPM_USER][binary->parts_count[BPM_USER] - 1] = part; } } - if(xobjects != NULL) /* FIXME */ + if(xobjects != NULL) xmlXPathFreeObject(xobjects); free(access); - qsort(result->parts[BPM_USER], result->parts_count[BPM_USER], - sizeof(GBinPart *), g_binary_part_compare); - - - - - + qsort(binary->parts[BPM_USER], binary->parts_count[BPM_USER], + sizeof(GBinPart *), (__compar_fn_t)g_binary_part_compare); return result; @@ -496,7 +416,7 @@ GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const * context = contexte à utiliser pour les recherches. * * path = chemin d'accès réservé au binaire. * * * -* Description : Ecrit une sauvegarde du binaire dans un fichier XML. * +* Description : Ecrit les parties de valeur du binaire dans un fichier XML. * * * * Retour : true si l'opération a bien tourné, false sinon. * * * @@ -504,7 +424,7 @@ GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const * * ******************************************************************************/ -bool g_openida_binary_save(const GOpenidaBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path) +static bool g_loaded_binary_save_parts(const GLoadedBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path) { bool result; /* Bilan à faire remonter */ char *access; /* Chemin d'accès à un élément */ @@ -513,21 +433,6 @@ bool g_openida_binary_save(const GOpenidaBinary *binary, xmlDocPtr xdoc, xmlXPat result = true; - /* Type */ - - result &= add_string_attribute_to_node(xdoc, context, path, "type", "file"); - - /* Nom du fichier associé */ - - access = strdup(path); - access = stradd(access, "/Filename"); - - result &= add_content_to_node(xdoc, context, access, binary->filename); - - free(access); - - /* Parties à désassembler */ - if (binary->parts_count[BPM_DEFAULT] > 0) { access = strdup(path); @@ -590,9 +495,9 @@ bool g_openida_binary_save(const GOpenidaBinary *binary, xmlDocPtr xdoc, xmlXPat * * ******************************************************************************/ -void g_openida_binary_set_parts(GOpenidaBinary *binary, BinaryPartModel model, GBinPart **parts, size_t count) +void g_loaded_binary_set_parts(GLoadedBinary *binary, BinaryPartModel model, GBinPart **parts, size_t count) { - qsort(parts, count, sizeof(GBinPart *), g_binary_part_compare); + qsort(parts, count, sizeof(GBinPart *), (__compar_fn_t)g_binary_part_compare); binary->parts[model] = parts; binary->parts_count[model] = count; @@ -614,7 +519,7 @@ void g_openida_binary_set_parts(GOpenidaBinary *binary, BinaryPartModel model, G * * ******************************************************************************/ -GBinPart ***g_openida_binary_get_parts(const GOpenidaBinary *binary, BinaryPartModel *model, size_t **count) +GBinPart ***g_loaded_binary_get_parts(const GLoadedBinary *binary, BinaryPartModel *model, size_t **count) { *model = binary->model; *count = binary->parts_count; @@ -636,7 +541,7 @@ GBinPart ***g_openida_binary_get_parts(const GOpenidaBinary *binary, BinaryPartM * * ******************************************************************************/ -void g_openida_binary_analyse(GOpenidaBinary *binary) +void g_loaded_binary_analyse(GLoadedBinary *binary) { GBinPart **parts; /* Parties d'élément binaire */ size_t parts_count; /* Nombre de ces parties */ @@ -660,7 +565,7 @@ void g_openida_binary_analyse(GOpenidaBinary *binary) else { parts = g_exe_format_get_parts(binary->format, &parts_count); - qsort(parts, parts_count, sizeof(GBinPart *), g_binary_part_compare); + qsort(parts, parts_count, sizeof(GBinPart *), (__compar_fn_t)g_binary_part_compare); } } @@ -676,25 +581,7 @@ void g_openida_binary_analyse(GOpenidaBinary *binary) /****************************************************************************** * * * Paramètres : binary = élément binaire à consulter. * -* * -* Description : Fournit une description humaine d'un élément binaire. * -* * -* Retour : Chaîne de caractères humainenement lisible de représentation.* -* * -* Remarques : - * -* * -******************************************************************************/ - -const char *g_openida_binary_to_string(const GOpenidaBinary *binary) -{ - return binary->filename; - -} - - -/****************************************************************************** -* * -* Paramètres : binary = élément binaire à consulter. * +* full = précise s'il s'agit d'une version longue ou non. * * * * Description : Fournit le fichier correspondant à l'élément binaire. * * * @@ -704,9 +591,9 @@ const char *g_openida_binary_to_string(const GOpenidaBinary *binary) * * ******************************************************************************/ -const char *g_openida_binary_get_filename(const GOpenidaBinary *binary) +const char *g_loaded_binary_get_filename(const GLoadedBinary *binary, bool full) { - return binary->filename; + return binary->get_filename(binary, full); } @@ -724,7 +611,7 @@ const char *g_openida_binary_get_filename(const GOpenidaBinary *binary) * * ******************************************************************************/ -bin_t *g_openida_binary_get_data(const GOpenidaBinary *binary, off_t *length) +bin_t *g_loaded_binary_get_data(const GLoadedBinary *binary, off_t *length) { if (length != NULL) *length = binary->bin_length; @@ -746,7 +633,7 @@ bin_t *g_openida_binary_get_data(const GOpenidaBinary *binary, off_t *length) * * ******************************************************************************/ -GExeFormat *g_openida_binary_get_format(const GOpenidaBinary *binary) +GExeFormat *g_loaded_binary_get_format(const GLoadedBinary *binary) { return binary->format; @@ -757,63 +644,6 @@ GExeFormat *g_openida_binary_get_format(const GOpenidaBinary *binary) * * * Paramètres : binary = élément binaire à consulter. * * * -* Description : Fournit les options d'affichage définies pour le binaire. * -* * -* Retour : Adresse des options d'affichage. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GRenderingOptions *g_openida_binary_get_options(const GOpenidaBinary *binary) -{ - return binary->options; - -} - - -/****************************************************************************** -* * -* Paramètres : binary = élément binaire à consulter. * -* * -* Description : Donne la racine des lignes de rendu issues du désassemblage. * -* * -* Retour : Lieu d'enregistrement des lignes issues du désassemblage. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GRenderingLine **g_openida_binary_get_lines_root(const GOpenidaBinary *binary) -{ - return &binary->lines; - -} - - -/****************************************************************************** -* * -* Paramètres : binary = élément binaire à consulter. * -* * -* Description : Fournit les lignes de rendu issues du désassemblage. * -* * -* Retour : Lignes issues du désassemblage. * -* * -* Remarques : - * -* * -******************************************************************************/ - -GRenderingLine *g_openida_binary_get_lines(const GOpenidaBinary *binary) -{ - return binary->lines; - -} - - -/****************************************************************************** -* * -* Paramètres : binary = élément binaire à consulter. * -* * * Description : Fournit les instructions issues du désassemblage. * * * * Retour : Instructions issues du désassemblage. * @@ -822,7 +652,7 @@ GRenderingLine *g_openida_binary_get_lines(const GOpenidaBinary *binary) * * ******************************************************************************/ -GArchInstruction *g_openida_binary_get_instructions(const GOpenidaBinary *binary) +GArchInstruction *g_loaded_binary_get_instructions(const GLoadedBinary *binary) { return binary->instrs; @@ -841,7 +671,7 @@ GArchInstruction *g_openida_binary_get_instructions(const GOpenidaBinary *binary * * ******************************************************************************/ -GCodeBuffer *g_openida_binary_get_disassembled_buffer(const GOpenidaBinary *binary) +GCodeBuffer *g_loaded_binary_get_disassembled_buffer(const GLoadedBinary *binary) { return binary->disass_buffer; @@ -860,7 +690,7 @@ GCodeBuffer *g_openida_binary_get_disassembled_buffer(const GOpenidaBinary *bina * * ******************************************************************************/ -bool *g_openida_binary_display_addresses_in_text(const GOpenidaBinary *binary) +bool *g_loaded_binary_display_addresses_in_text(GLoadedBinary *binary) { return &binary->text_display[0]; @@ -879,7 +709,7 @@ bool *g_openida_binary_display_addresses_in_text(const GOpenidaBinary *binary) * * ******************************************************************************/ -bool *g_openida_binary_display_code_in_text(const GOpenidaBinary *binary) +bool *g_loaded_binary_display_code_in_text(GLoadedBinary *binary) { return &binary->text_display[1]; @@ -899,7 +729,7 @@ bool *g_openida_binary_display_code_in_text(const GOpenidaBinary *binary) * * ******************************************************************************/ -GCodeBuffer *g_openida_binary_get_decompiled_buffer(const GOpenidaBinary *binary, size_t index) +GCodeBuffer *g_loaded_binary_get_decompiled_buffer(const GLoadedBinary *binary, size_t index) { GCodeBuffer *result; /* Tampon à retourner */ @@ -926,7 +756,7 @@ GCodeBuffer *g_openida_binary_get_decompiled_buffer(const GOpenidaBinary *binary * * ******************************************************************************/ -bool *g_openida_binary_display_decomp_lines(const GOpenidaBinary *binary) +bool *g_loaded_binary_display_decomp_lines(GLoadedBinary *binary) { return &binary->lines_display; @@ -935,59 +765,6 @@ bool *g_openida_binary_display_decomp_lines(const GOpenidaBinary *binary) /****************************************************************************** * * -* Paramètres : filename = nom du fichier à charger. * -* length = taille des données mises en mémoire. [OUT] * -* * -* Description : Charge en mémoire le contenu d'un fichier. * -* * -* Retour : Adresse du contenu binaire ou NULL en cas d'échec. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bin_t *map_binary_file(const char *filename, off_t *length) -{ - uint8_t *result; /* Données à retourner */ - int fd; /* Fichier ouvert en lecture */ - struct stat info; /* Informations sur le fichier */ - int ret; /* Bilan d'un appel */ - - fd = open(filename, 0, O_RDONLY); - if (fd == -1) - { - perror("open()"); - return NULL; - } - - ret = fstat(fd, &info); - if (ret == -1) - { - perror("fstat()"); - close(fd); - return NULL; - } - - *length = info.st_size; - - result = (uint8_t *)mmap(NULL, *length, PROT_READ, MAP_PRIVATE, fd, 0); - if (result == MAP_FAILED) - { - perror("mmap()"); - result = NULL; - } - - ret = close(fd); - if (ret == -1) - perror("close()"); - - return result; - -} - - -/****************************************************************************** -* * * Paramètres : disass = travail de désassemblage mené à bien. * * binary = représentation de binaire à l'origine de l'opérat°. * * * @@ -999,9 +776,9 @@ bin_t *map_binary_file(const char *filename, off_t *length) * * ******************************************************************************/ -void ack_completed_disassembly(void/*GDelayedDisassembly*/ *disass, GOpenidaBinary *binary) +void ack_completed_disassembly(void/*GDelayedDisassembly*/ *disass, GLoadedBinary *binary) { - GRenderingLine *line; /* "Première" ligne de rendu */ + //GRenderingLine *line; /* "Première" ligne de rendu */ size_t i; /* Boucle de parcours */ @@ -1040,196 +817,3 @@ void ack_completed_disassembly(void/*GDelayedDisassembly*/ *disass, GOpenidaBina g_signal_emit_by_name(binary, "disassembly-done"); } - - - -/* ---------------------------------------------------------------------------------- */ -/* ELEMENTS DE DEBOGAGE */ -/* ---------------------------------------------------------------------------------- */ - - -/****************************************************************************** -* * -* Paramètres : binary = représentation de binaire à modifier. * -* name = éventuel nom à associer au groupe. * -* * -* Description : Ajoute un nouveau groupe de points d'arrêt au binaire. * -* * -* Retour : true si l'opération s'est bien effectuée, false sinon. * -* * -* Remarques : - * -* * -******************************************************************************/ - -bool g_openida_binary_add_break_group(GOpenidaBinary *binary, const char *name) -{ - bool result; /* Bilan à faire remonter */ - const char *used; /* Désignation à utiliser */ - size_t tmp_len; /* Longeur maximale à gérer */ - char *tmp; /* Construction temporaire */ - size_t i; /* Boucle de parcours */ - const char *test; /* Nom existant à tester */ - - result = true; - - /* Préparation du nom de scène */ - - if (name != NULL) used = name; - else - { - tmp_len = strlen(_("Group")) + 1 + SIZE_T_MAXLEN + 1; - tmp = (char *)calloc(tmp_len, sizeof(char)); - - snprintf(tmp, tmp_len, "%s %lu", _("Group"), binary->brk_count); - - used = tmp; - - } - - /* Vérification d'unicité */ - - for (i = 0; i < binary->brk_count && result; i++) - { - test = g_break_group_get_name(binary->brk_groups[i]); - - if (test != NULL) - result = (strcmp(used, test) != 0); - - } - - /* Mise en place finale */ - - if (result) - { - binary->brk_count++; - binary->brk_groups = (GBreakGroup **)realloc(binary->brk_groups, - binary->brk_count * sizeof(GBreakGroup *)); - - binary->brk_groups[i] = g_break_group_new(); - - g_break_group_set_name(binary->brk_groups[i], used); - - if (binary->brk_default == NULL) - binary->brk_default = binary->brk_groups[i]; - - g_signal_connect(binary->brk_groups[i], "added", - G_CALLBACK(g_openida_binary_breakpoint_added), binary); - - g_signal_connect(binary->brk_groups[i], "removed", - G_CALLBACK(g_openida_binary_breakpoint_removed), binary); - - } - - if (name == NULL) free(tmp); - - return result; - -} - - -/****************************************************************************** -* * -* Paramètres : group = ensemble de points d'arrêt intervenant. * -* point = point d'arrêt à l'origine de la procédure. * -* binary = représentation de binaire à modifier. * -* * -* Description : Réagit à une nouvelle création de point d'arrêt. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_openida_binary_breakpoint_added(GBreakGroup *group, GBreakPoint *point, GOpenidaBinary *binary) -{ - GRenderingLine *line; /* Ligne à retrouver */ - - line = g_rendering_line_find_by_address(binary->lines, NULL, - g_break_point_get_address(point)); - - if (line != NULL) - g_rendering_line_toggle_flag(line, RLF_BREAK_POINT); - -} - - -/****************************************************************************** -* * -* Paramètres : group = ensemble de points d'arrêt intervenant. * -* point = point d'arrêt à l'origine de la procédure. * -* binary = représentation de binaire à modifier. * -* * -* Description : Réagit à une suppression de point d'arrêt. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_openida_binary_breakpoint_removed(GBreakGroup *group, GBreakPoint *point, GOpenidaBinary *binary) -{ - GRenderingLine *line; /* Ligne à retrouver */ - - line = g_rendering_line_find_by_address(binary->lines, NULL, - g_break_point_get_address(point)); - - if (line != NULL) - g_rendering_line_toggle_flag(line, RLF_BREAK_POINT); - -} - - -/****************************************************************************** -* * -* Paramètres : binary = représentation de binaire à mettre à jour. * -* addr = adresse mémoire à faire basculer. * -* * -* Description : Ajoute ou supprime un point d'arrêt dans un binaire. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_openida_binary_toggle_breakpoint(GOpenidaBinary *binary, vmpa_t addr) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < binary->brk_count; i++) - if (g_break_group_has_address(binary->brk_groups[i], addr)) - { - g_break_group_toggle_breakpoint(binary->brk_groups[i], addr); - break; - } - - if (i == binary->brk_count) - g_break_group_toggle_breakpoint(binary->brk_default, addr); - -} - - -/****************************************************************************** -* * -* Paramètres : binary = représentation de binaire à parcourir. * -* func = fonction à appeler à chaque point trouvé. * -* data = éventuelle donnée de l'utilisateur à joindre. * -* * -* Description : Parcourt l'ensemble des groupes de points d'arrêt du binaire.* -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_openida_binary_for_each_bp_group(GOpenidaBinary *binary, GExtFunc func, gpointer data) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < binary->brk_count; i++) - func(binary, binary->brk_groups[i], data); - -} diff --git a/src/analysis/binary.h b/src/analysis/binary.h index 63a9e61..7ff9080 100644 --- a/src/analysis/binary.h +++ b/src/analysis/binary.h @@ -32,24 +32,23 @@ #include "line.h" #include "../arch/processor.h" #include "../common/xml.h" -#include "../debug/break.h" #include "../format/executable.h" #include "../glibext/gcodebuffer.h" -#define G_TYPE_OPENIDA_BINARY g_openida_binary_get_type() -#define G_OPENIDA_BINARY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_openida_binary_get_type(), GOpenidaBinary)) -#define G_IS_OPENIDA_BINARY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_openida_binary_get_type())) -#define G_OPENIDA_BINARY_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_openida_binary_get_type(), GOpenidaBinaryIface)) -#define G_OPENIDA_BINARY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_OPENIDA_BINARY, GOpenidaBinaryClass)) +#define G_TYPE_LOADED_BINARY g_loaded_binary_get_type() +#define G_LOADED_BINARY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_loaded_binary_get_type(), GLoadedBinary)) +#define G_IS_LOADED_BINARY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_loaded_binary_get_type())) +#define G_LOADED_BINARY_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_loaded_binary_get_type(), GLoadedBinaryIface)) +#define G_LOADED_BINARY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_LOADED_BINARY, GLoadedBinaryClass)) /* Description de fichier binaire (instance) */ -typedef struct _GOpenidaBinary GOpenidaBinary; +typedef struct _GLoadedBinary GLoadedBinary; /* Description de fichier binaire (classe) */ -typedef struct _GOpenidaBinaryClass GOpenidaBinaryClass; +typedef struct _GLoadedBinaryClass GLoadedBinaryClass; /* Modèle de sélection des parties */ @@ -65,78 +64,49 @@ typedef enum _BinaryPartModel /* Indique le type défini pour une description de fichier binaire. */ -GType g_openida_binary_get_type(void); - -/* Charge en mémoire le contenu d'un fichier. */ -GOpenidaBinary *g_openida_binary_new_from_file(const char *); +GType g_loaded_binary_get_type(void); /* Charge en mémoire le contenu d'un fichier à partir d'XML. */ -GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr, const char *); +GLoadedBinary *g_loaded_binary_new_from_xml(xmlXPathContextPtr, const char *); /* Ecrit une sauvegarde du binaire dans un fichier XML. */ -bool g_openida_binary_save(const GOpenidaBinary *, xmlDocPtr, xmlXPathContextPtr, const char *); +bool g_loaded_binary_save(const GLoadedBinary *, xmlDocPtr, xmlXPathContextPtr, const char *); /* Définit les parties de binaire à analyser. */ -void g_openida_binary_set_parts(GOpenidaBinary *, BinaryPartModel, GBinPart **, size_t); +void g_loaded_binary_set_parts(GLoadedBinary *, BinaryPartModel, GBinPart **, size_t); /* Fournit les parties de binaire analysées. */ -GBinPart ***g_openida_binary_get_parts(const GOpenidaBinary *, BinaryPartModel *, size_t **); +GBinPart ***g_loaded_binary_get_parts(const GLoadedBinary *, BinaryPartModel *, size_t **); /* Lance l'analyse d'un élément binaire chargé. */ -void g_openida_binary_analyse(GOpenidaBinary *); - -/* Fournit une description humaine d'un élément binaire. */ -const char *g_openida_binary_to_string(const GOpenidaBinary *); +void g_loaded_binary_analyse(GLoadedBinary *); /* Fournit le fichier correspondant à l'élément binaire. */ -const char *g_openida_binary_get_filename(const GOpenidaBinary *); +const char *g_loaded_binary_get_filename(const GLoadedBinary *, bool); /* Fournit les détails du contenu binaire chargé en mémoire. */ -bin_t *g_openida_binary_get_data(const GOpenidaBinary *, off_t *); +bin_t *g_loaded_binary_get_data(const GLoadedBinary *, off_t *); /* Fournit le format de fichier reconnu dans le contenu binaire. */ -GExeFormat *g_openida_binary_get_format(const GOpenidaBinary *); - -/* Fournit les options d'affichage définies pour le binaire. */ -GRenderingOptions *g_openida_binary_get_options(const GOpenidaBinary *); - -/* Donne la racine des lignes de rendu issues du désassemblage. */ -GRenderingLine **g_openida_binary_get_lines_root(const GOpenidaBinary *); - -/* Fournit les lignes de rendu issues du désassemblage. */ -GRenderingLine *g_openida_binary_get_lines(const GOpenidaBinary *); +GExeFormat *g_loaded_binary_get_format(const GLoadedBinary *); /* Fournit les instructions issues du désassemblage. */ -GArchInstruction *g_openida_binary_get_instructions(const GOpenidaBinary *); +GArchInstruction *g_loaded_binary_get_instructions(const GLoadedBinary *); /* Fournit le tampon associé au contenu assembleur d'un binaire. */ -GCodeBuffer *g_openida_binary_get_disassembled_buffer(const GOpenidaBinary *); +GCodeBuffer *g_loaded_binary_get_disassembled_buffer(const GLoadedBinary *); /* Indique si les adresses doivent apparaître dans le rendu. */ -bool *g_openida_binary_display_addresses_in_text(const GOpenidaBinary *); +bool *g_loaded_binary_display_addresses_in_text(GLoadedBinary *); /* Indique si le code doit apparaître dans le rendu. */ -bool *g_openida_binary_display_code_in_text(const GOpenidaBinary *); +bool *g_loaded_binary_display_code_in_text(GLoadedBinary *); /* Fournit le tampon associé au contenu d'un fichier source. */ -GCodeBuffer *g_openida_binary_get_decompiled_buffer(const GOpenidaBinary *, size_t); +GCodeBuffer *g_loaded_binary_get_decompiled_buffer(const GLoadedBinary *, size_t); /* Indique si les lignes doivent apparaître dans le rendu. */ -bool *g_openida_binary_display_decomp_lines(const GOpenidaBinary *); - - - -/* ------------------------------ ELEMENTS DE DEBOGAGE ------------------------------ */ - - -/* Ajoute un nouveau groupe de points d'arrêt au binaire. */ -bool g_openida_binary_add_break_group(GOpenidaBinary *, const char *); - -/* Ajoute ou supprime un point d'arrêt dans un binaire. */ -void g_openida_binary_toggle_breakpoint(GOpenidaBinary *, vmpa_t); - -/* Parcourt l'ensemble des groupes de points d'arrêt du binaire. */ -void g_openida_binary_for_each_bp_group(GOpenidaBinary *, GExtFunc, gpointer); +bool *g_loaded_binary_display_decomp_lines(GLoadedBinary *); diff --git a/src/analysis/decomp/decompiler.c b/src/analysis/decomp/decompiler.c index 42dc1ff..8e574c0 100644 --- a/src/analysis/decomp/decompiler.c +++ b/src/analysis/decomp/decompiler.c @@ -42,7 +42,7 @@ static void build_decomp_prologue(GCodeBuffer *, const char *); /* S'assure de la transcription de routines en expressions. */ -static void prepare_all_routines_for_decomp(const GOpenidaBinary *, const char *); +static void prepare_all_routines_for_decomp(const GLoadedBinary *, const char *); @@ -127,7 +127,7 @@ static void build_decomp_prologue(GCodeBuffer *buffer, const char *filename) * * ******************************************************************************/ -static void prepare_all_routines_for_decomp(const GOpenidaBinary *binary, const char *filename) +static void prepare_all_routines_for_decomp(const GLoadedBinary *binary, const char *filename) { GExeFormat *format; /* Format du binaire fourni */ GArchProcessor *proc; /* Architecture du binaire */ @@ -140,7 +140,7 @@ static void prepare_all_routines_for_decomp(const GOpenidaBinary *binary, const GDecContext *context; /* Contexte pour la décompil. */ GDecInstruction *instr; - format = g_openida_binary_get_format(binary); + format = g_loaded_binary_get_format(binary); proc = get_arch_processor_from_format(G_EXE_FORMAT(format)); @@ -179,7 +179,7 @@ static void prepare_all_routines_for_decomp(const GOpenidaBinary *binary, const * * ******************************************************************************/ -GCodeBuffer *decompile_all_from_file(const GOpenidaBinary *binary, const char *filename) +GCodeBuffer *decompile_all_from_file(const GLoadedBinary *binary, const char *filename) { GCodeBuffer *result; /* Tampon constitué à renvoyer */ GExeFormat *format; /* Format du binaire fourni */ @@ -195,7 +195,7 @@ GCodeBuffer *decompile_all_from_file(const GOpenidaBinary *binary, const char *f - format = g_openida_binary_get_format(binary); + format = g_loaded_binary_get_format(binary); g_binary_format_decompile(G_BIN_FORMAT(format), result, filename); return result; diff --git a/src/analysis/decomp/decompiler.h b/src/analysis/decomp/decompiler.h index 363ad27..5233b74 100644 --- a/src/analysis/decomp/decompiler.h +++ b/src/analysis/decomp/decompiler.h @@ -30,7 +30,7 @@ /* Procède à la décompilation des routines d'un fichier donné. */ -GCodeBuffer *decompile_all_from_file(const GOpenidaBinary *, const char *); +GCodeBuffer *decompile_all_from_file(const GLoadedBinary *, const char *); diff --git a/src/analysis/disass/disassembler.c b/src/analysis/disass/disassembler.c index 872dc09..73d75cf 100644 --- a/src/analysis/disass/disassembler.c +++ b/src/analysis/disass/disassembler.c @@ -60,7 +60,7 @@ typedef struct _GDelayedDisassembly { GDelayedWork parent; /* A laisser en premier */ - const GOpenidaBinary *binary; /* Destinataire final */ + const GLoadedBinary *binary; /* Destinataire final */ const GExeFormat *format; /* Format du binaire représenté*/ GBinPart **parts; /* Parties binaires à traiter */ @@ -89,7 +89,7 @@ static void g_delayed_disassembly_class_init(GDelayedDisassemblyClass *); static void g_delayed_disassembly_init(GDelayedDisassembly *); /* Crée une tâche de désassemblage différé. */ -static GDelayedDisassembly *g_delayed_disassembly_new(const GOpenidaBinary *, GBinPart **, size_t, GCodeBuffer *); +static GDelayedDisassembly *g_delayed_disassembly_new(const GLoadedBinary *, GBinPart **, size_t, GCodeBuffer *); /* Assure le désassemblage en différé. */ static void g_delayed_disassembly_process(GDelayedDisassembly *, GtkExtStatusBar *); @@ -165,14 +165,14 @@ static void g_delayed_disassembly_init(GDelayedDisassembly *disass) * * ******************************************************************************/ -static GDelayedDisassembly *g_delayed_disassembly_new(const GOpenidaBinary *binary, GBinPart **parts, size_t count, GCodeBuffer *buffer) +static GDelayedDisassembly *g_delayed_disassembly_new(const GLoadedBinary *binary, GBinPart **parts, size_t count, GCodeBuffer *buffer) { GDelayedDisassembly *result; /* Tâche à retourner */ result = g_object_new(G_TYPE_DELAYED_DISASSEMBLY, NULL); result->binary = binary; - result->format = g_openida_binary_get_format(binary); + result->format = g_loaded_binary_get_format(binary); result->parts = parts; result->count = count; @@ -381,7 +381,7 @@ static void build_disass_prologue(GCodeBuffer *buffer, const char *filename, con * * ******************************************************************************/ -void disassemble_binary(GOpenidaBinary *binary, GBinPart **parts, size_t parts_count, GArchInstruction **instrs, GCodeBuffer **buffer) +void disassemble_binary(GLoadedBinary *binary, GBinPart **parts, size_t parts_count, GArchInstruction **instrs, GCodeBuffer **buffer) { const uint8_t *data; /* Données binaires brutes */ off_t length; /* Quantité de ces données */ @@ -395,8 +395,8 @@ void disassemble_binary(GOpenidaBinary *binary, GBinPart **parts, size_t parts_c *buffer = g_code_buffer_new(); - data = g_openida_binary_get_data(binary, &length); - build_disass_prologue(*buffer, g_openida_binary_get_filename(binary), data, length); + data = g_loaded_binary_get_data(binary, &length); + build_disass_prologue(*buffer, g_loaded_binary_get_filename(binary, true), data, length); disass = g_delayed_disassembly_new(binary, parts, parts_count, *buffer); diff --git a/src/analysis/disass/disassembler.h b/src/analysis/disass/disassembler.h index 2c5adef..8cca194 100644 --- a/src/analysis/disass/disassembler.h +++ b/src/analysis/disass/disassembler.h @@ -31,7 +31,7 @@ /* Procède à la décompilation des routines d'un fichier donné. */ -void disassemble_binary(GOpenidaBinary *, GBinPart **parts, size_t parts_count, GArchInstruction **, GCodeBuffer **); +void disassemble_binary(GLoadedBinary *, GBinPart **parts, size_t parts_count, GArchInstruction **, GCodeBuffer **); diff --git a/src/analysis/disass/fetch.c b/src/analysis/disass/fetch.c index 6bd9795..a1df5e3 100644 --- a/src/analysis/disass/fetch.c +++ b/src/analysis/disass/fetch.c @@ -45,7 +45,7 @@ * * ******************************************************************************/ -GArchInstruction *disassemble_binary_parts(const GOpenidaBinary *binary, GBinPart **parts, size_t count, GtkExtStatusBar *statusbar, guint id) +GArchInstruction *disassemble_binary_parts(const GLoadedBinary *binary, GBinPart **parts, size_t count, GtkExtStatusBar *statusbar, guint id) { GArchInstruction *result; /* Liste d'instr. à renvoyer */ GBinFormat *format; /* Format du fichier binaire */ @@ -69,9 +69,9 @@ GArchInstruction *disassemble_binary_parts(const GOpenidaBinary *binary, GBinPar result = NULL; - format = G_BIN_FORMAT(g_openida_binary_get_format(binary)); + format = G_BIN_FORMAT(g_loaded_binary_get_format(binary)); proc = get_arch_processor_from_format(G_EXE_FORMAT(format)); - bin_data = g_openida_binary_get_data(binary, &bin_length); + bin_data = g_loaded_binary_get_data(binary, &bin_length); /* Préparation du suivi de la progression */ diff --git a/src/analysis/disass/fetch.h b/src/analysis/disass/fetch.h index 09bb584..89c3226 100644 --- a/src/analysis/disass/fetch.h +++ b/src/analysis/disass/fetch.h @@ -31,7 +31,7 @@ /* Procède au désassemblage basique d'un contenu binaire. */ -GArchInstruction *disassemble_binary_parts(const GOpenidaBinary *, GBinPart **, size_t, GtkExtStatusBar *, guint); +GArchInstruction *disassemble_binary_parts(const GLoadedBinary *, GBinPart **, size_t, GtkExtStatusBar *, guint); |