/* Chrysalide - Outil d'analyse de fichiers binaires * links.c - résolution des liens entre différentes instructions * * Copyright (C) 2010-2013 Cyrille Bagard * * This file is part of Chrysalide. * * 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 "links.h" #include "../../arch/instruction.h" #include "../../arch/target.h" /* Complète un désassemblage accompli pour une instruction. */ static void convert_immediate_into_target(GArchInstruction *, size_t, GBinFormat *); /* Rétablit un lien naturel coupé par un autre lien. */ static void establish_natural_link(GArchInstruction *, GArchInstruction *); /****************************************************************************** * * * Paramètres : instr = instruction désassemblée à traiter. * * index = indice de l'opérande à traiter. * * format = accès aux données du binaire d'origine. * * * * Description : Complète un désassemblage accompli pour une instruction. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void convert_immediate_into_target(GArchInstruction *instr, size_t index, GBinFormat *format) { GArchOperand *op; /* Opérande numérique en place */ virt_t addr; /* Adresse visée par le saut */ MemoryDataSize msize; /* Taille de l'opérande */ GArchOperand *new; /* Instruction de ciblage */ op = g_arch_instruction_get_operand(instr, index); if (!G_IS_IMM_OPERAND(op)) return; if (g_imm_operand_to_virt_t(G_IMM_OPERAND(op), &addr)) { msize = g_imm_operand_get_size(G_IMM_OPERAND(op)); new = g_target_operand_new(msize, addr); if (!g_target_operand_resolve(G_TARGET_OPERAND(new), format)) g_object_unref(G_OBJECT(new)); else g_arch_instruction_replace_operand(instr, new, op); } } /****************************************************************************** * * * Paramètres : instr = instruction désassemblée à traiter. * * list = ensemble d'instructions à relier. * * format = accès aux données du binaire d'origine. * * * * Description : Complète un désassemblage accompli pour une instruction. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void establish_links_for_instruction(GArchInstruction *instr, GArchInstruction *list, GBinFormat *format) { size_t count; /* Nombre d'opérandes présents */ size_t i; /* Boucle de parcours */ GArchOperand *op; /* Opérande numérique en place */ virt_t virt; /* Adresse liée à une cible */ vmpa2t addr; /* Localisation plus complète */ GArchInstruction *target; /* Instruction visée au final */ count = g_arch_instruction_count_operands(instr); for (i = 0; i < count; i++) { convert_immediate_into_target(instr, i, format); op = g_arch_instruction_get_operand(instr, i); if (!G_IS_TARGET_OPERAND(op)) continue; virt = g_target_operand_get_addr(G_TARGET_OPERAND(op)); init_vmpa(&addr, VMPA_NO_PHYSICAL, virt); target = g_arch_instruction_find_by_address(list, &addr, true); if (target != NULL) g_arch_instruction_link_with(instr, target, ILT_REF); } } /****************************************************************************** * * * Paramètres : instr = instruction désassemblée à traiter. * * prev = instruction précédente. * * * * Description : Rétablit un lien naturel coupé par un autre lien. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void establish_natural_link(GArchInstruction *instr, GArchInstruction *prev) { GArchInstruction **others; /* Instructions diverses liées */ InstructionLinkType *types; /* Types de lien existants */ size_t count; /* Nbre de sources affichées */ size_t i; /* Boucle de parcours */ /** * Si rien ne vient séparer les deux instructions, * on ne peut pas créer de lien plus naturel que l'existant. */ if (!g_arch_instruction_has_sources(instr)) return; /** * Si on se trouve à une extrémité, on ne se lie pas * avec le voisin. */ if (g_arch_instruction_is_return(prev)) return; if (g_arch_instruction_get_flags(instr) & AIF_ROUTINE_START) return; /** * On s'assure que le lien naturel est valide. */ count = g_arch_instruction_get_destinations(prev, &others, &types, NULL); for (i = 0; i < count; i++) { if (types[i] == ILT_EXEC_FLOW) break; if (types[i] == ILT_JUMP) break; if (types[i] == ILT_CASE_JUMP) break; if (types[i] == ILT_LOOP) break; } if (i < count) return; /** * On vérifie que le lien n'existe pas déjà avant d'en créer un... */ count = g_arch_instruction_get_sources(instr, &others, &types); for (i = 0; i < count; i++) { if (others[i] == prev && types[i] == ILT_JUMP_IF_TRUE) break; if (others[i] == prev && types[i] == ILT_JUMP_IF_FALSE) break; } if (i == count) g_arch_instruction_link_with(prev, instr, ILT_EXEC_FLOW); } /****************************************************************************** * * * Paramètres : list = ensemble d'instructions à relier. * * format = accès aux données du binaire d'origine. * * 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 : - * * * ******************************************************************************/ void establish_links_between_instructions(GArchInstruction *list, GBinFormat *format, GtkExtStatusBar *statusbar, bstatus_id_t id) { GArchInstruction *prev; /* Itération précédente */ GArchInstruction *iter; /* Boucle de parcours */ prev = NULL; for (iter = list; iter != NULL; iter = g_arch_instruction_get_next_iter(list, iter, ~0/* FIXME */)) { if (prev != NULL) establish_natural_link(iter, prev); prev = iter; establish_links_for_instruction(iter, list, format); } } #if 0 /****************************************************************************** * * * Paramètres : list = ensemble d'instructions à 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 : - * * * ******************************************************************************/ void establish_links_between_lines(GArchInstruction *list, GBinRoutine **routines, size_t count, GtkExtStatusBar *statusbar, bstatus_id_t id) { size_t i; /* Boucle de parcours */ vmpa_t start; /* Adresse de départ */ vmpa_t end; /* Adresse de fin */ GArchInstruction *iter; /* Boucle de parcours */ vmpa_t addr; /* Adresse référencée */ InstructionLinkType type; /* Type de référence */ GArchInstruction *target; /* Ligne visée par la référence*/ GArchInstruction *prev; /* Instruction précédente */ for (i = 0; i < count; i++) { start = g_binary_routine_get_address(routines[i]); end = start + g_binary_routine_get_size(routines[i]); /* Définition de toutes les destinations */ for (iter = g_arch_instruction_find_by_address(list, start, true); iter != NULL; iter = g_arch_instruction_get_next_iter(list, iter, end)) { type = g_arch_instruction_get_link(iter, &addr); switch (type) { case ILT_NONE: break; case ILT_JUMP: target = g_arch_instruction_find_by_address(list, addr, true); if (target != NULL) g_arch_instruction_link_with(iter, target, type); break; case ILT_JUMP_IF_FALSE: break; case ILT_JUMP_IF_TRUE: target = g_arch_instruction_find_by_address(list, addr, true); if (target != NULL) { g_arch_instruction_link_with(iter, target, type); target = g_arch_instruction_get_next_iter(list, iter, end); if (target != NULL) g_arch_instruction_link_with(iter, target, ILT_JUMP_IF_FALSE); } break; case ILT_CALL: target = g_arch_instruction_find_by_address(list, addr, true); if (target != NULL) g_arch_instruction_link_with(iter, target, type); break; default: /** * Note pour GCC : à ce stade du désassemblage, ILT_CASE_JUMP et * ILT_CATCH_EXCEPTION ne peuvent être présentes, car ne provenant * que de greffons. Pour ILT_EXEC_FLOW, sa seule insertion est ici, plus bas. */ break; } } /* Rattachement de deux blocs selon le flux normal */ iter = g_arch_instruction_find_by_address(list, start, true); if (iter == NULL) printf("no match for 0x%08llx\n", start); if (iter != NULL) for (iter = g_arch_instruction_get_next_iter(list, iter, end); iter != NULL; iter = g_arch_instruction_get_next_iter(list, iter, end)) { if (!g_arch_instruction_has_sources(iter)) continue; prev = g_arch_instruction_get_prev_iter(list, iter); if (g_arch_instruction_is_return(prev)) continue; if (!g_arch_instruction_has_destinations(prev)) g_arch_instruction_link_with(prev, iter, ILT_EXEC_FLOW); } gtk_extended_status_bar_update_activity(statusbar, id, (i + 1) * 1.0 / count); } } #endif