/* Chrysalide - Outil d'analyse de fichiers binaires
* format.c - support des différents formats binaires
*
* Copyright (C) 2009-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 "format.h"
#include
#include
#include
#include
#include "format-int.h"
#include "preload.h"
#include "../arch/processor.h"
#include "../common/sort.h"
#include "../plugins/pglist.h"
/* Initialise la classe des formats binaires génériques. */
static void g_binary_format_class_init(GBinFormatClass *);
/* Initialise une instance de format binaire générique. */
static void g_binary_format_init(GBinFormat *);
/* Supprime toutes les références externes. */
static void g_binary_format_dispose(GBinFormat *);
/* Procède à la libération totale de la mémoire. */
static void g_binary_format_finalize(GBinFormat *);
/* ---------------------- RASSEMBLEMENT ET GESTION DE SYMBOLES ---------------------- */
/* Retire un symbole de la collection du format binaire. */
static void _g_binary_format_remove_symbol(GBinFormat *, size_t);
/* Supprime les éventuels doublons au sein des symboles. */
static void g_binary_format_delete_duplicated_symbols(GBinFormat *);
/* Recherche le symbole associé à une adresse. */
static bool _g_binary_format_find_symbol(const GBinFormat *, const vmpa2t *, __compar_fn_t, size_t *, GBinSymbol **);
/* Indique le type défini pour un format binaire générique. */
G_DEFINE_TYPE(GBinFormat, g_binary_format, G_TYPE_OBJECT);
/******************************************************************************
* *
* Paramètres : klass = classe à initialiser. *
* *
* Description : Initialise la classe des formats binaires génériques. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_binary_format_class_init(GBinFormatClass *klass)
{
GObjectClass *object; /* Autre version de la classe */
object = G_OBJECT_CLASS(klass);
object->dispose = (GObjectFinalizeFunc/* ! */)g_binary_format_dispose;
object->finalize = (GObjectFinalizeFunc)g_binary_format_finalize;
}
/******************************************************************************
* *
* Paramètres : format = instance à initialiser. *
* *
* Description : Initialise une instance de format binaire générique. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_binary_format_init(GBinFormat *format)
{
g_rw_lock_init(&format->pt_lock);
format->info = g_preload_info_new();
g_rw_lock_init(&format->syms_lock);
#ifndef DEBUG
g_atomic_int_set(&format->sym_locked, 0);
#endif
format->errors = NULL;
format->error_count = 0;
g_mutex_init(&format->error_mutex);
#ifndef DEBUG
g_atomic_int_set(&format->error_locked, 0);
#endif
}
/******************************************************************************
* *
* Paramètres : format = instance d'objet GLib à traiter. *
* *
* Description : Supprime toutes les références externes. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_binary_format_dispose(GBinFormat *format)
{
g_object_unref(format->info);
g_rw_lock_clear(&format->syms_lock);
g_mutex_clear(&format->error_mutex);
G_OBJECT_CLASS(g_binary_format_parent_class)->dispose(G_OBJECT(format));
}
/******************************************************************************
* *
* Paramètres : format = instance d'objet GLib à traiter. *
* *
* Description : Procède à la libération totale de la mémoire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_binary_format_finalize(GBinFormat *format)
{
size_t i; /* Boucle de parcours */
if (format->errors != NULL)
{
for (i = 0; i < format->error_count; i++)
if (format->errors[i].desc != NULL)
free(format->errors[i].desc);
free(format->errors);
}
G_OBJECT_CLASS(g_binary_format_parent_class)->finalize(G_OBJECT(format));
}
/******************************************************************************
* *
* Paramètres : format = instance à traiter. *
* status = barre de statut à tenir informée. *
* *
* Description : Effectue les ultimes opérations de chargement d'un binaire. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_binary_format_complete_loading(GBinFormat *format, GtkStatusStack *status)
{
handle_binary_format(PGA_FORMAT_LOADER_LAST, format, status);
g_binary_format_delete_duplicated_symbols(format);
return true;
}
/******************************************************************************
* *
* Paramètres : format = description de l'exécutable à consulter. *
* content = contenu binaire à parcourir. *
* *
* Description : Définit le contenu binaire à analyser. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_binary_format_set_content(GBinFormat *format, GBinContent *content)
{
assert(format->content == NULL);
g_object_ref(G_OBJECT(content));
format->content = content;
}
/******************************************************************************
* *
* Paramètres : format = description de l'exécutable à consulter. *
* *
* Description : Fournit une référence vers le contenu binaire analysé. *
* *
* Retour : Gestionnaire de contenu binaire en place. *
* *
* Remarques : - *
* *
******************************************************************************/
GBinContent *g_binary_format_get_content(const GBinFormat *format)
{
g_object_ref(G_OBJECT(format->content));
return format->content;
}
/******************************************************************************
* *
* Paramètres : format = description de l'exécutable à consulter. *
* *
* Description : Indique le boutisme employé par le format binaire analysé. *
* *
* Retour : Boutisme associé au format. *
* *
* Remarques : - *
* *
******************************************************************************/
SourceEndian g_binary_format_get_endianness(const GBinFormat *format)
{
return G_BIN_FORMAT_GET_CLASS(format)->get_endian(format);
}
/******************************************************************************
* *
* Paramètres : format = description de l'exécutable à compléter. *
* pt = point de l'espace mémoire à considérer. *
* entry = nature du point fourni. *
* *
* Description : Enregistre une adresse comme début d'une zone de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_binary_format_register_code_point(GBinFormat *format, virt_t pt, bool entry)
{
g_rw_lock_writer_lock(&format->pt_lock);
if (entry)
{
format->entry_points = (virt_t *)realloc(format->entry_points,
++format->ep_count * sizeof(virt_t));
format->entry_points[format->ep_count - 1] = pt;
}
else
{
if (format->xp_count == format->xp_allocated)
{
format->xp_allocated += EXTRA_POINT_BLOCK;
format->extra_points = (virt_t *)realloc(format->extra_points,
format->xp_allocated * sizeof(virt_t));
}
format->extra_points[format->xp_count++] = pt;
}
g_rw_lock_writer_unlock(&format->pt_lock);
}
/******************************************************************************
* *
* Paramètres : format = description de l'exécutable à consulter. *
* ctx = contexte de désassemblage à préparer. *
* status = barre de statut à tenir informée. *
* *
* Description : Intègre dans un contexte les informations tirées d'un format.*
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_binary_format_preload_disassembling_context(GBinFormat *format, GProcContext *ctx, GtkStatusStack *status)
{
g_preload_info_copy(format->info, G_PRELOAD_INFO(ctx));
}
/******************************************************************************
* *
* Paramètres : format = description de l'exécutable à consulter. *
* ctx = contexte de désassemblage à préparer. *
* status = barre de statut à tenir informée. *
* *
* Description : Définit les points de départ d'un contexte de désassemblage. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_binary_format_activate_disassembling_context(GBinFormat *format, GProcContext *ctx, GtkStatusStack *status)
{
size_t i; /* Boucle de parcours */
g_rw_lock_reader_lock(&format->pt_lock);
for (i = 0; i < format->ep_count; i++)
g_proc_context_push_drop_point(ctx, DPL_ENTRY_POINT, format->entry_points[i]);
for (i = 0; i < format->xp_count; i++)
g_proc_context_push_drop_point(ctx, DPL_SYMBOL, format->extra_points[i]);
g_rw_lock_reader_unlock(&format->pt_lock);
}
/* ---------------------------------------------------------------------------------- */
/* RASSEMBLEMENT ET GESTION DE SYMBOLES */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : format = architecture à manipuler. *
* state = nouvel état de l'accès aux symboles. *
* *
* Description : Protège ou lève la protection de l'accès aux symboles. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_binary_format_lock_unlock_symbols_rd(GBinFormat *format, bool state)
{
#ifndef NDEBUG
gint test; /* Test de valeur courante */
#endif
if (state)
{
g_rw_lock_reader_lock(&format->syms_lock);
#ifndef NDEBUG
g_atomic_int_inc(&format->sym_locked);
#endif
}
else
{
#ifndef NDEBUG
test = g_atomic_int_add(&format->sym_locked, -1);
assert(test > 0);
#endif
g_rw_lock_reader_unlock(&format->syms_lock);
}
}
/******************************************************************************
* *
* Paramètres : format = architecture à manipuler. *
* state = nouvel état de l'accès aux symboles. *
* *
* Description : Protège ou lève la protection de l'accès aux symboles. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_binary_format_lock_unlock_symbols_wr(GBinFormat *format, bool state)
{
if (state)
{
g_rw_lock_writer_lock(&format->syms_lock);
#ifndef NDEBUG
g_atomic_int_set(&format->sym_locked, 1);
#endif
}
else
{
#ifndef NDEBUG
g_atomic_int_set(&format->sym_locked, 0);
#endif
g_rw_lock_writer_unlock(&format->syms_lock);
}
}
/******************************************************************************
* *
* Paramètres : format = architecture à consulter via la procédure. *
* *
* Description : Fournit la marque de dernière modification des symboles. *
* *
* Retour : Marque de la dernière modification de la liste de symboles. *
* *
* Remarques : - *
* *
******************************************************************************/
unsigned int g_binary_format_get_symbols_stamp(const GBinFormat *format)
{
return format->sym_stamp;
}
/******************************************************************************
* *
* Paramètres : format = format visé par la procédure. *
* *
* Description : Compte le nombre de symboles représentés. *
* *
* Retour : Nombre de symboles présents. *
* *
* Remarques : - *
* *
******************************************************************************/
size_t g_binary_format_count_symbols(const GBinFormat *format)
{
assert(g_atomic_int_get(&format->sym_locked) > 0);
return format->sym_count;
}
/******************************************************************************
* *
* Paramètres : format = format visé par la procédure. *
* index = indice du symbole visé. *
* *
* Description : Fournit un symbole lié à un format. *
* *
* Retour : Symbole conservé trouvé ou NULL si aucun. *
* *
* Remarques : - *
* *
******************************************************************************/
GBinSymbol *g_binary_format_get_symbol(const GBinFormat *format, size_t index)
{
GBinSymbol *result; /* Symbole à retourner */
assert(g_atomic_int_get(&format->sym_locked) > 0);
if (format->sym_count == 0)
result = NULL;
else
{
assert(index < format->sym_count);
result = format->symbols[index];
assert(result != NULL);
g_object_ref(G_OBJECT(result));
}
return result;
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à compléter. *
* symbol = symbole à ajouter à la liste. *
* *
* Description : Ajoute un symbole à la collection du format binaire. *
* *
* Retour : true si le symbole était bien localisé et a été inséré. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_binary_format_add_symbol(GBinFormat *format, GBinSymbol *symbol)
{
bool result; /* Statut d'ajout à retourner */
#ifndef NDEBUG
const mrange_t *range; /* Couverture du symbole */
const vmpa2t *addr; /* Emplacement du symbole */
#endif
size_t index; /* Indice du point d'insertion */
/**
* Pour que les fonctions de recherche basées sur _g_binary_format_find_symbol()
* fassent bien leur office, il faut que les symboles soient triés.
*
* Cependant, les localisations à satisfaire lors d'une recherche recontrent
* un problème si les positions physiques ne sont pas renseignées. En effet
* les adresses virtuelles en sont potentiellement décorrélées (c'est le cas
* avec le format ELF par exemple, où les zones en mémoire ne suivent pas le
* même ordre que les segments du binaire).
*
* Comme les comparaisons entre localisations se réalisent sur les éléments
* renseignés communs, à commencer par la position physique si c'est possible,
* une localisation s'appuyant uniquement sur une adresse virtuelle va être
* analysée suivant une liste non triée d'adresses virtuelles.
*
* On corrige donc le tir si besoin est en forçant la comparaison via les
* positions physiques.
*/
#ifndef NDEBUG
range = g_binary_symbol_get_range(symbol);
addr = get_mrange_addr(range);
assert(has_phys_addr(addr) || g_binary_symbol_get_status(symbol) == SSS_IMPORTED);
#endif
g_binary_format_lock_unlock_symbols_wr(format, true);
/**
* Avec tous les traitements parallèles, il est possible que plusieurs chemins d'exécution
* amènent à la création d'un même symbole.
*
* Plutôt que de verrouiller la liste des symboles en amont (et donc assez longtemps)
* pour faire une vérification avant construction puis ajout, on préfère limiter
* l'état figé à cette seule fonction, quitte à annuler le travail fourni pour la
* construction du symbole dans les cas peu fréquents où le symbole était déjà en place.
*/
result = bsearch_index(&symbol, format->symbols, format->sym_count,
sizeof(GBinSymbol *), (__compar_fn_t)g_binary_symbol_cmp, &index);
if (!result)
{
format->symbols = _qinsert(format->symbols, &format->sym_count,
sizeof(GBinSymbol *), &symbol, index);
format->sym_stamp++;
result = true;
}
else
g_object_unref(G_OBJECT(symbol));
g_binary_format_lock_unlock_symbols_wr(format, false);
return result;
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à compléter. *
* index = indice du symbole à retirer de la liste. *
* *
* Description : Retire un symbole de la collection du format binaire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void _g_binary_format_remove_symbol(GBinFormat *format, size_t index)
{
/**
* TODO : envoyer un signal pour avertir les opérandes concernées.
*/
assert(g_atomic_int_get(&format->sym_locked) == 1);
assert(index < format->sym_count);
if ((index + 1) < format->sym_count)
memmove(&format->symbols[index], &format->symbols[index + 1],
(format->sym_count - index - 1) * sizeof(GBinSymbol *));
format->symbols = (GBinSymbol **)realloc(format->symbols,
--format->sym_count * sizeof(GBinSymbol *));
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à compléter. *
* symbol = symbole à retirer de la liste. *
* *
* Description : Retire un symbole de la collection du format binaire. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_binary_format_remove_symbol(GBinFormat *format, GBinSymbol *symbol)
{
bool found; /* Jeton de présence */
size_t index; /* Indice du point de retrait */
g_binary_format_lock_unlock_symbols_wr(format, true);
found = bsearch_index(&symbol, format->symbols, format->sym_count,
sizeof(GBinSymbol *), (__compar_fn_t)g_binary_symbol_cmp, &index);
if (found)
_g_binary_format_remove_symbol(format, index);
g_binary_format_lock_unlock_symbols_wr(format, false);
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à corriger si besoin est. *
* *
* Description : Supprime les éventuels doublons au sein des symboles. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
static void g_binary_format_delete_duplicated_symbols(GBinFormat *format)
{
size_t i; /* Boucle de parcours */
const mrange_t *range; /* Emplacement à consulter */
mrange_t last; /* Dernière localisation vue */
size_t index; /* Indice de suppression */
g_binary_format_lock_unlock_symbols_wr(format, true);
if (format->sym_count > 1)
{
range = g_binary_symbol_get_range(format->symbols[0]);
copy_mrange(&last, range);
}
for (i = 1; i < format->sym_count; i++)
{
range = g_binary_symbol_get_range(format->symbols[i]);
if (cmp_vmpa(get_mrange_addr(&last), get_mrange_addr(range)) == 0)
{
/* TODO : établir une meilleur comparaison pour trouver le bon candidat */
/* TODO : (éviter de) traiter selon le type aussi */
index = (get_mrange_length(&last) == 0 ? i - 1 : i);
/*
printf("DELETE @ %zu / 0x%08x '%s'\n", index,
(unsigned int)last.addr.virtual,
g_binary_symbol_get_label(format->symbols[index]));
*/
_g_binary_format_remove_symbol(format, index);
i--;
}
copy_mrange(&last, range);
}
g_binary_format_lock_unlock_symbols_wr(format, false);
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* addr = adresse liée à la chaîne à traiter. *
* length = taille de la chaîne à représenter. *
* *
* Description : Construit une désignation pour chaîne de caractères. *
* *
* Retour : Chaîne de caractères à libérer de la mémoire. *
* *
* Remarques : - *
* *
******************************************************************************/
char *create_string_label(GBinFormat *format, const vmpa2t *addr, size_t length)
{
char *result; /* Nouvelle chaîne à retourner */
vmpa2t pos; /* Tête de lecture modifiable */
const bin_t *base; /* Contenu complet et original */
unsigned int wc; /* Nombre de mots rencontrés */
size_t iter; /* Tête d'écriture de recopie */
size_t i; /* Boucle de parcours */
bool empty; /* Base de l'étiquette vide ? */
GBinSymbol *found; /* Symbole similaire trouvé */
VMPA_BUFFER(last_sfx); /* Dernier suffixe à intégrer */
copy_vmpa(&pos, addr);
base = g_binary_content_get_raw_access(format->content, &pos, length);
if (base == NULL)
return NULL;
result = (char *)calloc(length + 5 + VMPA_MAX_LEN + 1, sizeof(char));
wc = 0;
iter = 0;
for (i = 0; i < length; i++)
{
if (isalnum(base[i])) result[iter++] = tolower(base[i]);
else if (iter > 0)
{
if (result[iter - 1] != '_') wc++;
if (wc == 3) break;
if (result[iter - 1] != '_') result[iter++] = '_';
}
}
/* Détermination du suffixe suffisant */
empty = (iter == 0);
if (iter > 0 && result[iter - 1] != '_') result[iter++] = '_';
strcpy(&result[iter], "str");
iter += 3;
found = NULL;
if (empty || g_binary_format_find_symbol_by_label(format, result, &found))
{
if (found != NULL)
g_object_unref(G_OBJECT(found));
if (iter > 0 && result[iter - 1] != '_') result[iter++] = '_';
assert(has_phys_addr(addr) || has_virt_addr(addr));
/* TODO : use_phy_instead_of_virt */
if (has_virt_addr(addr))
vmpa2_virt_to_string(addr, MDS_UNDEFINED, last_sfx, NULL);
else
vmpa2_phys_to_string(addr, MDS_UNDEFINED, last_sfx, NULL);
strcpy(&result[iter], last_sfx);
}
return result;
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* label = étiquette à retrouver lors des recherches. *
* symbol = éventuel symbole trouvé à déréfenrencer. [OUT] *
* *
* Description : Recherche le symbole correspondant à une étiquette. *
* *
* Retour : true si l'opération a été un succès, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_binary_format_find_symbol_by_label(GBinFormat *format, const char *label, GBinSymbol **symbol)
{
bool result; /* Bilan à retourner */
size_t i; /* Boucle de parcours */
const char *cur_lbl; /* Etiquette courante */
result = false;
g_binary_format_lock_symbols_rd(format);
for (i = 0; i < format->sym_count && !result; i++)
{
cur_lbl = g_binary_symbol_get_label(format->symbols[i]);
if (cur_lbl == NULL) continue;
if (strcmp(label, cur_lbl) == 0)
{
*symbol = format->symbols[i];
g_object_ref(G_OBJECT(*symbol));
result = true;
}
}
g_binary_format_unlock_symbols_rd(format);
return result;
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* addr = adresse à cibler lors des recherches. *
* fn = méthode de comparaison des symboles. *
* index = indice de l'éventuel symbole trouvé ou NULL. [OUT] *
* symbol = éventuel symbole trouvé à déréfenrencer. [OUT] *
* *
* Description : Recherche le symbole associé à une adresse. *
* *
* Retour : true si l'opération a été un succès, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
static bool _g_binary_format_find_symbol(const GBinFormat *format, const vmpa2t *addr, __compar_fn_t fn, size_t *index, GBinSymbol **symbol)
{
bool result; /* Bilan à retourner */
void *found; /* Résultat de recherches */
assert(g_atomic_int_get(&format->sym_locked) > 0);
/**
* Pour ce qui est des justifications quant à la vérification suivante,
* se référer aux commentaires placés dans g_binary_format_add_symbol().
*/
assert(has_phys_addr(addr));
found = bsearch(addr, format->symbols, format->sym_count, sizeof(GBinSymbol *), fn);
if (found != NULL)
{
if (index != NULL)
*index = (GBinSymbol **)found - format->symbols;
if (symbol != NULL)
{
*symbol = *(GBinSymbol **)found;
g_object_ref(G_OBJECT(*symbol));
}
result = true;
}
else
{
*symbol = NULL;
result = false;
}
return result;
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* addr = adresse à cibler lors des recherches. *
* symbol = éventuel symbole trouvé à déréfenrencer. [OUT] *
* *
* Description : Recherche le symbole correspondant à une adresse. *
* *
* Retour : true si l'opération a été un succès, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_binary_format_find_symbol_at(GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol)
{
bool result; /* Bilan à retourner */
int find_symbol(const vmpa2t *addr, const GBinSymbol **sym)
{
const mrange_t *range; /* Espace mémoire parcouru */
range = g_binary_symbol_get_range(*sym);
return cmp_vmpa(addr, get_mrange_addr(range));
}
g_binary_format_lock_symbols_rd(format);
result = _g_binary_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, NULL, symbol);
g_binary_format_unlock_symbols_rd(format);
return result;
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* addr = adresse à cibler lors des recherches. *
* symbol = éventuel symbole trouvé à déréfenrencer. [OUT] *
* *
* Description : Recherche le symbole contenant une adresse. *
* *
* Retour : true si l'opération a été un succès, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_binary_format_find_symbol_for(GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol)
{
bool result; /* Bilan à retourner */
int find_symbol(const vmpa2t *addr, const GBinSymbol **sym)
{
const mrange_t *range; /* Espace mémoire parcouru */
range = g_binary_symbol_get_range(*sym);
return cmp_mrange_with_vmpa(range, addr);
}
g_binary_format_lock_symbols_rd(format);
result = _g_binary_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, NULL, symbol);
g_binary_format_unlock_symbols_rd(format);
return result;
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* addr = adresse à cibler lors des recherches. *
* symbol = éventuel symbole trouvé à déréfenrencer. [OUT] *
* *
* Description : Recherche le symbole suivant celui lié à une adresse. *
* *
* Retour : true si l'opération a été un succès, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_binary_format_find_next_symbol_at(GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol)
{
bool result; /* Bilan à retourner */
size_t index; /* Indice à considérer */
int find_symbol(const vmpa2t *addr, const GBinSymbol **sym)
{
const mrange_t *range; /* Espace mémoire parcouru */
range = g_binary_symbol_get_range(*sym);
return cmp_mrange_with_vmpa(range, addr);
}
g_binary_format_lock_symbols_rd(format);
result = _g_binary_format_find_symbol(format, addr, (__compar_fn_t)find_symbol, &index, NULL);
if (result && (index + 1) < format->sym_count)
{
*symbol = format->symbols[index + 1];
g_object_ref(G_OBJECT(*symbol));
}
else
{
*symbol = NULL;
result = false;
}
g_binary_format_unlock_symbols_rd(format);
return result;
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* addr = adresse à cibler lors des recherches. *
* strict = indication de tolérance acceptée. *
* symbol = éventuel symbole trouvé à déréfenrencer. [OUT] *
* diff = décalage entre l'adresse et le symbole. [OUT] *
* *
* Description : Recherche le symbole correspondant à une adresse. *
* *
* Retour : true si l'opération a été un succès, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_binary_format_resolve_symbol(GBinFormat *format, const vmpa2t *addr, bool strict, GBinSymbol **symbol, phys_t *diff)
{
bool result; /* Bilan à retourner */
const mrange_t *range; /* Espace mémoire parcouru */
if (strict)
result = g_binary_format_find_symbol_at(format, addr, symbol);
else
result = g_binary_format_find_symbol_for(format, addr, symbol);
if (result)
{
range = g_binary_symbol_get_range(*symbol);
*diff = compute_vmpa_diff(get_mrange_addr(range), addr);
assert(!strict || *diff == 0);
}
else
*diff = 0;
return result;
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* count = taille de la liste retournée. [OUT] *
* defsrc = fichier de code principal. [OUT] *
* *
* Description : Fournit la liste des fichiers source détectés. *
* *
* Retour : Liste de noms de fichier ou NULL si aucun. *
* *
* Remarques : - *
* *
******************************************************************************/
const char * const *g_binary_format_get_source_files(const GBinFormat *format, size_t *count, size_t *defsrc)
{
*count = format->src_count;
*defsrc = format->def_source;
return format->src_files;
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* buffer = tampon mis à disposition pour la sortie. *
* filename = nom du fichier source à cibler. *
* *
* Description : Procède à la décompilation complète du format. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
#if 0
void g_binary_format_decompile(const GBinFormat *format, GCodeBuffer *buffer, const char *filename)
{
GBinRoutine **routines;
size_t count;
size_t i;
GDecInstruction *instr;
if (format->decompile != NULL)
format->decompile(format, buffer, filename);
routines = g_binary_format_get_routines(format, &count);
for (i = 0; i < count; i++)
{
//printf(" -- %s --\n", g_binary_routine_get_name(routines[i]));
//if (strcmp("cryptself", g_binary_routine_get_name(routines[i])) == 0)
{
instr = g_binary_routine_get_decomp_instructions(routines[i]);
if (instr == NULL) continue;
//g_dec_instruction_print(instr, buffer, NULL, g_java_output_new());
}
}
}
#endif
/* ---------------------------------------------------------------------------------- */
/* CONSERVATION DES SOUCIS DURANT LE CHARGEMENT */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : format = architecture à manipuler. *
* state = nouvel état de l'accès aux erreurs relevées. *
* *
* Description : Protège ou lève la protection de l'accès aux erreurs. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_binary_format_lock_unlock_errors(GBinFormat *format, bool state)
{
if (state)
{
g_mutex_lock(&format->error_mutex);
g_atomic_int_set(&format->error_locked, 1);
}
else
{
g_atomic_int_set(&format->error_locked, 0);
g_mutex_unlock(&format->error_mutex);
}
}
/******************************************************************************
* *
* Paramètres : format = architecture concernée par la procédure. *
* index = indice du problème visé. *
* type = type d'erreur retrouvée. *
* addr = localisation associée. *
* desc = éventuelle description humaine de description. *
* *
* Description : Etend la liste des soucis détectés avec de nouvelles infos. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void g_binary_format_add_error(GBinFormat *format, BinaryFormatError type, const vmpa2t *addr, const char *desc)
{
fmt_error *error; /* Raccourci de confort */
g_binary_format_lock_errors(format);
format->errors = realloc(format->errors, ++format->error_count * sizeof(fmt_error));
error = &format->errors[format->error_count - 1];
error->type = type;
copy_vmpa(&error->addr, addr);
if (desc != NULL)
error->desc = strdup(desc);
else
error->desc = NULL;
g_binary_format_unlock_errors(format);
}
/******************************************************************************
* *
* Paramètres : format = architecture à consulter durant la procédure. *
* *
* Description : Indique le nombre d'erreurs relevées au niveau assembleur. *
* *
* Retour : Nombre d'erreurs en stock. *
* *
* Remarques : - *
* *
******************************************************************************/
size_t g_binary_format_count_errors(GBinFormat *format)
{
size_t result; /* Quantité à retourner */
assert(g_atomic_int_get(&format->error_locked) == 1);
result = format->error_count;
return result;
}
/******************************************************************************
* *
* Paramètres : format = architecture concernée par la procédure. *
* index = indice du problème visé. *
* type = type d'erreur retrouvée. [OUT] *
* addr = localisation associée. [OUT] *
* desc = éventuelle description humaine de description. [OUT]*
* *
* Description : Fournit les éléments concernant un soucis détecté. *
* *
* Retour : Validité des informations renseignées. *
* *
* Remarques : - *
* *
******************************************************************************/
bool g_binary_format_get_error(GBinFormat *format, size_t index, BinaryFormatError *type, vmpa2t *addr, char **desc)
{
bool result; /* Bilan à retourner */
fmt_error *error; /* Raccourci de confort */
assert(g_atomic_int_get(&format->error_locked) == 1);
result = (index < format->error_count);
assert(result);
if (result)
{
error = &format->errors[index];
*type = error->type;
copy_vmpa(addr, &error->addr);
if (error->desc != NULL)
*desc = strdup(error->desc);
else
*desc = NULL;
}
return result;
}