/* OpenIDA - Outil d'analyse de fichiers binaires * delayed.c - gestion des actions d'analyse différées * * Copyright (C) 2009 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 "delayed.h" #include "line_code.h" #include "line_comment.h" #include "../common/dllist.h" #include "../format/format.h" #include "../glibext/delayed-int.h" #include "../gtkext/gtkextstatusbar.h" #include "../gtkext/iodamarshal.h" #ifndef _ # define _(str) (str) #endif /* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */ /* Ensembles binaires à désassembler (instance) */ struct _GDelayedDisassembly { GDelayedWork parent; /* A laisser en premier */ GOpenidaBinary *binary; /* Destinataire final */ GBinPart **parts; /* Parties binaires à traiter */ size_t count; /* Nombre de ces parties */ }; /* Ensembles binaires à désassembler (classe) */ struct _GDelayedDisassemblyClass { GDelayedWorkClass parent; /* A laisser en premier */ }; /* 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 *); /* ------------------------- GESTION DES ANALYSES DIFFEREES ------------------------- */ /* Gestionnaire des analyses différées (instance) */ struct _GDisassManager { GWorkQueue parent; /* A laisser en premier */ GtkExtStatusBar *statusbar; /* Barre de statut principale */ }; /* Gestionnaire des analyses différées (classe) */ struct _GDisassManagerClass { GWorkQueueClass parent; /* A laisser en premier */ /* Signaux */ void (* disassembly_completed) (GDisassManager *, GOpenidaBinary *, GRenderingLine *); }; /* Initialise la classe des gestionnaires d'analyses différées. */ static void g_disassembly_manager_class_init(GDisassManagerClass *); /* Initialise un gestionnaire d'analyses différées. */ static void g_disassembly_manager_init(GDisassManager *); /* Crée un gestionnaire d'analyses différées. */ static GDisassManager *g_disassembly_manager_new(GObject *); /* Assure le désassemblage en différé. */ static void process_disassemblies(GDisassManager *, GDelayedDisassembly *); /* 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); /* ---------------------------------------------------------------------------------- */ /* 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) { } /****************************************************************************** * * * 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 : - * * * ******************************************************************************/ 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; } /* ---------------------------------------------------------------------------------- */ /* GESTION DES ANALYSES DIFFEREES */ /* ---------------------------------------------------------------------------------- */ /* Indique le type défini pour le gestionnaire des analyses différées. */ G_DEFINE_TYPE(GDisassManager, g_disassembly_manager, G_TYPE_WORK_QUEUE); /****************************************************************************** * * * Paramètres : klass = classe à initialiser. * * * * Description : Initialise la classe des gestionnaires d'analyses différées. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_disassembly_manager_class_init(GDisassManagerClass *klass) { g_signal_new("disassembly-completed", G_TYPE_DISASS_MANAGER, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET(GDisassManagerClass, disassembly_completed), NULL, NULL, g_cclosure_user_marshal_VOID__OBJECT_OBJECT, G_TYPE_NONE, 2, G_TYPE_OPENIDA_BINARY, G_TYPE_RENDERING_LINE); } /****************************************************************************** * * * Paramètres : manager = instance à initialiser. * * * * Description : Initialise un gestionnaire d'analyses différées. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_disassembly_manager_init(GDisassManager *manager) { GWorkQueue *parent; /* Instance parente */ parent = G_WORK_QUEUE(manager); parent->process = (process_work_fc)process_disassemblies; } /****************************************************************************** * * * Paramètres : ref = espace de référencements global. * * * * Description : Crée un gestionnaire d'analyses différées. * * * * Retour : Gestionnaire mis en place ou NULL en cas d'échec. * * * * Remarques : - * * * ******************************************************************************/ static GDisassManager *g_disassembly_manager_new(GObject *ref) { GDisassManager *result; /* Adresse à retourner */ result = g_object_new(G_TYPE_DISASS_MANAGER, NULL); result->statusbar = g_object_get_data(ref, "statusbar"); return result; } /****************************************************************************** * * * Paramètres : manager = gestionnaire des actions à mener. * * disass = analyse à mener. * * * * Description : Assure le désassemblage en différé. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void process_disassemblies(GDisassManager *manager, GDelayedDisassembly *disass) { GBinRoutine **routines; /* Liste des routines trouvées */ size_t routines_count; /* Nombre de ces routines */ guint id; /* Identifiant de statut */ GRenderingLine *lines; /* Nouvelles lignes de rendu */ routines = g_binary_format_get_routines(G_BIN_FORMAT(g_openida_binary_get_format(disass->binary)), &routines_count); qsort(routines, routines_count, sizeof(GBinRoutine *), g_binary_routine_rcompare); /* Première étape */ id = gtk_extended_status_bar_push(manager->statusbar, _("Disassembling..."), true); lines = disassemble_binary_parts(disass, routines, routines_count, manager->statusbar, id); gtk_extended_status_bar_remove(manager->statusbar, id); /* Seconde étape */ id = gtk_extended_status_bar_push(manager->statusbar, _("Establishing links..."), true); establish_links_between_lines(lines, routines, routines_count, manager->statusbar, id); gtk_extended_status_bar_remove(manager->statusbar, id); /* Troisième étape */ id = gtk_extended_status_bar_push(manager->statusbar, _("Finding remaining limits..."), true); limit_all_routines(lines, routines, routines_count, manager->statusbar, id); gtk_extended_status_bar_remove(manager->statusbar, id); /* Fin */ g_signal_emit_by_name(manager, "disassembly-completed", disass->binary, lines); } /****************************************************************************** * * * 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); sum += len; } done = 0; for (i = 0; i < disass->count; i++) { g_binary_part_get_values(disass->parts[i], &pos, &len, &base); /* 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); 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); /* Ajout des prototypes de fonctions */ for (k = 0; 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); } } 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); 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; } /****************************************************************************** * * * Paramètres : manager = nouveau gestionnaire à mémoriser ou NULL. * * * * Description : Fournit le gestionnaire d'analyse en différé courant. * * * * Retour : Gestionnaire d'analyse en différé courant. * * * * Remarques : - * * * ******************************************************************************/ GDisassManager *_get_disassembly_manager(GDisassManager *manager) { static GDisassManager *result = NULL; /* Singleton à retourner */ if (manager != NULL) result = manager; return result; } /****************************************************************************** * * * Paramètres : ref = espace de référencements global. * * * * Description : Procède au chargement du gestionnaire d'analyse différées. * * * * Retour : true pour indiquer un chargement réussi, false sinon. * * * * Remarques : - * * * ******************************************************************************/ bool init_disassembly_manager(GObject *ref) { GDisassManager *manager; /* Singleton à mettre en place */ manager = g_disassembly_manager_new(ref); if (manager != NULL) _get_disassembly_manager(manager); return (manager != NULL); }