/* OpenIDA - Outil d'analyse de fichiers binaires
* il.h - mise en place d'un langage intermédiaire
*
* Copyright (C) 2012 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 "il.h"
#include "../blocks/flow.h"
#include "../blocks/virtual.h"
#include "../../decomp/expr/block.h"
#include "../../decomp/instr/ite.h"
/* --------------------- GESTION DES CONTEXTES DE DECOMPILATION --------------------- */
/* -------------------------- ENCADREMENT DES INSTRUCTIONS -------------------------- */
/* Retrouve et rassemble les instructions décompilées. */
static GDecInstruction *merge_decompiled_instructions(GDecInstruction *, GDecInstruction *);
/* Procède à la décompilation d'un bloc déterminé. */
static GDecInstruction *decompiled_instructions_block(GFlowBlock *, GVirtualBlock *, GDecContext *);
/* Procède à la décompilation d'un ensemble de blocs déterminé. */
static GDecInstruction *decompiled_instructions_blocks(GVirtualBlock *, GDecContext *);
/* Procède à la décompilation d'un bloc basique quelconque. */
static GDecInstruction *decompiled_basic_block(GInstrBlock *, GDecContext *);
/* ---------------------------------------------------------------------------------- */
/* GESTION DES CONTEXTES DE DECOMPILATION */
/* ---------------------------------------------------------------------------------- */
/* ---------------------------------------------------------------------------------- */
/* ENCADREMENT DES INSTRUCTIONS */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : group = groupe d'instructions à compléter ou constituer. *
* list = liste d'instructions à intégrer. *
* *
* Description : Retrouve et rassemble les instructions décompilées. *
* *
* Retour : Groupe fourni ou nouveau groupe créé pour l'occasion. *
* *
* Remarques : - *
* *
******************************************************************************/
static GDecInstruction *merge_decompiled_instructions(GDecInstruction *group, GDecInstruction *list)
{
GExprBlock *block; /* Autre vision du groupe */
GDecInstruction *iter; /* Boucle de parcours */
if (group == NULL) block = NULL;
else block = G_EXPR_BLOCK(group);
for (iter = list;
iter != NULL;
iter = g_dec_instruction_get_next_iter(list, iter))
{
if (block == NULL)
block = G_EXPR_BLOCK(g_expr_block_new(iter));
else
g_expr_block_add_item(block, iter);
}
return G_DEC_INSTRUCTION(block);
}
/******************************************************************************
* *
* Paramètres : block = ensemble des instructions d'assemblage à traiter. *
* parent = groupe de blocs d'appartenance. *
* ctx = contexte de soutien à associer à l'opération. *
* *
* Description : Procède à la décompilation d'un bloc déterminé. *
* *
* Retour : Instructions créées et enregistrées, ou NULL si erreur. *
* *
* Remarques : - *
* *
******************************************************************************/
static GDecInstruction *decompiled_instructions_block(GFlowBlock *block, GVirtualBlock *parent, GDecContext *ctx)
{
GDecInstruction *res;
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 */
GDecInstruction *decomp; /* Dernier résultat de décomp. */
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; /* Bloc basique correspondant */
instrs = g_flow_block_get_all_instructions_list(block);
g_flow_block_get_boundary(block, &first, &last);
g_flow_block_get_boundary_addresses(block, NULL, &max);
max++;
/* Décompilation du corps du bloc */
for (iter = first;
iter != NULL;
iter = g_arch_instruction_get_next_iter(instrs, iter, max))
{
decomp = g_arch_instruction_decompile(iter, ctx);
}
/* Post-traitement selon les types de lien */
res = g_dec_context_get_decomp_instrs(ctx);
/* if ... then ... else ... */
if (G_IS_ITE_INSTRUCTION(decomp))
{
next = g_arch_instruction_get_given_destination(last, ILT_JUMP_IF_TRUE);
printf("@ 0x%08llx : true : %p\n", max, next);
true_dinstr = NULL;
if (next != NULL)
{
g_arch_instruction_get_location(next, NULL, NULL, &next_addr);
next_block = g_instr_block_find_by_addr(G_INSTR_BLOCK(parent), next_addr);
if (next_block != NULL)
{
next_block = g_instr_block_find_by_addr(next_block, next_addr);
true_dinstr = decompiled_basic_block(next_block, ctx);
}
}
next = g_arch_instruction_get_given_destination(last, ILT_JUMP_IF_FALSE);
printf("@ 0x%08llx : false : %p\n", max, next);
false_dinstr = NULL;
if (next != NULL)
{
g_arch_instruction_get_location(next, NULL, NULL, &next_addr);
next_block = g_instr_block_find_by_addr(G_INSTR_BLOCK(parent), next_addr);
if (next_block != NULL)
{
next_block = g_instr_block_find_by_addr(next_block, next_addr);
false_dinstr = decompiled_basic_block(next_block, ctx);
}
}
printf(" -> ite : %p + %p\n", true_dinstr, false_dinstr);
printf(" -> ite : %s + %s\n",
g_type_name(G_TYPE_FROM_INSTANCE(true_dinstr)),
g_type_name(G_TYPE_FROM_INSTANCE(false_dinstr)));
g_ite_instruction_set_branches(G_ITE_INSTRUCTION(decomp), true_dinstr, false_dinstr);
}
/* Renvoi des instructions mises en place */
return res;
//return g_dec_context_get_decomp_instrs(ctx);
}
/******************************************************************************
* *
* Paramètres : block = ensemble des instructions d'assemblage à traiter. *
* ctx = contexte de soutien à associer à l'opération. *
* *
* Description : Procède à la décompilation d'un ensemble de blocs déterminé. *
* *
* Retour : Instructions créées et enregistrées, ou NULL si erreur. *
* *
* Remarques : - *
* *
******************************************************************************/
static GDecInstruction *decompiled_instructions_blocks(GVirtualBlock *block, GDecContext *ctx)
{
GDecInstruction *result; /* Instructions à renvoyer */
size_t count; /* Nombre de sous-blocs */
size_t i; /* Boucle de parcours */
GInstrBlock *sub_block; /* Sous-bloc à traiter */
GDecInstruction *dinstrs; /* Instructions décompilées */
result = NULL;
count = g_virtual_block_count_children(block);
for (i = 0; i < count; i++)
{
sub_block = g_virtual_block_get_child(block, i);
/**
* Les groupes de blocs sont forcément rattachés à une instruction,
* donc ils sont décompilés depuis ces instructions, pas ici.
*/
if (!G_IS_FLOW_BLOCK(sub_block)) continue;
/* FIXME */
g_dec_context_set_decomp_instrs(ctx, NULL);
dinstrs = decompiled_instructions_block(G_FLOW_BLOCK(sub_block), block, ctx);
result = merge_decompiled_instructions(result, dinstrs);
}
return result;
}
/******************************************************************************
* *
* Paramètres : block = ensemble des instructions d'assemblage à traiter. *
* ctx = contexte de soutien à associer à l'opération. *
* *
* Description : Procède à la décompilation d'un bloc basique quelconque. *
* *
* Retour : Instructions créées et enregistrées, ou NULL si erreur. *
* *
* Remarques : - *
* *
******************************************************************************/
static GDecInstruction *decompiled_basic_block(GInstrBlock *block, GDecContext *ctx)
{
GDecInstruction *result; /* Instructions à retourner */
/* FIXME */
g_dec_context_set_decomp_instrs(ctx, NULL);
if (G_IS_VIRTUAL_BLOCK(block))
result = decompiled_instructions_blocks(G_VIRTUAL_BLOCK(block), ctx);
else
{
result = decompiled_instructions_block(G_FLOW_BLOCK(block), NULL, ctx);
if (!G_IS_EXPR_BLOCK(result))
result = merge_decompiled_instructions(NULL, result);
}
return result;
}
/******************************************************************************
* *
* Paramètres : routine = routine dont le corps est à traiter. *
* format = format du binaire contenant les instructions. *
* proc = architecture du code machine. *
* *
* Description : Procède à la décompilation d'une routinée déterminée. *
* *
* Retour : Instructions créées ou NULL si erreur. *
* *
* Remarques : - *
* *
******************************************************************************/
GDecInstruction *decompiled_routine_instructions(GBinRoutine *routine, GExeFormat *format, GArchProcessor *proc)
{
GDecInstruction *result; /* Instructions à retourner */
GDecContext *context; /* Contexte pour la décompil. */
GInstrBlock *blocks; /* Blocs basiques de routine */
context = g_arch_processor_get_decomp_context(proc);
g_object_set_data(G_OBJECT(context), "format", format);
g_object_set_data(G_OBJECT(context), "routine", routine);
blocks = g_binary_routine_get_basic_blocks(routine);
result = decompiled_basic_block(blocks, context);
g_object_unref(context);
return result;
}
#if 0
#include
#include
#include
#include "../../decomp/expr/block.h"
#include "../../decomp/instr/ite.h"
/* Indications sur une branche */
typedef struct _branch_info
{
vmpa_t *jumps; /* Jalons de la branche */
size_t count; /* Quantité de ces jalons */
} 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);
/* Identifie les différents points de passage d'une branche. */
static void find_next_jumps(GArchInstruction *, vmpa_t, vmpa_t, branch_info *);
/* Retrouve le point de ralliement entre deux branches. */
static vmpa_t compute_first_common_addr(branch_info *, branch_info *);
/******************************************************************************
* *
* Paramètres : info = informations à consulter. *
* addr = adresse à rechercher. *
* fast = autorise une recherche rapide. *
* *
* Description : Indique si une adresse est retenue comme point de passage. *
* *
* Retour : true si le jalon est déjà dans la liste, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
static bool is_addr_in_branch(const branch_info *info, const vmpa_t *addr, bool fast)
{
bool result; /* Bilan à retourner */
size_t i; /* Boucle de parcours */
void *ptr; /* Résultat des recherches */
result = false;
if (!fast)
for (i = 0; i < info->count && !result; i++)
result = (info->jumps[i] == *addr);
else
{
ptr = bsearch(addr, info->jumps, info->count, sizeof(vmpa_t), (__compar_fn_t)compare_vmpa);
result = (ptr != NULL);
}
return result;
}
/******************************************************************************
* *
* Paramètres : instrs = ensemble des instructions d'assemblage. *
* start = adresse de début du bloc. *
* end = adresse de fin du bloc (exclusive). *
* count = nombre de sauts détectés. [OUT] *
* *
* Description : Identifie les différents points de passage d'une branche. *
* *
* Retour : Jalons dans le flot d'exécution. *
* *
* Remarques : - *
* *
******************************************************************************/
static void find_next_jumps(GArchInstruction *instrs, vmpa_t start, vmpa_t end, branch_info *info)
{
GArchInstruction *iter; /* Boucle de parcours #1 */
GArchInstruction **dests; /* Instr. visée par une autre */
InstructionLinkType *types; /* Type de lien entre lignes */
size_t dcount; /* Nombre de liens de dest. */
size_t i; /* Boucle de parcours #2 */
vmpa_t addr; /* Adresse de la destination */
/* On évite de boucler... */
if (is_addr_in_branch(info, &start, false))
return;
info->jumps = (vmpa_t *)realloc(info->jumps, ++(info->count) * sizeof(vmpa_t));
info->jumps[info->count - 1] = start;
/* On suit le flot jusqu'à la prochaine bifurcation */
for (iter = g_arch_instruction_find_by_address(instrs, start, true);
iter != NULL;
iter = g_arch_instruction_get_next_iter(instrs, iter, end))
{
if (!g_arch_instruction_has_destinations(iter))
continue;
dcount = g_arch_instruction_get_destinations(iter, &dests, &types);
for (i = 0; i < dcount; i++)
switch (types[i])
{
case ILT_EXEC_FLOW:
case ILT_JUMP:
case ILT_JUMP_IF_TRUE:
case ILT_JUMP_IF_FALSE:
g_arch_instruction_get_location(dests[i], NULL, NULL, &addr);
find_next_jumps(instrs, addr, end, info);
break;
default:
break;
}
break;
}
/* Si on termine... */
if (iter != NULL && !is_addr_in_branch(info, &end, false))
{
info->jumps = (vmpa_t *)realloc(info->jumps, ++(info->count) * sizeof(vmpa_t));
info->jumps[info->count - 1] = end;
}
}
/******************************************************************************
* *
* Paramètres : a = premier ensemble de jalons à parcourir. *
* b = second ensemble de jalons à parcourir. *
* *
* Description : Retrouve le point de ralliement entre deux branches. *
* *
* Retour : Adresse commune à deux branches. *
* *
* Remarques : - *
* *
******************************************************************************/
static vmpa_t compute_first_common_addr(branch_info *a, branch_info *b)
{
vmpa_t result; /* Adresse trouvée à retourner */
size_t i; /* Boucle de parcours */
/* Valeur conceptuellement impossible à renvoyer */
result = VMPA_MAX;
//qsort(a->jumps, a->count, sizeof(vmpa_t), (__compar_fn_t)compare_vmpa);
//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))
result = a->jumps[i];
return result;
}
#include "../../arch/processor.h"
/******************************************************************************
* *
* Paramètres : instrs = ensemble des instructions d'assemblage. *
* start = adresse de début du bloc. *
* end = adresse de fin du bloc (exclusive). *
* stop = adresse d'arrêt en cas de saut ou VMPA_MAX. *
* ctx = contexte de soutien à associer à l'opération. *
* *
* Description : Procède à la décompilation basique d'un bloc déterminé. *
* *
* Retour : Instructions créées et enregistrées, ou NULL si erreur. *
* *
* Remarques : - *
* *
******************************************************************************/
GDecInstruction *build_decompiled_block(GArchInstruction *instrs, vmpa_t start, vmpa_t end, vmpa_t stop, GDecContext *ctx)
{
GDecInstruction *result; /* Instructions décompilées */
GArchInstruction *iter; /* Boucle de parcours */
GDecInstruction *pite; /* IfThenElse potientiel... */
GArchInstruction **dests; /* Instr. visée par une autre */
InstructionLinkType *types; /* Type de lien entre lignes */
size_t dcount; /* Nombre de liens de dest. */
size_t i; /* Boucle de parcours */
vmpa_t addr; /* Adresse de la destination */
branch_info true_branch; /* Branche 'condition vraie' */
branch_info false_branch; /* Branche 'condition fausse' */
GDecInstruction *true_dinstr; /* Décompilation 'cond vraie' */
GDecInstruction *false_dinstr; /* Décompilation 'cond fausse' */
vmpa_t next_addr; /* Prochaine instruction visée */
GDecInstruction *first; /* Première décompilation */
GDecInstruction *dinstr; /* Nouvelle décompilation */
GExeFormat *format; /* Format du binaire fourni */
GArchProcessor *proc; /* Architecture du binaire */
GDecContext *context; /* Contexte pour la décompil. */
result = NULL;
//printf("[+] processing 0x%08llx -> 0x%08llx... stop @ 0x%08llx\n", start, end, stop);
for (iter = g_arch_instruction_find_by_address(instrs, start, true);
iter != NULL;
)
{
/* On s'arrêter si l'instruction est déjà décompilée */
if (g_object_get_data(G_OBJECT(iter), "decomp_done") != NULL) break;
g_object_set_data(G_OBJECT(iter), "decomp_done", iter);
pite = g_arch_instruction_decompile(iter, ctx);
g_arch_instruction_get_location(iter, NULL, NULL, &addr);
//printf(" --- decomp %p @ 0x%08llx\n", pite, addr);
/* On n'approfondit que les chemins qui se séparent */
if (!g_arch_instruction_has_destinations(iter))
{
iter = g_arch_instruction_get_next_iter(instrs, iter, end);
continue;
}
/* Adaptations en fonction du type de bifurcation */
dcount = g_arch_instruction_get_destinations(iter, &dests, &types);
next_addr = 0;
memset(&true_branch, 0, sizeof(branch_info));
memset(&false_branch, 0, sizeof(branch_info));
for (i = 0; i < dcount; i++)
switch (types[i])
{
case ILT_EXEC_FLOW:
case ILT_JUMP:
g_arch_instruction_get_location(dests[i], NULL, NULL, &next_addr);
break;
case ILT_JUMP_IF_TRUE:
g_arch_instruction_get_location(dests[i], NULL, NULL, &addr);
find_next_jumps(instrs, addr, end, &true_branch);
break;
case ILT_JUMP_IF_FALSE:
g_arch_instruction_get_location(dests[i], NULL, NULL, &addr);
find_next_jumps(instrs, addr, end, &false_branch);
break;
default:
next_addr = VMPA_MAX;
break;
}
if (next_addr == VMPA_MAX)
{
iter = g_arch_instruction_get_next_iter(instrs, iter, end);
continue;
}
else if (true_branch.count > 0 || false_branch.count > 0)
{
next_addr = compute_first_common_addr(&true_branch, &false_branch);
next_addr = MIN(next_addr, end);
format = g_object_get_data(G_OBJECT(ctx), "format");
proc = get_arch_processor_from_format(G_EXE_FORMAT(format));
context = g_arch_processor_get_decomp_context(proc);
g_object_set_data(G_OBJECT(context), "format", g_object_get_data(G_OBJECT(ctx), "format"));
g_object_set_data(G_OBJECT(context), "routine", g_object_get_data(G_OBJECT(ctx), "routine"));
g_dec_context_set_max_address(context, next_addr);
true_dinstr = build_decompiled_block(instrs, true_branch.jumps[0],
end, next_addr, context);
context = g_arch_processor_get_decomp_context(proc);
g_object_set_data(G_OBJECT(context), "format", g_object_get_data(G_OBJECT(ctx), "format"));
g_object_set_data(G_OBJECT(context), "routine", g_object_get_data(G_OBJECT(ctx), "routine"));
g_dec_context_set_max_address(context, next_addr);
false_dinstr = build_decompiled_block(instrs, false_branch.jumps[0],
end, next_addr, context);
/*
printf("{branch : %p (0x%08llx) | %p (0x%08llx)\n",
true_dinstr, true_branch.jumps[0],
false_dinstr, false_branch.jumps[0]);
*/
g_ite_instruction_set_branches(G_ITE_INSTRUCTION(pite), true_dinstr, false_dinstr);
if (next_addr == end) break;
}
/* Détermination du prochain point de chute */
if (next_addr == stop) break;
iter = g_arch_instruction_find_by_address(instrs, next_addr, true);
}
first = g_dec_context_get_decomp_instrs(ctx);
//printf(" ... context instr : %p\n", first);
for (dinstr = first;
dinstr != NULL;
dinstr = g_dec_instruction_get_next_iter(first, dinstr))
{
if (result == NULL) result = g_expr_block_new(dinstr);
else g_expr_block_add_item(G_EXPR_BLOCK(result), dinstr);
}
//printf(" ... return %p\n", result);
return result;
}
#endif