/* OpenIDA - Outil d'analyse de fichiers binaires
* binary.c - traitement des flots de code binaire
*
* Copyright (C) 2008 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 .
*/
#include "binary.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "line_code.h" /* TODO : supprimer ? */
#include "line_comment.h" /* TODO : supprimer ? */
#include "line_prologue.h"
#include "routine.h"
#include "../common/cpp.h"
#include "../common/extstr.h"
#include "../debug/break.h"
#include "../glibext/delayed-int.h"
#include "../format/format.h"
#include "../panels/log.h"
#include "../plugins/pglist.h"
#include "../format/dbg_format.h"
#ifndef _
# define _(str) str
#endif
/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */
#define G_TYPE_DELAYED_DISASSEMBLY g_delayed_disassembly_get_type()
#define G_DELAYED_DISASSEMBLY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_delayed_disassembly_get_type(), GDelayedDisassembly))
#define G_IS_DELAYED_DISASSEMBLY(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_delayed_disassembly_get_type()))
#define G_DELAYED_DISASSEMBLY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DELAYED_DISASSEMBLY, GDelayedDisassemblyClass))
#define G_IS_DELAYED_DISASSEMBLY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DELAYED_DISASSEMBLY))
#define G_DELAYED_DISASSEMBLY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DELAYED_DISASSEMBLY, GDelayedDisassemblyClass))
/* Ensembles binaires à désassembler (instance) */
typedef struct _GDelayedDisassembly
{
GDelayedWork parent; /* A laisser en premier */
GOpenidaBinary *binary; /* Destinataire final */
GBinPart **parts; /* Parties binaires à traiter */
size_t count; /* Nombre de ces parties */
GRenderingLine *lines; /* Lignes de rendu résultantes */
} GDelayedDisassembly;
/* Ensembles binaires à désassembler (classe) */
typedef struct _GDelayedDisassemblyClass
{
GDelayedWorkClass parent; /* A laisser en premier */
} GDelayedDisassemblyClass;
/* Indique le type défini pour les tâches de désassemblage différé. */
static GType g_delayed_disassembly_get_type(void);
/* Initialise la classe des tâches de désassemblage différé. */
static void g_delayed_disassembly_class_init(GDelayedDisassemblyClass *);
/* Initialise une tâche de désassemblage différé. */
static void g_delayed_disassembly_init(GDelayedDisassembly *);
/* Crée une tâche de désassemblage différé. */
static GDelayedDisassembly *g_delayed_disassembly_new(GOpenidaBinary *, GBinPart **, size_t);
/* Assure le désassemblage en différé. */
static void g_delayed_disassembly_process(GDelayedDisassembly *, GtkExtStatusBar *);
/* Procède au désassemblage basique d'un contenu binaire. */
static GRenderingLine *disassemble_binary_parts(GDelayedDisassembly *, GBinRoutine **, size_t, GtkExtStatusBar *, guint);
/* Etablit les liens entres les différentes lignes de code. */
static void establish_links_between_lines(GRenderingLine *, GBinRoutine **, size_t, GtkExtStatusBar *, guint);
/* S'assure que toutes les routines ont une taille définie. */
static void limit_all_routines(GRenderingLine *, GBinRoutine **, size_t, GtkExtStatusBar *, guint);
/* Cherche l'adresse de fin d'une routine. */
static vmpa_t find_best_ending_address_for_routine(GRenderingLine *, size_t, const vmpa_t *, const off_t *, size_t);
/* 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 */
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 *);
/* 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 *);
/* Construit la description d'introduction du désassemblage. */
GRenderingLine *build_binary_prologue(const char *, const uint8_t *, off_t);
/* Acquitte la fin d'un désasemblage différé et complet. */
void ack_completed_disassembly(GDelayedDisassembly *, GOpenidaBinary *);
/* ------------------------------ ELEMENTS DE DEBOGAGE ------------------------------ */
/* 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 *);
/* ---------------------------------------------------------------------------------- */
/* DESASSEMBLAGE DE BINAIRE DIFFERE */
/* ---------------------------------------------------------------------------------- */
/* Indique le type défini pour les tâches de désassemblage différé. */
G_DEFINE_TYPE(GDelayedDisassembly, g_delayed_disassembly, G_TYPE_DELAYED_WORK);
/******************************************************************************
* *
* Paramètres : klass = classe à initialiser. *
* *
* Description : Initialise la classe des tâches de désassemblage différé. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_delayed_disassembly_class_init(GDelayedDisassemblyClass *klass)
{
}
/******************************************************************************
* *
* Paramètres : disass = instance à initialiser. *
* *
* Description : Initialise une tâche de désassemblage différé. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_delayed_disassembly_init(GDelayedDisassembly *disass)
{
G_DELAYED_WORK(disass)->run = (run_task_fc)g_delayed_disassembly_process;
}
/******************************************************************************
* *
* Paramètres : binary = binaire chargé en attente des résultats. *
* parts = parties binaires à désassembler. *
* count = nombre de parties à traiter. *
* *
* Description : Crée une tâche de désassemblage différé. *
* *
* Retour : Tâche créée. *
* *
* Remarques : - *
* *
******************************************************************************/
static GDelayedDisassembly *g_delayed_disassembly_new(GOpenidaBinary *binary, GBinPart **parts, size_t count)
{
GDelayedDisassembly *result; /* Tâche à retourner */
result = g_object_new(G_TYPE_DELAYED_DISASSEMBLY, NULL);
result->binary = binary;
result->parts = parts;
result->count = count;
return result;
}
/******************************************************************************
* *
* Paramètres : disass = analyse à mener. *
* statusbar = barre de statut à tenir informée. *
* *
* Description : Assure le désassemblage en différé. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_delayed_disassembly_process(GDelayedDisassembly *disass, GtkExtStatusBar *statusbar)
{
GBinRoutine **routines; /* Liste des routines trouvées */
size_t routines_count; /* Nombre de ces routines */
guint id; /* Identifiant de statut */
routines = g_binary_format_get_routines(G_BIN_FORMAT(disass->binary->format), &routines_count);
qsort(routines, routines_count, sizeof(GBinRoutine *), g_binary_routine_rcompare);
/* Première étape */
id = gtk_extended_status_bar_push(statusbar, _("Disassembling..."), true);
disass->lines = disassemble_binary_parts(disass, routines, routines_count, statusbar, id);
gtk_extended_status_bar_remove(statusbar, id);
/* Seconde étape */
id = gtk_extended_status_bar_push(statusbar, _("Establishing links..."), true);
establish_links_between_lines(disass->lines, routines, routines_count, statusbar, id);
gtk_extended_status_bar_remove(statusbar, id);
/* Troisième étape */
id = gtk_extended_status_bar_push(statusbar, _("Finding remaining limits..."), true);
limit_all_routines(disass->lines, routines, routines_count, statusbar, id);
gtk_extended_status_bar_remove(statusbar, id);
}
/******************************************************************************
* *
* Paramètres : disass = tâche à l'origine du traitement. *
* routines = prototypes existants à insérer. *
* count = quantité de ces prototypes. *
* statusbar = barre de statut avec progression à mettre à jour.*
* id = identifiant du message affiché à l'utilisateur. *
* *
* Description : Procède au désassemblage basique d'un contenu binaire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static GRenderingLine *disassemble_binary_parts(GDelayedDisassembly *disass, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, guint id)
{
GRenderingLine *result; /* Ligne de rendu à retourner */
GArchProcessor *proc; /* Architecture du binaire */
GRenderingOptions *options; /* Options de désassemblage */
bin_t *bin_data; /* Données binaires à lire */
size_t i; /* Boucle de parcours #1 */
off_t sum; /* Somme de toutes les tailles */
off_t done; /* Quantité déjà traitée */
off_t pos; /* Début d'une zone binaire */
off_t len; /* Taille de cette même zone */
vmpa_t base; /* Adresse de la zone binaire */
off_t start; /* Conservation du pt de départ*/
vmpa_t addr; /* Adresse d'une instruction */
GArchInstruction *instr; /* Instruction décodée */
GRenderingLine *line; /* Nouvelle ligne de rendu */
size_t k; /* Boucle de parcours #2 */
uint64_t routine_offset; /* Point de départ de routine */
char *routine_desc; /* Prototype d'une routine */
result = NULL;
proc = get_arch_processor_from_format(g_openida_binary_get_format(disass->binary));
options = g_openida_binary_get_options(disass->binary);
bin_data = g_openida_binary_get_data(disass->binary, NULL);
/* Préparation du suivi de la progression */
sum = 0;
for (i = 0; i < disass->count; i++)
{
g_binary_part_get_values(disass->parts[i], NULL, &len, NULL);
if (len > disass->binary->bin_length) continue;
sum += len;
}
done = 0;
k = 0;
for (i = 0; i < disass->count; i++)
{
g_binary_part_get_values(disass->parts[i], &pos, &len, &base);
if (len > disass->binary->bin_length) continue;
/* Décodage des instructions */
start = pos;
pos = 0;
while (pos < len)
{
addr = base + pos;
instr = g_arch_processor_decode_instruction(proc, &bin_data[start],
&pos, len, start, addr);
line = g_code_line_new(addr, instr, options);
g_rendering_line_add_to_lines(&result, line);
/* Ajout des prototypes de fonctions */
for (; k < count; k++)
{
routine_offset = g_binary_routine_get_address(routines[k]);
if (routine_offset > addr) break;
routine_desc = g_binary_routine_to_string(routines[k]);
line = g_comment_line_new(routine_offset, routine_desc, options);
g_rendering_line_insert_into_lines(&result, line, true);
free(routine_desc);
}
if (pos < len)
gtk_extended_status_bar_update_activity(statusbar, id, (done + pos) * 1.0 / sum);
}
done += len;
gtk_extended_status_bar_update_activity(statusbar, id, done * 1.0 / sum);
#if 0
/* Ajout des prototypes de fonctions */
printf("BASE == 0x%08llx\n", base);
for (; k < count; k++)
{
routine_offset = g_binary_routine_get_address(routines[k]);
if (!(base <= routine_offset && routine_offset < (base + len))) continue;
routine_desc = g_binary_routine_to_string(routines[k]);
line = g_comment_line_new(routine_offset, routine_desc, options);
g_rendering_line_insert_into_lines(&result, line, true);
free(routine_desc);
}
#endif
}
return result;
}
/******************************************************************************
* *
* Paramètres : lines = lignes de rendu à relier. *
* routines = prototypes existants à insérer. *
* count = quantité de ces prototypes. *
* statusbar = barre de statut avec progression à mettre à jour.*
* id = identifiant du message affiché à l'utilisateur. *
* *
* Description : Etablit les liens entres les différentes lignes de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void establish_links_between_lines(GRenderingLine *lines, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, guint id)
{
size_t i; /* Boucle de parcours */
vmpa_t start; /* Adresse de départ */
vmpa_t end; /* Adresse de fin */
GRenderingLine *iter; /* Boucle de parcours */
GArchInstruction *instr; /* Instruction à ausculter */
vmpa_t addr; /* Adresse référencée */
InstructionLinkType type; /* Type de référence */
GRenderingLine *target; /* Ligne visée par la référence*/
for (i = 0; i < count; i++)
{
start = g_binary_routine_get_address(routines[i]);
end = start + g_binary_routine_get_size(routines[i]);
for (iter = g_rendering_line_find_by_address(lines, NULL, start);
iter != NULL;
iter = g_rendering_line_get_next_iter(lines, iter, NULL))
{
/* Si on sort de la zone... */
if (get_rendering_line_address(iter) >= end) break;
/* On ne traite que du code ici ! */
if (!G_IS_CODE_LINE(iter)) continue;
instr = g_code_line_get_instruction(G_CODE_LINE(iter));
type = g_arch_instruction_get_link(instr, &addr);
switch (type)
{
case ILT_NONE:
break;
case ILT_JUMP:
target = g_rendering_line_find_by_address(lines, NULL, addr);
if (target != NULL)
g_rendering_line_link_with(iter, target, type);
break;
case ILT_JUMP_IF_FALSE:
break;
case ILT_JUMP_IF_TRUE:
target = g_rendering_line_find_by_address(lines, NULL, addr);
if (target != NULL)
{
g_rendering_line_link_with(iter, target, type);
target = g_rendering_line_get_next_iter(lines, iter, NULL);
if (target != NULL)
g_rendering_line_link_with(iter, target, ILT_JUMP_IF_FALSE);
}
break;
case ILT_CALL:
target = g_rendering_line_find_by_address(lines, NULL, addr);
if (target != NULL)
g_rendering_line_link_with(iter, target, type);
break;
}
}
gtk_extended_status_bar_update_activity(statusbar, id, (i + 1) * 1.0 / count);
}
}
/******************************************************************************
* *
* Paramètres : lines = lignes de rendu à parcourir. *
* routines = prototypes existants à insérer. *
* count = quantité de ces prototypes. *
* statusbar = barre de statut avec progression à mettre à jour.*
* id = identifiant du message affiché à l'utilisateur. *
* *
* Description : S'assure que toutes les routines ont une taille définie. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void limit_all_routines(GRenderingLine *lines, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, guint id)
{
size_t i; /* Boucle de parcours */
vmpa_t *starts; /* Adresses de départ */
off_t *lengths; /* Tailles des routines */
GRenderingLine *line; /* Ligne de départ / d'arrivée */
vmpa_t start; /* Adresse de début de routine */
vmpa_t last; /* Meilleur dernière adresse */
GArchInstruction *instr; /* Instruction à ausculter */
off_t length; /* Taille du code */
if (count == 0) return;
starts = (vmpa_t *)calloc(count, sizeof(vmpa_t));
lengths = (off_t *)calloc(count, sizeof(off_t));
for (i = 0; i < count; i++)
{
starts[i] = g_binary_routine_get_address(routines[i]);
lengths[i] = g_binary_routine_get_size(routines[i]);
gtk_extended_status_bar_update_activity(statusbar, id, (i + 1) * 1.0 / (count * 2));
}
for (i = 0; i < count; i++)
{
if (lengths[i] > 0) continue;
start = g_binary_routine_get_address(routines[i]);
line = g_rendering_line_find_by_address(lines, NULL, start);
/* Si le symbole est hors du code analysé (routine de PLT par exemple) */
if (line == NULL) continue;
last = find_best_ending_address_for_routine(line, i, starts, lengths, count);
line = g_rendering_line_find_by_address(lines, NULL, last);
line = g_rendering_line_loop_for_code(line, NULL);
instr = g_code_line_get_instruction(G_CODE_LINE(line));
g_arch_instruction_get_location(instr, NULL, &length, NULL);
lengths[i] = last - start + length;
g_binary_routine_set_size(routines[i], lengths[i]);
gtk_extended_status_bar_update_activity(statusbar, id, (i + 1 + count) * 1.0 / (count * 2));
}
free(starts);
free(lengths);
}
/******************************************************************************
* *
* Paramètres : line = ligne de départ du parcours. *
* index = indice de la routine traitée dans la liste. *
* starts = adresse de départ des autres routines. *
* lengths = taille des différentes routines, valides ou nulles.*
* count = quantité de routines présentes. *
* *
* Description : Cherche l'adresse de fin d'une routine. *
* *
* Retour : Plus grande adresse de dernière instruction de routine. *
* *
* Remarques : - *
* *
******************************************************************************/
static vmpa_t find_best_ending_address_for_routine(GRenderingLine *line, size_t index, const vmpa_t *starts, const off_t *lengths, size_t count)
{
vmpa_t result; /* Haute adresse à remonter */
GRenderingLine *iter; /* Boucle de parcours #1 */
vmpa_t candidate; /* Candidat potentiel */
size_t i; /* Boucle de parcours #2 */
GArchInstruction *instr; /* Instruction à ausculter */
result = starts[index];
for (iter = line; iter != NULL; iter = g_rendering_line_get_next_iter(line, iter, NULL))
{
if (!G_IS_CODE_LINE(iter)) continue;
candidate = get_rendering_line_address(iter);
/* Regarde si on n'empiète pas sur une autre routine */
for (i = 0; i < count; i++)
{
if (i == index) continue;
if (starts[i] <= candidate && candidate < (starts[i] + lengths[i]))
break;
}
if (i != count) break;
else result = candidate;
/* Retour de fonction ? */
instr = g_code_line_get_instruction(G_CODE_LINE(iter));
if (g_arch_instruction_is_return(instr)) break;
}
return result;
}
/* Indique le type défini pour une description de fichier binaire. */
G_DEFINE_TYPE(GOpenidaBinary, g_openida_binary, G_TYPE_OBJECT);
/******************************************************************************
* *
* Paramètres : klass = classe à initialiser. *
* *
* Description : Initialise la classe des descriptions de fichier binaire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_openida_binary_class_init(GOpenidaBinaryClass *klass)
{
g_signal_new("disassembly-done",
G_TYPE_OPENIDA_BINARY,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(GOpenidaBinaryClass, disassembly_done),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
/******************************************************************************
* *
* Paramètres : binary = instance à initialiser. *
* *
* Description : Initialise une description de fichier binaire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_openida_binary_init(GOpenidaBinary *binary)
{
/* FIXME : à replacer ailleurs */
g_openida_binary_add_break_group(binary, _("default"));
}
/******************************************************************************
* *
* 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 : - *
* *
******************************************************************************/
GOpenidaBinary *g_openida_binary_new_from_file(const char *filename)
{
GOpenidaBinary *result; /* Adresse à retourner */
result = g_object_new(G_TYPE_OPENIDA_BINARY, NULL);
log_variadic_message(LMT_PROCESS, _("Opening '%s' file..."), filename);
result->filename = strdup(filename);
result->bin_data = map_binary_file(filename, &result->bin_length);
if (result->bin_data == NULL) goto lbf_error;
result->format = G_EXE_FORMAT(load_new_format(FMT_EXEC, result->bin_data, result->bin_length));
if (result->format == NULL)
{
log_simple_message(LMT_INFO, _("Unknown binary format"));
goto lbf_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;
}
result->lines = build_binary_prologue(filename, result->bin_data, result->bin_length);
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);
g_rendering_options_show_address(result->options, MRD_GRAPH, true);
g_rendering_options_show_code(result->options, MRD_GRAPH, false);
return result;
lbf_error:
//unload_binary_file(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 : - *
* *
******************************************************************************/
GOpenidaBinary *g_openida_binary_new_from_xml(xmlXPathContextPtr context, const char *path)
{
GOpenidaBinary *result; /* Adresse à retourner */
size_t access_len; /* Taille d'un chemin interne */
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 */
off_t offset; /* Position de cette partie */
vmpa_t addr; /* Adresse correspondante */
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_openida_binary_new_from_file(filename);
free(filename);
}
if (result == NULL) return NULL;
/* Parties à désassembler : default */
access = strdup(path);
access = stradd(access, "/BinParts/Default/Part");
xobjects = get_node_xpath_object(context, access);
for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobjects); i++)
{
part = g_binary_part_load_from_xml(NODE_FROM_PATH_OBJ(xobjects, i));
if (part != NULL)
{
g_binary_part_get_values(part, &offset, NULL, NULL);
if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(result->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 *));
result->parts[BPM_DEFAULT][result->parts_count[BPM_DEFAULT] - 1] = part;
}
}
if(xobjects != NULL) /* FIXME */
xmlXPathFreeObject(xobjects);
free(access);
qsort(result->parts[BPM_DEFAULT], result->parts_count[BPM_DEFAULT],
sizeof(GBinPart *), g_binary_part_compare);
/* Parties à désassembler : routines */
access = strdup(path);
access = stradd(access, "/BinParts/Routines/Part");
xobjects = get_node_xpath_object(context, access);
for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobjects); i++)
{
part = g_binary_part_load_from_xml(NODE_FROM_PATH_OBJ(xobjects, i));
if (part != NULL)
{
g_binary_part_get_values(part, &offset, NULL, NULL);
if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(result->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 *));
result->parts[BPM_ROUTINES][result->parts_count[BPM_ROUTINES] - 1] = part;
}
}
if(xobjects != NULL) /* FIXME */
xmlXPathFreeObject(xobjects);
free(access);
qsort(result->parts[BPM_ROUTINES], result->parts_count[BPM_ROUTINES],
sizeof(GBinPart *), g_binary_part_compare);
/* Parties à désassembler : utilisateur */
access = strdup(path);
access = stradd(access, "/BinParts/User/Part");
xobjects = get_node_xpath_object(context, access);
for (i = 0; i < XPATH_OBJ_NODES_COUNT(xobjects); i++)
{
part = g_binary_part_load_from_xml(NODE_FROM_PATH_OBJ(xobjects, i));
if (part != NULL)
{
g_binary_part_get_values(part, &offset, NULL, NULL);
if (!g_exe_format_translate_offset_into_address(G_EXE_FORMAT(result->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 *));
result->parts[BPM_USER][result->parts_count[BPM_USER] - 1] = part;
}
}
if(xobjects != NULL) /* FIXME */
xmlXPathFreeObject(xobjects);
free(access);
qsort(result->parts[BPM_USER], result->parts_count[BPM_USER],
sizeof(GBinPart *), g_binary_part_compare);
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 : - *
* *
******************************************************************************/
bool g_openida_binary_save(const GOpenidaBinary *binary, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path)
{
bool result; /* Bilan à faire remonter */
char *access; /* Chemin d'accès à un élément */
xmlNodePtr node; /* Point d'insertion XML */
size_t i; /* Boucle de parcours */
result = true;
/* 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);
access = stradd(access, "/BinParts/Default");
node = ensure_node_exist(xdoc, context, access);
free(access);
for (i = 0; i < binary->parts_count[BPM_DEFAULT] && result; i++)
result &= g_binary_part_save_to_xml(binary->parts[BPM_DEFAULT][i], xdoc, node);
}
if (binary->parts_count[BPM_ROUTINES] > 0)
{
access = strdup(path);
access = stradd(access, "/BinParts/Routines");
node = ensure_node_exist(xdoc, context, access);
free(access);
for (i = 0; i < binary->parts_count[BPM_ROUTINES] && result; i++)
result &= g_binary_part_save_to_xml(binary->parts[BPM_ROUTINES][i], xdoc, node);
}
if (binary->parts_count[BPM_USER] > 0)
{
access = strdup(path);
access = stradd(access, "/BinParts/User");
node = ensure_node_exist(xdoc, context, access);
free(access);
for (i = 0; i < binary->parts_count[BPM_USER] && result; i++)
result &= g_binary_part_save_to_xml(binary->parts[BPM_USER][i], xdoc, node);
}
return result;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* parts = liste des zones binaires à analyser. *
* model = modèle de sélection des zones. *
* count = quantité de zones listées. *
* *
* Description : Définit les parties de binaire à analyser. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_openida_binary_set_parts(GOpenidaBinary *binary, BinaryPartModel model, GBinPart **parts, size_t count)
{
qsort(parts, count, sizeof(GBinPart *), g_binary_part_compare);
binary->parts[model] = parts;
binary->parts_count[model] = count;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* model = modèle de sélection des zones. [OUT] *
* count = quantité de zones listées. [OUT] *
* *
* Description : Fournit les parties de binaire analysées. *
* *
* Retour : Zones binaires à analyser. *
* *
* Remarques : - *
* *
******************************************************************************/
GBinPart ***g_openida_binary_get_parts(const GOpenidaBinary *binary, BinaryPartModel *model, size_t **count)
{
*model = binary->model;
*count = binary->parts_count;
return binary->parts;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à traiter. *
* *
* Description : Lance l'analyse d'un élément binaire chargé. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_openida_binary_analyse(GOpenidaBinary *binary)
{
GWorkQueue *queue; /* Gestionnaire de différés */
GBinPart **parts; /* Parties d'élément binaire */
size_t parts_count; /* Nombre de ces parties */
GDelayedDisassembly *disass; /* Désassemblage à mener */
queue = get_work_queue();
if (binary->parts_count[BPM_ROUTINES] > 0)
binary->model = BPM_ROUTINES;
if (binary->parts[binary->model] != NULL)
{
parts = binary->parts[binary->model];
parts_count = binary->parts_count[binary->model];
}
else
{
if (binary->parts[BPM_DEFAULT] != NULL)
{
parts = binary->parts[BPM_DEFAULT];
parts_count = binary->parts_count[BPM_DEFAULT];
}
else
{
parts = g_exe_format_get_parts(binary->format, &parts_count);
qsort(parts, parts_count, sizeof(GBinPart *), g_binary_part_compare);
}
}
disass = g_delayed_disassembly_new(binary, parts, parts_count);
g_signal_connect(disass, "work-completed",
G_CALLBACK(ack_completed_disassembly), binary);
g_work_queue_schedule_work(queue, G_DELAYED_WORK(disass));
}
/******************************************************************************
* *
* 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. *
* *
* Description : Fournit le fichier correspondant à l'élément binaire. *
* *
* Retour : Nom de fichier avec chemin absolu. *
* *
* Remarques : - *
* *
******************************************************************************/
const char *g_openida_binary_get_filename(const GOpenidaBinary *binary)
{
return binary->filename;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* length = taille en octets des données chargées. [OUT] *
* *
* Description : Fournit les détails du contenu binaire chargé en mémoire. *
* *
* Retour : Pointeur vers le début des données. *
* *
* Remarques : - *
* *
******************************************************************************/
bin_t *g_openida_binary_get_data(const GOpenidaBinary *binary, off_t *length)
{
if (length != NULL)
*length = binary->bin_length;
return binary->bin_data;
}
/******************************************************************************
* *
* Paramètres : binary = élément binaire à consulter. *
* *
* Description : Fournit le format de fichier reconnu dans le contenu binaire.*
* *
* Retour : Adresse du format reconnu. *
* *
* Remarques : - *
* *
******************************************************************************/
GExeFormat *g_openida_binary_get_format(const GOpenidaBinary *binary)
{
return binary->format;
}
/******************************************************************************
* *
* 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 : 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 : filename = nom du fichier chargé. *
* data = données en mémoire pour l'empreinte. *
* length = quantité de données à prendre en compte. *
* *
* Description : Construit la description d'introduction du désassemblage. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
GRenderingLine *build_binary_prologue(const char *filename, const uint8_t *data, off_t length)
{
GRenderingLine *result; /* Contenu à renvoyer */
size_t len; /* Taille du texte */
char *content; /* Contenu textuel d'une ligne */
GRenderingLine *line; /* Représentation à ajouter */
GChecksum *checksum; /* Calcul de l'empreinte */
const gchar *hex; /* Valeur hexadécimale du SHA */
result = NULL;/* FIXME DL_LIST_HEAD_INIT( **/
line = g_prologue_line_new("Disassembly generated by OpenIDA");
g_rendering_line_add_to_lines(&result, line);
line = g_prologue_line_new("OpenIDA is free software - © 2008-2010 Cyrille Bagard");
g_rendering_line_add_to_lines(&result, line);
line = g_prologue_line_new("");
g_rendering_line_add_to_lines(&result, line);
/* Fichier */
len = strlen(_("File: ")) + strlen(filename);
content = (char *)calloc(len + 1, sizeof(char));
snprintf(content, len + 1, "%s%s", _("File: "), filename);
line = g_prologue_line_new(content);
g_rendering_line_add_to_lines(&result, line);
free(content);
/* Checksum SHA256 */
checksum = g_checksum_new(G_CHECKSUM_SHA256);
g_checksum_update(checksum, data, length);
hex = g_checksum_get_string(checksum);
len = strlen(_("Sha256: ")) + strlen(hex);
content = (char *)calloc(len + 1, sizeof(char));
snprintf(content, len + 1, "%s%s", _("Sha256: "), hex);
g_checksum_free(checksum);
line = g_prologue_line_new(content);
g_rendering_line_add_to_lines(&result, line);
free(content);
line = g_prologue_line_new("");
g_rendering_line_add_to_lines(&result, line);
line = g_prologue_line_new("");
g_rendering_line_add_to_lines(&result, line);
return result;
}
/******************************************************************************
* *
* Paramètres : disass = travail de désassemblage mené à bien. *
* binary = représentation de binaire à l'origine de l'opérat°. *
* *
* Description : Acquitte la fin d'un désasemblage différé et complet. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void ack_completed_disassembly(GDelayedDisassembly *disass, GOpenidaBinary *binary)
{
GRenderingLine *line; /* "Première" ligne de rendu */
GPluginModule **pglist; /* Liste de greffons */
size_t pgcount; /* Taille de cette liste */
size_t i; /* Boucle de parcours */
g_rendering_line_merge(&binary->lines, &disass->lines);
line = g_rendering_line_find_by_address(disass->lines, NULL,
g_exe_format_get_entry_point(binary->format));
if (line != NULL) g_rendering_line_add_flag(line, RLF_ENTRY_POINT);
/* Action post-désassemblage */
pglist = get_all_plugins_for_action(PGA_CODE_PROCESS, &pgcount);
if (pgcount > 0)
{
for (i = 0; i < pgcount; i++)
g_plugin_module_execute_action_on_binary(pglist[i], binary, PGA_CODE_PROCESS);
free(pglist);
}
/* On réintègre le flot premier */
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);
}