/* Chrysalide - Outil d'analyse de fichiers binaires * links.c - résolution des liens entre différentes instructions * * Copyright (C) 2010-2017 Cyrille Bagard * * This file is part of Chrysalide. * * Chrysalide 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. * * Chrysalide 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/raw.h" #include "../../arch/target.h" /* Complète un désassemblage accompli pour une instruction. */ static void convert_immediate_into_target(GArchInstruction *, size_t, GBinFormat *); /****************************************************************************** * * * 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 : - * * * ******************************************************************************/ void establish_natural_link(GArchInstruction *instr, GArchInstruction *prev) { bool has_src; /* Présence de sources ? */ instr_link_t *others; /* Instructions diverses liées */ 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. */ g_arch_instruction_rlock_src(instr); has_src = g_arch_instruction_has_sources(instr); g_arch_instruction_runlock_src(instr); if (!has_src) return; /** * Si on se trouve à une extrémité, on ne se lie pas * avec le voisin. */ if (g_arch_instruction_get_flags(prev) & AIF_RETURN_POINT) return; if (g_arch_instruction_get_flags(instr) & AIF_ROUTINE_START) return; /** * On s'assure que le lien naturel est valide. */ g_arch_instruction_rlock_dest(prev); count = g_arch_instruction_get_destinations(prev, &others); for (i = 0; i < count; i++) { if (others[i].type == ILT_EXEC_FLOW) break; if (others[i].type == ILT_JUMP) break; if (others[i].type == ILT_CASE_JUMP) break; if (others[i].type == ILT_LOOP) break; } g_arch_instruction_runlock_dest(prev); if (count > 0 && i < count) return; /** * On vérifie que le lien n'existe pas déjà avant d'en créer un... */ g_arch_instruction_rlock_src(instr); count = g_arch_instruction_get_sources(instr, &others); for (i = 0; i < count; i++) { if (others[i].linked == prev && others[i].type == ILT_JUMP_IF_TRUE) break; if (others[i].linked == prev && others[i].type == ILT_JUMP_IF_FALSE) break; } g_arch_instruction_runlock_src(instr); if (i == count) g_arch_instruction_link_with(prev, instr, ILT_EXEC_FLOW); } /****************************************************************************** * * * 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 */ GImmOperand *imm; /* Version native de l'opérande*/ 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; imm = G_IMM_OPERAND(op); if (g_imm_operand_get_display(imm) != IOD_HEX) return; if (g_imm_operand_to_virt_t(imm, &addr)) { msize = g_imm_operand_get_size(imm); new = g_target_operand_new(msize, addr); if (!g_target_operand_resolve(G_TARGET_OPERAND(new), format, false)) g_object_unref(G_OBJECT(new)); else g_arch_instruction_replace_operand(instr, new, op); } } /****************************************************************************** * * * Paramètres : instr = instruction désassemblée à traiter. * * format = accès aux données du binaire d'origine. * * proc = ensemble d'instructions à relier. * * * * Description : Complète un désassemblage accompli pour une instruction. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void establish_links_for_instruction(GArchInstruction *instr, GBinFormat *format, GArchProcessor *proc) { bool skip; /* Saut des conversions */ 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 */ if (G_IS_RAW_INSTRUCTION(instr)) skip = g_raw_instruction_is_string(G_RAW_INSTRUCTION(instr)); else skip = false; count = g_arch_instruction_count_operands(instr); for (i = 0; i < count; i++) { if (!skip) 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_processor_find_instr_by_address(proc, &addr); if (target != NULL) { g_arch_instruction_link_with(instr, target, ILT_REF); g_object_unref(G_OBJECT(target)); } } }