From 5b89c8369d2a26089f22be7c482e8254244ebc8c Mon Sep 17 00:00:00 2001 From: Cyrille Bagard Date: Sat, 2 Feb 2013 18:51:02 +0000 Subject: Closed some switch cases with a 'break' keyword. git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@336 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a --- ChangeLog | 31 ++++ plugins/androhelpers/switch.c | 46 ++++++ src/analysis/block-int.h | 5 + src/analysis/block.c | 21 +++ src/analysis/block.h | 3 + src/analysis/blocks/flow.c | 27 +++ src/analysis/blocks/virtual.c | 27 +++ src/analysis/decomp/il.c | 373 +++++++++++++++++++++++++++++++----------- src/analysis/disass/macro.c | 97 ++++++++++- src/arch/dalvik/decomp/if.c | 5 +- src/arch/dalvik/instruction.c | 12 +- src/decomp/instr/Makefile.am | 1 + src/decomp/instr/keyword.c | 162 ++++++++++++++++++ src/decomp/instr/keyword.h | 68 ++++++++ src/decomp/instr/switch.c | 11 +- 15 files changed, 768 insertions(+), 121 deletions(-) create mode 100644 src/decomp/instr/keyword.c create mode 100644 src/decomp/instr/keyword.h diff --git a/ChangeLog b/ChangeLog index 6c9b261..48a5414 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,34 @@ +13-02-02 Cyrille Bagard + + * plugins/androhelpers/switch.c: + Ensure that switch cases which share instructions have distinct blocks. + + * src/analysis/block.c: + * src/analysis/block.h: + * src/analysis/block-int.h: + * src/analysis/blocks/flow.c: + * src/analysis/blocks/virtual.c: + Provide leaf blocks of a group of blocks. + + * src/analysis/decomp/il.c: + Reorganize the code. Close some switch cases with a 'break' keyword. + + * src/analysis/disass/macro.c: + + * src/arch/dalvik/decomp/if.c: + * src/arch/dalvik/instruction.c: + Decompile more 'if' instructions. + + * src/decomp/instr/keyword.c: + * src/decomp/instr/keyword.h: + New entries: allow to insert the 'break' keyword in decompiled code. + + * src/decomp/instr/Makefile.am: + Add the 'keyword.[ch]' files to libdecompinstr_la_SOURCES. + + * src/decomp/instr/switch.c: + Typos. + 13-01-31 Cyrille Bagard * plugins/androhelpers/switch.c: diff --git a/plugins/androhelpers/switch.c b/plugins/androhelpers/switch.c index 0a1e488..3bb900f 100644 --- a/plugins/androhelpers/switch.c +++ b/plugins/androhelpers/switch.c @@ -42,6 +42,9 @@ static bool load_dex_switch(const GArchInstruction *, GArchInstruction *, const /* Lie les instructions selon les cas d'un aiguillage. */ static void link_all_switch_cases(GArchInstruction *, const dex_switch *, GArchInstruction *, vmpa_t, vmpa_t); +/* Prend en compte les absences de 'break' dans les cas. */ +static void ensure_each_case_has_its_block(GArchInstruction *, GArchInstruction *); + /* Insère des indications dans le texte humainement lisibles. */ static void mark_all_switch_cases(const GArchInstruction *, const dex_switch *, GArchInstruction *, const GLoadedBinary *, vmpa_t, vmpa_t); @@ -166,6 +169,7 @@ static void link_all_switch_cases(GArchInstruction *instr, const dex_switch *dsw imm = g_imm_operand_new_from_value(MDS_32_BITS_UNSIGNED, value); g_arch_instruction_link_with(instr, next, ILT_CASE_JUMP, imm); + ensure_each_case_has_its_block(next, instrs); } @@ -176,7 +180,49 @@ static void link_all_switch_cases(GArchInstruction *instr, const dex_switch *dsw next = g_arch_instruction_get_next_iter(instrs, instr, end); if (next != NULL) + { g_arch_instruction_link_with(instr, next, ILT_CASE_JUMP, NULL); + ensure_each_case_has_its_block(next, instrs); + } + +} + + +/****************************************************************************** +* * +* Paramètres : instr = instruction d'aiguillage rencontrée. * +* instrs = liste des instructions pour tout le binaire. * +* * +* Description : Prend en compte les absences de 'break' dans les cas. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void ensure_each_case_has_its_block(GArchInstruction *instr, GArchInstruction *instrs) +{ + GArchInstruction *prev; /* Instruction avant un cas */ + + /** + * La situation où un cas n'a pas de 'break' conduit à une fusion du corps + * du cas avec le corps du cas suivant (partie commune). + * La fin du premier cas n'ayant pas de saut enregistré, rien n'entraîne un + * lien logique, et donc une séparation des deux cas en blocs distincts. + * + * Cette procédure établit les vérifications nécessaires, et rétablit + * la logique des liens et des blocs en cas de besoin. + */ + + prev = g_arch_instruction_get_prev_iter(instrs, instr); + + if (prev != NULL + && !g_arch_instruction_has_destinations(prev) + && !g_arch_instruction_is_return(prev)) + { + g_arch_instruction_link_with(prev, instr, ILT_EXEC_FLOW, NULL); + } } diff --git a/src/analysis/block-int.h b/src/analysis/block-int.h index 419a8b0..069b50c 100644 --- a/src/analysis/block-int.h +++ b/src/analysis/block-int.h @@ -38,6 +38,10 @@ typedef bool (* visit_all_blocks_fc) (GInstrBlock *, instr_block_visitor_cb, voi /* Etablit la liste de tous les blocs présents. */ typedef void (* list_all_blocks_fc) (const GInstrBlock *, GInstrBlock ***, size_t *); +/* Etablit la liste de tous les blocs terminaux. */ +typedef void (* list_leafs_blocks_fc) (const GInstrBlock *, GInstrBlock ***, size_t *); + + /* Fournit les différents accès aux registres. */ //typedef const reg_access * (* list_regs_accesses_fc) (const GInstrBlock *, size_t *); @@ -51,6 +55,7 @@ struct _GInstrBlock find_by_addr_fc find_by_addr; /* Recherche par adresse */ visit_all_blocks_fc visit_blocks; /* Visite des différents blocs */ list_all_blocks_fc list_blocks; /* Liste de tous les blocs */ + list_leafs_blocks_fc list_leafs; /* Liste des blocs terminaux */ //list_regs_accesses_fc list_regs; /* Liste des accès registres */ GInstrBlock *links_block; /* Lieu des blocs attachés */ diff --git a/src/analysis/block.c b/src/analysis/block.c index 50d5644..d8d906a 100644 --- a/src/analysis/block.c +++ b/src/analysis/block.c @@ -202,6 +202,27 @@ void g_instr_block_list_all_blocks(const GInstrBlock *block, GInstrBlock ***list /****************************************************************************** * * +* Paramètres : block = bloc d'instructions à consulter. * +* list = ensemble de blocs à compléter. [OUT] * +* count = nombre de blocs au total. [OUT] * +* * +* Description : Etablit la liste de tous les blocs terminaux. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_instr_block_list_leafs_blocks(const GInstrBlock *block, GInstrBlock ***list, size_t *count) +{ + block->list_leafs(block, list, count); + +} + + +/****************************************************************************** +* * * Paramètres : block = bloc d'instructions à mettre à jour. * * links = bloc contenant les blocs liés au bloc. * * * diff --git a/src/analysis/block.h b/src/analysis/block.h index 7786ce5..d4e5a2b 100644 --- a/src/analysis/block.h +++ b/src/analysis/block.h @@ -74,6 +74,9 @@ bool g_instr_block_visit(GInstrBlock *, instr_block_visitor_cb, void *); /* Etablit la liste de tous les blocs présents. */ void g_instr_block_list_all_blocks(const GInstrBlock *, GInstrBlock ***, size_t *); +/* Etablit la liste de tous les blocs terminaux. */ +void g_instr_block_list_leafs_blocks(const GInstrBlock *, GInstrBlock ***, size_t *); + /* Définit l'ensemble contenant les blocs liés. */ void g_instr_block_set_links_block(GInstrBlock *, GInstrBlock *); diff --git a/src/analysis/blocks/flow.c b/src/analysis/blocks/flow.c index 4df729c..0b68a14 100644 --- a/src/analysis/blocks/flow.c +++ b/src/analysis/blocks/flow.c @@ -74,6 +74,9 @@ static bool g_flow_block_visit(GFlowBlock *, instr_block_visitor_cb, void *); /* Etablit la liste de tous les blocs présents. */ static void g_flow_block_list_all_blocks(const GFlowBlock *, GInstrBlock ***, size_t *); +/* Etablit la liste de tous les blocs terminaux. */ +static void g_flow_block_list_leafs_blocks(const GFlowBlock *, GInstrBlock ***, size_t *); + /* Prend note de l'usage d'un registre, au besoin. */ static void g_flow_block_memorize_access(GFlowBlock *, GArchRegister *, RegAccessType, vmpa_t); @@ -134,6 +137,7 @@ static void g_flow_block_init(GFlowBlock *block) parent->find_by_addr = (find_by_addr_fc)g_flow_block_find_by_addr; parent->visit_blocks = (visit_all_blocks_fc)g_flow_block_visit; parent->list_blocks = (list_all_blocks_fc)g_flow_block_list_all_blocks; + parent->list_leafs = (list_leafs_blocks_fc)g_flow_block_list_leafs_blocks; //parent->list_regs = (list_regs_accesses_fc)g_flow_block_list_regs_accesses; block->regs = g_raccess_list_new(); @@ -315,6 +319,29 @@ static void g_flow_block_list_all_blocks(const GFlowBlock *block, GInstrBlock ** /****************************************************************************** * * +* Paramètres : block = bloc d'instructions à consulter. * +* list = ensemble de blocs à compléter. [OUT] * +* count = nombre de blocs au total. [OUT] * +* * +* Description : Etablit la liste de tous les blocs terminaux. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_flow_block_list_leafs_blocks(const GFlowBlock *block, GInstrBlock ***list, size_t *count) +{ + (*list) = (GInstrBlock **)realloc(*list, ++(*count) * sizeof(GInstrBlock *)); + + (*list)[*count - 1] = G_INSTR_BLOCK(block); + +} + + +/****************************************************************************** +* * * Paramètres : block = bloc d'instructions à mettre à jour. * * reg = registre visé par l'opération. * * type = type d'accès à l'opérande. * diff --git a/src/analysis/blocks/virtual.c b/src/analysis/blocks/virtual.c index 42492e9..0cc6a0d 100644 --- a/src/analysis/blocks/virtual.c +++ b/src/analysis/blocks/virtual.c @@ -79,6 +79,9 @@ static bool g_virtual_block_visit(GVirtualBlock *, instr_block_visitor_cb, void /* Etablit la liste de tous les blocs présents. */ static void g_virtual_block_list_all_blocks(const GVirtualBlock *, GInstrBlock ***, size_t *); +/* Etablit la liste de tous les blocs terminaux. */ +static void g_virtual_block_list_leafs_blocks(const GVirtualBlock *, GInstrBlock ***, size_t *); + /* Fournit les différents accès aux registres. */ //static const reg_access *g_virtual_block_list_regs_accesses(const GVirtualBlock *, size_t *); @@ -133,6 +136,7 @@ static void g_virtual_block_init(GVirtualBlock *block) parent->find_by_addr = (find_by_addr_fc)g_virtual_block_find_by_addr; parent->visit_blocks = (visit_all_blocks_fc)g_virtual_block_visit; parent->list_blocks = (list_all_blocks_fc)g_virtual_block_list_all_blocks; + parent->list_leafs = (list_leafs_blocks_fc)g_virtual_block_list_leafs_blocks; //parent->list_regs = (list_regs_accesses_fc)g_virtual_block_list_regs_accesses; } @@ -300,6 +304,29 @@ static void g_virtual_block_list_all_blocks(const GVirtualBlock *block, GInstrBl } + +/****************************************************************************** +* * +* Paramètres : block = bloc d'instructions à consulter. * +* list = ensemble de blocs à compléter. [OUT] * +* count = nombre de blocs au total. [OUT] * +* * +* Description : Etablit la liste de tous les blocs terminaux. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_virtual_block_list_leafs_blocks(const GVirtualBlock *block, GInstrBlock ***list, size_t *count) +{ + if (block->children_count > 0) + g_instr_block_list_leafs_blocks(block->children[block->children_count - 1], list, count); + +} + + #if 0 /****************************************************************************** * * diff --git a/src/analysis/decomp/il.c b/src/analysis/decomp/il.c index f241e46..9e235a6 100644 --- a/src/analysis/decomp/il.c +++ b/src/analysis/decomp/il.c @@ -24,11 +24,15 @@ #include "il.h" +#include + + #include "../blocks/flow.h" #include "../blocks/virtual.h" #include "../../decomp/expr/block.h" #include "../../decomp/expr/immediate.h" #include "../../decomp/instr/ite.h" +#include "../../decomp/instr/keyword.h" #include "../../decomp/instr/switch.h" @@ -67,6 +71,20 @@ static GDecInstruction *decompiled_basic_block(GInstrBlock *, GDecContext *); +/* --------------------------- DECOMPILATIONS SPECIFIQUES --------------------------- */ + + +/* Procède à la décompilation des éléments d'un 'if then else'. */ +static void build_ite_branches(GITEInstruction *, GFlowBlock *, GDecContext *); + +/* Termine le traitement d'un cas de 'switch'. */ +static void close_case_decomp_instructions(GDecInstruction *, GInstrBlock *, GArchInstruction **, size_t, size_t); + +/* Procède à la décompilation des éléments d'un 'switch'. */ +static void build_switch_branches(GSwitchInstruction *, GFlowBlock *, GDecContext *); + + + /* ---------------------------------------------------------------------------------- */ /* GESTION DES CONTEXTES DE DECOMPILATION */ /* ---------------------------------------------------------------------------------- */ @@ -328,27 +346,12 @@ static GDecInstruction *decompiled_instructions_block(GFlowBlock *block, GDecCon { GArchInstruction *instrs; /* Liste d'instructions natives*/ GArchInstruction *first; /* Première instruction du lot */ - GArchInstruction *last; /* Dernière instruction du lot */ vmpa_t max; /* Adresse de fin du bloc */ GArchInstruction *iter; /* Boucle de parcours #1 */ GDecInstruction *decomp; /* Dernier résultat de décomp. */ - GInstrBlock *sub_parent; /* Groupe des sous-branches */ - GHashTable *sub_shared; /* Allocations communes */ - GDecContext *sub_ctx; /* Sous-contexte pour branche */ - GDecInstruction *true_dinstr; /* Décompilation 'cond vraie' */ - GDecInstruction *false_dinstr; /* Décompilation 'cond fausse' */ - GArchInstruction *next; /* Instruction de branchement */ - vmpa_t next_addr; /* Adresse de cette instruct° */ - GInstrBlock *next_block; /* Sous-bloc basique direct */ - GArchInstruction **dests; /* Instr. visée par une autre */ - link_extra_info *info; /* Compléments pour les liens */ - size_t dcount; /* Nombre de liens de dest. */ - size_t i; /* Boucle de parcours #2 */ - GDecInstruction *case_dinstr; /* Décompilation 'case' */ - GDecExpression *case_value; /* Valeur d'aiguillage */ instrs = g_flow_block_get_all_instructions_list(block); - g_flow_block_get_boundary(block, &first, &last); + g_flow_block_get_boundary(block, &first, NULL); g_flow_block_get_boundary_addresses(block, NULL, &max); max++; @@ -366,92 +369,11 @@ static GDecInstruction *decompiled_instructions_block(GFlowBlock *block, GDecCon /* if ... then ... else ... */ if (G_IS_ITE_INSTRUCTION(decomp)) - { - sub_parent = g_instr_block_get_links_block(G_INSTR_BLOCK(block)); - sub_shared = g_hash_table_new_full((GHashFunc)g_arch_register_hash, - (GEqualFunc)g_arch_register_equal, - g_object_unref, g_object_unref); - - true_dinstr = NULL; - - next = g_arch_instruction_get_given_destination(last, ILT_JUMP_IF_TRUE); - if (next != NULL) - { - g_arch_instruction_get_location(next, NULL, NULL, &next_addr); - next_block = g_instr_block_find_by_addr(sub_parent, next_addr, false); - - if (next_block != NULL) - { - sub_ctx = create_new_context_for_sub_block(ctx, next_block, sub_shared); - true_dinstr = decompiled_basic_block(next_block, sub_ctx); - g_dec_context_spread_allocated_shared_regs(ctx, sub_ctx); - g_object_unref(G_OBJECT(sub_ctx)); - } - - } - - false_dinstr = NULL; - - next = g_arch_instruction_get_given_destination(last, ILT_JUMP_IF_FALSE); - if (next != NULL) - { - g_arch_instruction_get_location(next, NULL, NULL, &next_addr); - next_block = g_instr_block_find_by_addr(sub_parent, next_addr, false); - - if (next_block != NULL) - { - sub_ctx = create_new_context_for_sub_block(ctx, next_block, sub_shared); - false_dinstr = decompiled_basic_block(next_block, sub_ctx); - g_dec_context_spread_allocated_shared_regs(ctx, sub_ctx); - g_object_unref(G_OBJECT(sub_ctx)); - } - - } - - g_ite_instruction_set_branches(G_ITE_INSTRUCTION(decomp), true_dinstr, false_dinstr); - - g_hash_table_unref(sub_shared); - - } + build_ite_branches(G_ITE_INSTRUCTION(decomp), block, ctx); /* switch ... case ... */ else if (G_IS_SWITCH_INSTRUCTION(decomp)) - { - sub_parent = g_instr_block_get_links_block(G_INSTR_BLOCK(block)); - sub_shared = g_hash_table_new_full((GHashFunc)g_arch_register_hash, - (GEqualFunc)g_arch_register_equal, - g_object_unref, g_object_unref); - - dcount = g_arch_instruction_get_destinations(last, &dests, NULL, &info); - - for (i = 0; i < dcount; i++) - { - g_arch_instruction_get_location(dests[i], NULL, NULL, &next_addr); - next_block = g_instr_block_find_by_addr(sub_parent, next_addr, false); - - if (next_block != NULL) - { - sub_ctx = create_new_context_for_sub_block(ctx, next_block, sub_shared); - case_dinstr = decompiled_basic_block(next_block, sub_ctx); - g_dec_context_spread_allocated_shared_regs(ctx, sub_ctx); - g_object_unref(G_OBJECT(sub_ctx)); - - if (info[i].imm != NULL) - { - case_value = G_DEC_EXPRESSION(g_imm_expression_new(info[i].imm)); - g_switch_instruction_add_case(G_SWITCH_INSTRUCTION(decomp), - case_value, case_dinstr, next_addr); - } - else g_switch_instruction_set_default_case(G_SWITCH_INSTRUCTION(decomp), - case_dinstr); - - } - - } - - g_hash_table_unref(sub_shared); - - } + build_switch_branches(G_SWITCH_INSTRUCTION(decomp), block, ctx); /* Renvoi des instructions mises en place */ @@ -578,3 +500,256 @@ GDecInstruction *decompiled_routine_instructions(GBinRoutine *routine, GExeForma return result; } + + + +/* ---------------------------------------------------------------------------------- */ +/* DECOMPILATIONS SPECIFIQUES */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : decomp = instruction 'if ... then ... else' à compléter. * +* block = ensemble des instructions d'assemblage traitées. * +* ctx = contexte de soutien à associer à l'opération. * +* * +* Description : Procède à la décompilation des éléments d'un 'if then else'. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void build_ite_branches(GITEInstruction *decomp, GFlowBlock *block, GDecContext *ctx) +{ + GArchInstruction *last; /* Dernière instruction du lot */ + GInstrBlock *sub_parent; /* Groupe des sous-branches */ + GHashTable *sub_shared; /* Allocations communes */ + GDecContext *sub_ctx; /* Sous-contexte pour branche */ + GDecInstruction *true_dinstr; /* Décompilation 'cond vraie' */ + GDecInstruction *false_dinstr; /* Décompilation 'cond fausse' */ + GArchInstruction *next; /* Instruction de branchement */ + vmpa_t next_addr; /* Adresse de cette instruct° */ + GInstrBlock *next_block; /* Sous-bloc basique direct */ + + g_flow_block_get_boundary(block, NULL, &last); + + sub_parent = g_instr_block_get_links_block(G_INSTR_BLOCK(block)); + sub_shared = g_hash_table_new_full((GHashFunc)g_arch_register_hash, + (GEqualFunc)g_arch_register_equal, + g_object_unref, g_object_unref); + + true_dinstr = NULL; + false_dinstr = NULL; + + /* Branche 'true' */ + next = g_arch_instruction_get_given_destination(last, ILT_JUMP_IF_TRUE); + if (next != NULL) + { + g_arch_instruction_get_location(next, NULL, NULL, &next_addr); + next_block = g_instr_block_find_by_addr(sub_parent, next_addr, false); + + if (next_block != NULL) + { + sub_ctx = create_new_context_for_sub_block(ctx, next_block, sub_shared); + true_dinstr = decompiled_basic_block(next_block, sub_ctx); + g_dec_context_spread_allocated_shared_regs(ctx, sub_ctx); + g_object_unref(G_OBJECT(sub_ctx)); + } + + } + + /* Branche 'false' */ + next = g_arch_instruction_get_given_destination(last, ILT_JUMP_IF_FALSE); + if (next != NULL) + { + g_arch_instruction_get_location(next, NULL, NULL, &next_addr); + next_block = g_instr_block_find_by_addr(sub_parent, next_addr, false); + + if (next_block != NULL) + { + sub_ctx = create_new_context_for_sub_block(ctx, next_block, sub_shared); + false_dinstr = decompiled_basic_block(next_block, sub_ctx); + g_dec_context_spread_allocated_shared_regs(ctx, sub_ctx); + g_object_unref(G_OBJECT(sub_ctx)); + } + + } + + g_ite_instruction_set_branches(decomp, true_dinstr, false_dinstr); + + g_hash_table_unref(sub_shared); + +} + + +/****************************************************************************** +* * +* Paramètres : case_dinstr = instructions d'un cas de 'switch' décompilées. * +* case_block = bloc d'instructions assembleur correspondantes.* +* cases = listes des instructions des différents cas. * +* current = indice du cas courant. * +* ccount = nombre de cas présents dans le 'switch'. * +* * +* Description : Termine le traitement d'un cas de 'switch'. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void close_case_decomp_instructions(GDecInstruction *case_dinstr, GInstrBlock *case_block, GArchInstruction **cases, size_t current, size_t ccount) +{ + vmpa_t *cases_addr; /* Adresses des cas du 'switch'*/ + size_t i; /* Boucle de parcours #1 */ + GInstrBlock **leafs; /* Blocs terminaux du cas */ + size_t lcount; /* Nombre de blocs terminaux */ + vmpa_t common_addr; /* Adresse commune de suite */ + bool is_common; /* Suite commune ? */ + GArchInstruction *last; /* Dernière instruction de bloc*/ + GArchInstruction **dests; /* Instr. visée par une autre */ + size_t dcount; /* Nombre de liens de dest. */ + size_t j; /* Boucle de parcours #2 */ + vmpa_t addr; /* Adresse d'une instruction */ + bool jump_to_case; /* Suite dans le cas suivant ? */ + + /* Etablit la liste des adresses des cas */ + + cases_addr = (vmpa_t *)calloc(ccount, sizeof(vmpa_t)); + + for (i = 0; i < ccount; i++) + g_arch_instruction_get_location(cases[i], NULL, NULL, &cases_addr[i]); + + /* Récupère la (les) fin(s) du cas présent */ + + leafs = NULL; + lcount = 0; + + g_instr_block_list_leafs_blocks(case_block, &leafs, &lcount); + + /* Procède à une première analyse de la suite */ + + common_addr = VMPA_MAX; + is_common = true; + + for (i = 0; i < lcount && is_common; i++) + { + g_flow_block_get_boundary(G_FLOW_BLOCK(leafs[i]), NULL, &last); + dcount = g_arch_instruction_get_destinations(last, &dests, NULL, NULL); + + for (j = 0; j < dcount && is_common; j++) + { + g_arch_instruction_get_location(dests[j], NULL, NULL, &addr); + + if (common_addr == VMPA_MAX) + common_addr = addr; + else + is_common = (common_addr == addr); + + } + + } + + /* La sortie du cas est unique ! */ + if (is_common) + { + if (common_addr == VMPA_MAX) + goto ecdi_exit; + + jump_to_case = false; + + for (i = 0; i < ccount && !jump_to_case; i++) + if (i != current) + jump_to_case = (cases_addr[i] == common_addr); + + if (!jump_to_case) + g_expr_block_add_item(G_EXPR_BLOCK(case_dinstr), g_keyword_instruction_new(DKW_BREAK)); + + } + + /* ... ou il faut suivre les différentes branches... */ + else + { + + /* TODO */ + + } + + ecdi_exit: + + free(cases_addr); + +} + + +/****************************************************************************** +* * +* Paramètres : decomp = instruction 'switch' à compléter. * +* block = ensemble des instructions d'assemblage traitées. * +* ctx = contexte de soutien à associer à l'opération. * +* * +* Description : Procède à la décompilation des éléments d'un 'switch'. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void build_switch_branches(GSwitchInstruction *decomp, GFlowBlock *block, GDecContext *ctx) +{ + GArchInstruction *last; /* Dernière instruction du lot */ + GInstrBlock *sub_parent; /* Groupe des sous-branches */ + GHashTable *sub_shared; /* Allocations communes */ + GDecContext *sub_ctx; /* Sous-contexte pour branche */ + vmpa_t next_addr; /* Adresse de cette instruct° */ + GInstrBlock *next_block; /* Sous-bloc basique direct */ + GArchInstruction **dests; /* Instr. visée par une autre */ + link_extra_info *info; /* Compléments pour les liens */ + size_t dcount; /* Nombre de liens de dest. */ + size_t i; /* Boucle de parcours #2 */ + GDecInstruction *case_dinstr; /* Décompilation 'case' */ + GDecExpression *case_value; /* Valeur d'aiguillage */ + + g_flow_block_get_boundary(block, NULL, &last); + + sub_parent = g_instr_block_get_links_block(G_INSTR_BLOCK(block)); + sub_shared = g_hash_table_new_full((GHashFunc)g_arch_register_hash, + (GEqualFunc)g_arch_register_equal, + g_object_unref, g_object_unref); + + dcount = g_arch_instruction_get_destinations(last, &dests, NULL, &info); + + for (i = 0; i < dcount; i++) + { + g_arch_instruction_get_location(dests[i], NULL, NULL, &next_addr); + next_block = g_instr_block_find_by_addr(sub_parent, next_addr, false); + + if (next_block != NULL) + { + sub_ctx = create_new_context_for_sub_block(ctx, next_block, sub_shared); + case_dinstr = decompiled_basic_block(next_block, sub_ctx); + g_dec_context_spread_allocated_shared_regs(ctx, sub_ctx); + g_object_unref(G_OBJECT(sub_ctx)); + + close_case_decomp_instructions(case_dinstr, next_block, dests, i, dcount); + + if (info[i].imm != NULL) + { + case_value = G_DEC_EXPRESSION(g_imm_expression_new(info[i].imm)); + g_switch_instruction_add_case(G_SWITCH_INSTRUCTION(decomp), + case_value, case_dinstr, next_addr); + } + else g_switch_instruction_set_default_case(G_SWITCH_INSTRUCTION(decomp), + case_dinstr); + + } + + } + + g_hash_table_unref(sub_shared); + +} diff --git a/src/analysis/disass/macro.c b/src/analysis/disass/macro.c index 14dad95..993f70f 100644 --- a/src/analysis/disass/macro.c +++ b/src/analysis/disass/macro.c @@ -52,7 +52,7 @@ typedef struct _branch_info /* Indique si une adresse est retenue comme point de passage. */ -static bool is_addr_in_branch(const branch_info *, const vmpa_t *, bool); +static bool is_addr_in_branch(const branch_info *, const vmpa_t *, bool, size_t *); /* Identifie les différents points de passage d'une branche. */ static void find_next_jumps(GArchInstruction *, vmpa_t, vmpa_t, branch_info *); @@ -73,6 +73,7 @@ static GInstrBlock *build_instruction_block(GArchInstruction *, vmpa_t, vmpa_t, * Paramètres : info = informations à consulter. * * addr = adresse à rechercher. * * fast = autorise une recherche rapide. * +* pos = enregistrement de la position de la trouvaille. [OUT] * * * * Description : Indique si une adresse est retenue comme point de passage. * * * @@ -82,7 +83,7 @@ static GInstrBlock *build_instruction_block(GArchInstruction *, vmpa_t, vmpa_t, * * ******************************************************************************/ -static bool is_addr_in_branch(const branch_info *info, const vmpa_t *addr, bool fast) +static bool is_addr_in_branch(const branch_info *info, const vmpa_t *addr, bool fast, size_t *pos) { bool result; /* Bilan à retourner */ size_t i; /* Boucle de parcours */ @@ -92,12 +93,20 @@ static bool is_addr_in_branch(const branch_info *info, const vmpa_t *addr, bool if (!fast) for (i = 0; i < info->count && !result; i++) + { result = (info->jumps[i] == *addr); + if (result && pos != NULL) + *pos = i; + } else { ptr = bsearch(addr, info->jumps, info->count, sizeof(vmpa_t), (__compar_fn_t)compare_vmpa); result = (ptr != NULL); + + if (result && pos != NULL) + *pos = (ptr - ((void *)info->jumps)) / sizeof(vmpa_t); + } return result; @@ -130,7 +139,7 @@ static void find_next_jumps(GArchInstruction *instrs, vmpa_t start, vmpa_t end, vmpa_t addr; /* Adresse de la destination */ /* On évite de boucler... */ - if (is_addr_in_branch(info, &start, false)) + if (is_addr_in_branch(info, &start, false, NULL)) return; info->jumps = (vmpa_t *)realloc(info->jumps, ++(info->count) * sizeof(vmpa_t)); @@ -174,7 +183,7 @@ static void find_next_jumps(GArchInstruction *instrs, vmpa_t start, vmpa_t end, } /* Si on termine... */ - if (iter != NULL && !is_addr_in_branch(info, &end, false)) + if (iter != NULL && !is_addr_in_branch(info, &end, false, NULL)) { info->jumps = (vmpa_t *)realloc(info->jumps, ++(info->count) * sizeof(vmpa_t)); info->jumps[info->count - 1] = end; @@ -208,7 +217,7 @@ static vmpa_t compute_first_common_addr(branch_info *a, branch_info *b) //qsort(b->jumps, b->count, sizeof(vmpa_t), (__compar_fn_t)compare_vmpa); for (i = 0; i < a->count && result == VMPA_MAX; i++) - if (is_addr_in_branch(b, &a->jumps[i], false)) + if (is_addr_in_branch(b, &a->jumps[i], false, NULL)) result = a->jumps[i]; return result; @@ -247,7 +256,7 @@ static vmpa_t compute_first_common_addr_in_group(const branch_info *list, size_t keep = true; for (j = 1; j < count && keep; j++) - keep = is_addr_in_branch(&list[j], &list[0].jumps[i], false); + keep = is_addr_in_branch(&list[j], &list[0].jumps[i], false, NULL); if (keep) result = list[0].jumps[i]; @@ -259,6 +268,51 @@ static vmpa_t compute_first_common_addr_in_group(const branch_info *list, size_t } + + + +/****************************************************************************** +* * +* Paramètres : list = liste d'ensembles de jalons à parcourir. * +* count = taille de cette liste. * +* * +* Description : Retrouve le point de ralliement entre un groupe de branches. * +* * +* Retour : Adresse commune aux branches. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static vmpa_t avoid_cases_common_part(const branch_info *list, size_t cur, size_t count, vmpa_t max) +{ + vmpa_t result; /* Adresse trouvée à retourner */ + size_t found_pos; /* Plus petit tronc commun */ + size_t i; /* Boucle de parcours */ + size_t pos; /* Emplacement du cas commun */ + + result = max; + + found_pos = list[cur].count; + + for (i = 0; i < count; i++) + { + if (i == cur) continue; + + if (is_addr_in_branch(&list[cur], &list[i].jumps[0], false, &pos)) + { + if (pos < found_pos) + result = list[i].jumps[0]; + } + + } + + return result; + +} + + + /****************************************************************************** * * * Paramètres : instrs = ensemble des instructions d'assemblage. * @@ -447,13 +501,38 @@ static GInstrBlock *build_instruction_block(GArchInstruction *instrs, vmpa_t sta parent = block; group = g_virtual_block_new(); + do + { + size_t _i, _j; + + for (_i = 0; _i < cases_count; _i++) + { + printf(" [case %d] : ", _i); + + for (_j = 0; _j < cases_branches[_i].count; _j++) + printf("0x%08lx ", cases_branches[_i].jumps[_j]); + + printf("\n"); + + } + + } while (0); + + for (j = 0; j < cases_count; j++) { - printf(" ## %zu...", j); + printf(" ## %zu start=0x%08lx (0x%08lx)...\n", j, cases_branches[j].jumps[0], + next_addr); + + //block = build_instruction_block(instrs, cases_branches[j].jumps[0], end, next_addr); + + //next_addr = avoid_cases_common_part(cases_branches, j, cases_count, next_addr); - block = build_instruction_block(instrs, cases_branches[j].jumps[0], end, next_addr); + block = build_instruction_block(instrs, cases_branches[j].jumps[0], end, + avoid_cases_common_part(cases_branches, j, cases_count, next_addr)); - printf(" %p\n", block); + printf(" %p (0x%08lx)\n", block, + avoid_cases_common_part(cases_branches, j, cases_count, next_addr)); if (block != NULL) diff --git a/src/arch/dalvik/decomp/if.c b/src/arch/dalvik/decomp/if.c index 93e21d9..f7591b9 100644 --- a/src/arch/dalvik/decomp/if.c +++ b/src/arch/dalvik/decomp/if.c @@ -26,6 +26,7 @@ #include "../instruction.h" #include "../../../decomp/expr/cond.h" +#include "../../../decomp/expr/immediate.h" #include "../../../decomp/instr/ite.h" @@ -153,8 +154,8 @@ GDecInstruction *dalvik_decomp_instr_if_zero(const GArchInstruction *instr, GDec operand = g_arch_instruction_get_operand(instr, 0); op1 = g_dec_context_convert_register(ctx, operand, false, addr); - operand = g_imm_operand_new_from_value(MDS_8_BITS_UNSIGNED, (unsigned int)0); - op2 = g_imm_expression_new(operand); + operand = g_imm_operand_new_from_value(MDS_32_BITS_UNSIGNED, (unsigned int)0); + op2 = g_imm_expression_new(G_IMM_OPERAND(operand)); operand = g_arch_instruction_get_operand(instr, 2); jmp = 0x1234ull;/*g_dec_context_convert_register(ctx, operand, addr);*/ diff --git a/src/arch/dalvik/instruction.c b/src/arch/dalvik/instruction.c index 81b8993..1ab6e3c 100644 --- a/src/arch/dalvik/instruction.c +++ b/src/arch/dalvik/instruction.c @@ -117,12 +117,12 @@ static dalvik_instruction _instructions[DOP_COUNT] = { [DOP_IF_GE] = { 0x35, "if-ge", dalvik_decomp_instr_if }, [DOP_IF_GT] = { 0x36, "if-gt", dalvik_decomp_instr_if }, [DOP_IF_LE] = { 0x37, "if-le", dalvik_decomp_instr_if }, - [DOP_IF_EQZ] = { 0x38, "if-eqz"/*, dalvik_decomp_instr_if_zero*/ }, - [DOP_IF_NEZ] = { 0x39, "if-nez"/*, dalvik_decomp_instr_if_zero*/ }, - [DOP_IF_LTZ] = { 0x3a, "if-ltz"/*, dalvik_decomp_instr_if_zero*/ }, - [DOP_IF_GEZ] = { 0x3b, "if-gez"/*, dalvik_decomp_instr_if_zero*/ }, - [DOP_IF_GTZ] = { 0x3c, "if-gtz"/*, dalvik_decomp_instr_if_zero*/ }, - [DOP_IF_LEZ] = { 0x3d, "if-lez"/*, dalvik_decomp_instr_if_zero*/ }, + [DOP_IF_EQZ] = { 0x38, "if-eqz", dalvik_decomp_instr_if_zero }, + [DOP_IF_NEZ] = { 0x39, "if-nez", dalvik_decomp_instr_if_zero }, + [DOP_IF_LTZ] = { 0x3a, "if-ltz", dalvik_decomp_instr_if_zero }, + [DOP_IF_GEZ] = { 0x3b, "if-gez", dalvik_decomp_instr_if_zero }, + [DOP_IF_GTZ] = { 0x3c, "if-gtz", dalvik_decomp_instr_if_zero }, + [DOP_IF_LEZ] = { 0x3d, "if-lez", dalvik_decomp_instr_if_zero }, [DOP_UNUSED_3E] = { 0x3e, NULL /* unused */ }, [DOP_UNUSED_3F] = { 0x3f, NULL /* unused */ }, [DOP_UNUSED_40] = { 0x40, NULL /* unused */ }, diff --git a/src/decomp/instr/Makefile.am b/src/decomp/instr/Makefile.am index 6120cac..d299cd2 100644 --- a/src/decomp/instr/Makefile.am +++ b/src/decomp/instr/Makefile.am @@ -3,6 +3,7 @@ noinst_LTLIBRARIES = libdecompinstr.la libdecompinstr_la_SOURCES = \ ite.h ite.c \ + keyword.h keyword.c \ switch.h switch.c libdecompinstr_la_LDFLAGS = diff --git a/src/decomp/instr/keyword.c b/src/decomp/instr/keyword.c new file mode 100644 index 0000000..eca1530 --- /dev/null +++ b/src/decomp/instr/keyword.c @@ -0,0 +1,162 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * keyword.c - insertions de mots clefs de haut niveau + * + * Copyright (C) 2013 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 "keyword.h" + + +#include "../instruction-int.h" + + + +/* Définition d'un mot clef de haut niveau (instance) */ +struct _GKeywordInstruction +{ + GDecInstruction parent; /* A laisser en premier */ + + DecompiledKeyWord keyword; /* Mot clef représenté */ + +}; + + +/* Indique le type défini pour un mot clef de haut niveau. */ +struct _GKeywordInstructionClass +{ + GDecInstructionClass parent; /* A laisser en premier */ + +}; + + + +/* Initialise la classe des mots clefs de haut niveau. */ +static void g_keyword_instruction_class_init(GKeywordInstructionClass *); + +/* Initialise une instance de mot clef de haut niveau. */ +static void g_keyword_instruction_init(GKeywordInstruction *); + +/* Imprime pour l'écran un version humaine d'une instruction. */ +static GBufferLine *g_keyword_instruction_print(const GKeywordInstruction *, GCodeBuffer *, GBufferLine *, GLangOutput *); + + + +/* Indique le type défini pour un mot clef de haut niveau. */ +G_DEFINE_TYPE(GKeywordInstruction, g_keyword_instruction, G_TYPE_DEC_INSTRUCTION); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des mots clefs de haut niveau. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_keyword_instruction_class_init(GKeywordInstructionClass *klass) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : instr = instance à initialiser. * +* * +* Description : Initialise une instance de mot clef de haut niveau. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_keyword_instruction_init(GKeywordInstruction *instr) +{ + GDecInstruction *base; /* Autre version de l'objet */ + + base = G_DEC_INSTRUCTION(instr); + + base->print = (dec_instr_print_fc)g_keyword_instruction_print; + +} + + +/****************************************************************************** +* * +* Paramètres : keyword = mot clef à représenter. * +* * +* Description : Crée un mot clef de haut niveau. * +* * +* Retour : Instruction mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GDecInstruction *g_keyword_instruction_new(DecompiledKeyWord keyword) +{ + GKeywordInstruction *result; /* Expression à retourner */ + + result = g_object_new(G_TYPE_KEYWORD_INSTRUCTION, NULL); + + result->keyword = keyword; + + return G_DEC_INSTRUCTION(result); + +} + + +/****************************************************************************** +* * +* Paramètres : instr = instruction à transcrire en version humaine. * +* buffer = tampon où doit se réaliser l'insertion. * +* line = ligne d'impression prête à emploi ou NULL. * +* output = langage de programmation de sortie. * +* * +* Description : Imprime pour l'écran un version humaine d'une instruction. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static GBufferLine *g_keyword_instruction_print(const GKeywordInstruction *instr, GCodeBuffer *buffer, GBufferLine *line, GLangOutput *output) +{ + switch (instr->keyword) + { + case DKW_BREAK: + g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, "break", 5, RTT_KEY_WORD); + break; + + case DKW_CONTINUE: + g_buffer_line_insert_text(line, BLC_ASSEMBLY_HEAD, "continue", 8, RTT_KEY_WORD); + break; + + } + + return line; + +} diff --git a/src/decomp/instr/keyword.h b/src/decomp/instr/keyword.h new file mode 100644 index 0000000..69d6901 --- /dev/null +++ b/src/decomp/instr/keyword.h @@ -0,0 +1,68 @@ + +/* OpenIDA - Outil d'analyse de fichiers binaires + * keyword.h - prototypes pour les insertions de mots clefs de haut niveau + * + * Copyright (C) 2013 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 . + */ + + +#ifndef _DECOMP_INSTR_KEYWORD_H +#define _DECOMP_INSTR_KEYWORD_H + + +#include + + +#include "../instruction.h" + + + +#define G_TYPE_KEYWORD_INSTRUCTION g_keyword_instruction_get_type() +#define G_KEYWORD_INSTRUCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_keyword_instruction_get_type(), GKeywordInstruction)) +#define G_IS_KEYWORD_INSTRUCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_keyword_instruction_get_type())) +#define G_KEYWORD_INSTRUCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_KEYWORD_INSTRUCTION, GKeywordInstructionClass)) +#define G_IS_KEYWORD_INSTRUCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_KEYWORD_INSTRUCTION)) +#define G_KEYWORD_INSTRUCTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_KEYWORD_INSTRUCTION, GKeywordInstructionClass)) + + + +/* Type de mots clefs pris en charge */ +typedef enum _DecompiledKeyWord +{ + DKW_BREAK, /* 'break' */ + DKW_CONTINUE, /* 'continue' */ + +} DecompiledKeyWord; + + +/* Définition d'un mot clef de haut niveau (instance) */ +typedef struct _GKeywordInstruction GKeywordInstruction; + +/* Définition d'un mot clef de haut niveau (classe) */ +typedef struct _GKeywordInstructionClass GKeywordInstructionClass; + + +/* Indique le type défini pour un mot clef de haut niveau. */ +GType g_keyword_instruction_get_type(void); + +/* Crée un mot clef de haut niveau. */ +GDecInstruction *g_keyword_instruction_new(DecompiledKeyWord); + + + +#endif /* _DECOMP_INSTR_KEYWORD_H */ diff --git a/src/decomp/instr/switch.c b/src/decomp/instr/switch.c index 3c204a0..4b1662b 100644 --- a/src/decomp/instr/switch.c +++ b/src/decomp/instr/switch.c @@ -31,15 +31,16 @@ #include "../instruction-int.h" + /* Détails d'un cas */ typedef struct _case_info { - vmpa_t addr; /* Adresse des blocs associés */ + vmpa_t addr; /* Adresse des blocs associés */ - GDecExpression **values; /* Valeur d'embranchement */ - size_t values_count; /* Quantité de cas rassemblés */ + GDecExpression **values; /* Valeur d'embranchement */ + size_t values_count; /* Quantité de cas rassemblés */ - GDecInstruction *instrs; /* Instructions du cas */ + GDecInstruction *instrs; /* Instructions du cas */ } case_info; @@ -138,7 +139,7 @@ static void g_switch_instruction_init(GSwitchInstruction *instr) * * * Description : Exprime un aiguillage multiple du flux selon une valeur. * * * -* Retour : Expression mise en place. * +* Retour : Instruction mise en place. * * * * Remarques : - * * * -- cgit v0.11.2-87-g4458