diff options
| -rw-r--r-- | ChangeLog | 22 | ||||
| -rw-r--r-- | src/analysis/binary.c | 130 | ||||
| -rw-r--r-- | src/analysis/line.c | 45 | ||||
| -rw-r--r-- | src/analysis/line.h | 3 | ||||
| -rw-r--r-- | src/analysis/prototype.c | 53 | ||||
| -rw-r--r-- | src/analysis/prototype.h | 6 | ||||
| -rw-r--r-- | src/arch/instruction-int.h | 4 | ||||
| -rw-r--r-- | src/arch/instruction.c | 19 | ||||
| -rw-r--r-- | src/arch/instruction.h | 4 | ||||
| -rw-r--r-- | src/arch/x86/instruction.c | 22 | ||||
| -rw-r--r-- | src/format/elf/symbol.c | 9 |
11 files changed, 309 insertions, 8 deletions
@@ -1,3 +1,25 @@ +09-07-18 Cyrille Bagard <nocbos@gmail.com> + + * src/analysis/binary.c: + Compute the end of routines with no limit. + + * src/analysis/line.c: + * src/analysis/line.h: + Look for a code line in a list of lines. + + * src/analysis/prototype.c: + * src/analysis/prototype.h: + Compare routines for qsort(). + + * src/arch/instruction.c: + * src/arch/instruction.h: + * src/arch/instruction-int.h: + * src/arch/x86/instruction.c: + Add a function which tells if an instruction is a return from a call. + + * src/format/elf/symbol.c: + Clean the code. Only match with real functions when loading symbols. + 09-07-16 Cyrille Bagard <nocbos@gmail.com> * src/gtkext/gtkgraphview.c: diff --git a/src/analysis/binary.c b/src/analysis/binary.c index 09b7212..396dbe0 100644 --- a/src/analysis/binary.c +++ b/src/analysis/binary.c @@ -91,6 +91,12 @@ void disassemble_openida_binary(openida_binary *); /* Etablit les liens entres les différentes lignes de code. */ void establish_links_in_openida_binary(const openida_binary *); +/* S'assure que toutes les routines ont une taille définie. */ +void limit_all_routines_in_openida_binary(const openida_binary *); + +/* Cherche l'adresse de fin d'une routine. */ +vmpa_t find_best_ending_address_for_routine(GRenderingLine *, size_t, const vmpa_t *, const off_t *, size_t); + /****************************************************************************** @@ -629,6 +635,7 @@ void disassemble_openida_binary(openida_binary *binary) } establish_links_in_openida_binary(binary); + limit_all_routines_in_openida_binary(binary); line = g_rendering_line_find_by_address(binary->lines, NULL, get_exe_entry_point(binary->format)); if (line != NULL) g_rendering_line_add_flag(line, RLF_ENTRY_POINT); @@ -733,3 +740,126 @@ void establish_links_in_openida_binary(const openida_binary *binary) } } + + +/****************************************************************************** +* * +* Paramètres : binary = binaire dont le contenu est à lier. * +* * +* Description : S'assure que toutes les routines ont une taille définie. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void limit_all_routines_in_openida_binary(const openida_binary *binary) +{ + GBinRoutine **routines; /* Liste des routines trouvées */ + size_t routines_count; /* Nombre de ces routines */ + 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 */ + + routines = get_all_exe_routines(binary->format, &routines_count); + if (routines_count == 0) return; + + qsort(routines, routines_count, sizeof(GBinRoutine *), g_binary_routine_rcompare); + + starts = (vmpa_t *)calloc(routines_count, sizeof(vmpa_t)); + lengths = (off_t *)calloc(routines_count, sizeof(off_t)); + + for (i = 0; i < routines_count; i++) + { + starts[i] = g_binary_routine_get_address(routines[i]); + lengths[i] = g_binary_routine_get_size(routines[i]); + } + + for (i = 0; i < routines_count; i++) + { + if (lengths[i] > 0) continue; + + start = g_binary_routine_get_address(routines[i]); + line = g_rendering_line_find_by_address(binary->lines, NULL, start); + + last = find_best_ending_address_for_routine(line, i, starts, lengths, routines_count); + + line = g_rendering_line_find_by_address(binary->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]); + + } + + 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 : - * +* * +******************************************************************************/ + +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; + +} diff --git a/src/analysis/line.c b/src/analysis/line.c index 740673a..cd54db0 100644 --- a/src/analysis/line.c +++ b/src/analysis/line.c @@ -34,6 +34,7 @@ #include <sys/param.h> +#include "line_code.h" #include "../common/dllist.h" @@ -732,3 +733,47 @@ GRenderingLine *g_rendering_line_find_by_address(GRenderingLine *lines, const GR return result; } + + +/****************************************************************************** +* * +* Paramètres : start = première ligne de l'ensemble à parcourir. * +* last = dernière élément imposé du parcours ou NULL. * +* * +* Description : Donne la première ligne de code correspondant à une adresse. * +* * +* Retour : Ligne de code pour l'adresse donnée, NULL si aucune trouvée. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GRenderingLine *g_rendering_line_loop_for_code(GRenderingLine *start, const GRenderingLine *last) +{ + GRenderingLine *result; /* Trouvaille à retourner */ + vmpa_t reference; /* Adresse à conserver */ + + result = start; + reference = start->offset; + + lines_list_for_each(result, start) + { + if (G_IS_CODE_LINE(result)) break; + + if (result->offset != reference) + { + result = NULL; + break; + } + + if (result == last) + { + result = NULL; + break; + } + + } + + return result; + +} diff --git a/src/analysis/line.h b/src/analysis/line.h index 5f22db2..621ab60 100644 --- a/src/analysis/line.h +++ b/src/analysis/line.h @@ -131,6 +131,9 @@ GRenderingLine *g_rendering_line_find_by_y(GRenderingLine *, const GRenderingLin /* Recherche une ligne d'après sa position en mémoire/physique. */ GRenderingLine *g_rendering_line_find_by_address(GRenderingLine *, const GRenderingLine *, vmpa_t); +/* Donne la première ligne de code correspondant à une adresse. */ +GRenderingLine *g_rendering_line_loop_for_code(GRenderingLine *, const GRenderingLine *); + #endif /* _ANALYSIS_LINE_H */ diff --git a/src/analysis/prototype.c b/src/analysis/prototype.c index d68a485..72ee809 100644 --- a/src/analysis/prototype.c +++ b/src/analysis/prototype.c @@ -161,6 +161,59 @@ void g_binary_routine_finalize(GBinRoutine *routine) } #endif + +/****************************************************************************** +* * +* Paramètres : a = premières informations à consulter. * +* b = secondes informations à consulter. * +* * +* Description : Etablit la comparaison ascendante entre deux routines. * +* * +* Retour : Bilan : -1 (a < b), 0 (a == b) ou 1 (a > b). * +* * +* Remarques : - * +* * +******************************************************************************/ + +int g_binary_routine_compare(const GBinRoutine **a, const GBinRoutine **b) +{ + int result; /* Bilan à renvoyer */ + + if ((*a)->addr < (*b)->addr) result = -1; + else if((*a)->addr > (*b)->addr) result = 1; + else result = 0; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : a = premières informations à consulter. * +* b = secondes informations à consulter. * +* * +* Description : Etablit la comparaison descendante entre deux routines. * +* * +* Retour : Bilan : -1 (a < b), 0 (a == b) ou 1 (a > b). * +* * +* Remarques : - * +* * +******************************************************************************/ + +int g_binary_routine_rcompare(const GBinRoutine **a, const GBinRoutine **b) +{ + int result; /* Bilan à renvoyer */ + + if ((*a)->addr > (*b)->addr) result = -1; + else if((*a)->addr < (*b)->addr) result = 1; + else result = 0; + + return result; + +} + + /****************************************************************************** * * * Paramètres : routine = routine à mettre à jour. * diff --git a/src/analysis/prototype.h b/src/analysis/prototype.h index fe6d0a4..2a9439e 100644 --- a/src/analysis/prototype.h +++ b/src/analysis/prototype.h @@ -64,6 +64,12 @@ GType g_bin_routine_get_type(void); /* Crée une représentation de routine. */ GBinRoutine *g_binary_routine_new(void); +/* Etablit la comparaison ascendante entre deux routines. */ +int g_binary_routine_compare(const GBinRoutine **, const GBinRoutine **); + +/* Etablit la comparaison descendante entre deux routines. */ +int g_binary_routine_rcompare(const GBinRoutine **, const GBinRoutine **); + /* Définit la position physique / en mémoire d'une routine. */ void g_binary_routine_set_address(GBinRoutine *, vmpa_t); diff --git a/src/arch/instruction-int.h b/src/arch/instruction-int.h index 6ae0597..db6a3bf 100644 --- a/src/arch/instruction-int.h +++ b/src/arch/instruction-int.h @@ -36,6 +36,9 @@ typedef const char * (* get_instruction_text_fc) (const GArchInstruction *, cons /* Informe sur une éventuelle référence à une autre instruction. */ typedef InstructionLinkType (* get_instruction_link_fc) (const GArchInstruction *, vmpa_t *); +/* Indique si l'instruction correspond à un retour de fonction. */ +typedef bool (* is_instruction_return_fc) (const GArchInstruction *); + /* Définition générique d'une instruction d'architecture (instance) */ struct _GArchInstruction @@ -52,6 +55,7 @@ struct _GArchInstruction get_instruction_text_fc get_text; /* Texte humain équivalent */ get_instruction_link_fc get_link; /* Référence à une instruction */ + is_instruction_return_fc is_return; /* Retour de fonction ou pas ? */ }; diff --git a/src/arch/instruction.c b/src/arch/instruction.c index 69644dc..e0cea9f 100644 --- a/src/arch/instruction.c +++ b/src/arch/instruction.c @@ -321,3 +321,22 @@ InstructionLinkType g_arch_instruction_get_link(const GArchInstruction *instr, v return instr->get_link(instr, addr); } + + +/****************************************************************************** +* * +* Paramètres : instr = instruction à consulter. * +* * +* Description : Indique si l'instruction correspond à un retour de fonction. * +* * +* Retour : true si l'instruction est un 'return' quelconque ou false. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_arch_instruction_is_return(const GArchInstruction *instr) +{ + return instr->is_return(instr); + +} diff --git a/src/arch/instruction.h b/src/arch/instruction.h index b8be830..c0cb9f6 100644 --- a/src/arch/instruction.h +++ b/src/arch/instruction.h @@ -25,6 +25,7 @@ #define _ARCH_INSTRUCTION_H +#include <stdbool.h> #include <glib-object.h> #include <sys/types.h> @@ -90,6 +91,9 @@ char *g_arch_instruction_get_text(const GArchInstruction *, const exe_format *, /* Informe sur une éventuelle référence à une autre instruction. */ InstructionLinkType g_arch_instruction_get_link(const GArchInstruction *, vmpa_t *); +/* Indique si l'instruction correspond à un retour de fonction. */ +bool g_arch_instruction_is_return(const GArchInstruction *instr); + #endif /* _ARCH_INSTRUCTION_H */ diff --git a/src/arch/x86/instruction.c b/src/arch/x86/instruction.c index 0321e88..0af29c1 100644 --- a/src/arch/x86/instruction.c +++ b/src/arch/x86/instruction.c @@ -326,6 +326,8 @@ static const char *x86_get_instruction_text(const GX86Instruction *, const exe_f /* Informe sur une éventuelle référence à une autre instruction. */ static InstructionLinkType x86_get_instruction_link(const GX86Instruction *, vmpa_t *); +/* Indique si l'instruction correspond à un retour de fonction. */ +static bool x86_instruction_is_return(const GX86Instruction *); @@ -372,6 +374,7 @@ static void g_x86_instruction_init(GX86Instruction *instr) parent->get_text = (get_instruction_text_fc)x86_get_instruction_text; parent->get_link = (get_instruction_link_fc)x86_get_instruction_link; + parent->is_return = (is_instruction_return_fc)x86_instruction_is_return; } @@ -622,3 +625,22 @@ static InstructionLinkType x86_get_instruction_link(const GX86Instruction *instr return result; } + + +/****************************************************************************** +* * +* Paramètres : instr = instruction à consulter. * +* * +* Description : Indique si l'instruction correspond à un retour de fonction. * +* * +* Retour : true si l'instruction est un 'return' quelconque ou false. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool x86_instruction_is_return(const GX86Instruction *instr) +{ + return (instr->type == XOP_RET); + +} diff --git a/src/format/elf/symbol.c b/src/format/elf/symbol.c index 4fd56fe..35943e9 100644 --- a/src/format/elf/symbol.c +++ b/src/format/elf/symbol.c @@ -30,11 +30,6 @@ #include <string.h> -#include "../../arch/processor.h" /* FIXME : remove me ! */ -#include "../../arch/instruction.h" /* FIXME : remove me ! */ -#include "../../arch/instruction-int.h" /* FIXME : remove me ! */ - - #include "elf-int.h" #include "helper_mips.h" #include "section.h" @@ -254,9 +249,7 @@ bool load_elf_symbol_table_32(elf_format *format, const off_t *sym_start, const { memcpy(&symbol, &EXE_FORMAT(format)->content[iter], sizeof(Elf32_Sym)); - if (!(ELF32_ST_TYPE(symbol.st_info) == STT_FUNC - || (ELF32_ST_TYPE(symbol.st_info) == STT_NOTYPE - && ELF32_ST_BIND(symbol.st_info) == STB_GLOBAL))) continue; + if (!(ELF32_ST_TYPE(symbol.st_info) == STT_FUNC)) continue; if (symbol.st_value == 0) continue; |