/* OpenIDA - Outil d'analyse de fichiers binaires
* exe_format.h - support des formats d'exécutables
*
* Copyright (C) 2008-2009 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 "exe_format.h"
#include
#include
#include "exe_format-int.h"
#include "elf/e_elf.h"
#include "java/e_java.h"
#include "pe/e_pe.h"
#include "../panel/log.h"
#define _(str) str
/* ------------------------ DETECTION DE FORMATS EXECUTABLES ------------------------ */
/* Format d'exécutables enregistré */
typedef struct _registered_exe_format
{
const char *name; /* Désignation du format */
exe_match_fc match; /* Procédure de reconnaissance */
exe_load_fc load; /* Fonction de chargement */
} registered_exe_format;
/* Liste des formats d'exécutables enregistrés */
static registered_exe_format *exe_formats = NULL;
static size_t exe_formats_count = 0;
/* Enregistre la disponibilité d'un nouveau format exécutable. */
void register_exe_format(const char *, exe_match_fc, exe_load_fc);
/* ---------------------------------------------------------------------------------- */
/* MANIPULATION DES PARTIES DE CODE */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : - *
* *
* Description : Crée une description de partie de code vierge. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
bin_part *create_bin_part(void)
{
bin_part *result; /* Structure à renvoyer */
result = (bin_part *)calloc(1, sizeof(bin_part));
return result;
}
/******************************************************************************
* *
* Paramètres : part = description de partie à mettre à jour. *
* name = nom à donner à la partie. *
* *
* Description : Attribue une description humaine à une partie de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void set_bin_part_name(bin_part *part, const char *name)
{
if (part->name != NULL) free(part->name);
part->name = strdup(name);
}
/******************************************************************************
* *
* Paramètres : part = description de partie à mettre à jour. *
* offset = position de la section à conserver. *
* size = taille de la section à conserver. *
* voffset = adresse virtuelle de la section à conserver. *
* *
* Description : Définit les valeurs utiles d'une partie de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void set_bin_part_values(bin_part *part, off_t offset, off_t size, uint64_t voffset)
{
part->offset = offset;
part->size = size;
part->voffset = voffset;
}
/******************************************************************************
* *
* Paramètres : part = description de partie à mettre à jour. *
* offset = position de la section à donner. [OUT] *
* size = taille de la section à donner. [OUT] *
* voffset = adresse virtuelle de la section à donner. [OUT] *
* *
* Description : Fournit les valeurs utiles d'une partie de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void get_bin_part_values(const bin_part *part, off_t *offset, off_t *size, uint64_t *voffset)
{
if (offset != NULL) *offset = part->offset;
if (size != NULL) *size = part->size;
if (voffset != NULL) *voffset = part->voffset;
}
/******************************************************************************
* *
* Paramètres : part = description de partie à effacer. *
* *
* Description : Supprime de la mémoire une description de partie de code. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void delete_bin_part(bin_part *part)
{
if (part->name != NULL) free(part->name);
free(part);
}
/******************************************************************************
* *
* Paramètres : a = premières informations à consulter. *
* b = secondes informations à consulter. *
* *
* Description : Etablit la comparaison entre deux blocs binaires. *
* *
* Retour : Bilan : -1 (a < b), 0 (a == b) ou 1 (a > b). *
* *
* Remarques : - *
* *
******************************************************************************/
int compare_bin_parts(const bin_part **a, const bin_part **b)
{
int result; /* Bilan à renvoyer */
if ((*a)->offset < (*b)->offset) result = -1;
else if((*a)->offset > (*b)->offset) result = 1;
else result = 0;
return result;
}
/* ---------------------------------------------------------------------------------- */
/* DETECTION DE FORMATS EXECUTABLES */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : - *
* *
* Description : Procède au chargement des formats d'exécutables reconnus. *
* *
* Retour : true pour indiquer un chargement réussi, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
bool init_all_exe_formats(void)
{
register_exe_format(_("ELF"), elf_is_matching, load_elf);
register_exe_format(_("Java"), java_is_matching, load_java);
register_exe_format(_("Portable Executable"), pe_is_matching, load_pe);
return true;
}
/******************************************************************************
* *
* Paramètres : name = désignation humaine associée. *
* match = procédure de reconnaissance fournie. *
* load = fonction de chargement fournie. *
* *
* Description : Enregistre la disponibilité d'un nouveau format exécutable. *
* *
* Retour : - *
* *
* Remarques : - *
* *
******************************************************************************/
void register_exe_format(const char *name, exe_match_fc match, exe_load_fc load)
{
exe_formats = (registered_exe_format *)realloc(exe_formats,
++exe_formats_count * sizeof(registered_exe_format));
exe_formats[exe_formats_count - 1].name = name;
exe_formats[exe_formats_count - 1].match = match;
exe_formats[exe_formats_count - 1].load = load;
}
/******************************************************************************
* *
* Paramètres : content = contenu binaire à parcourir. *
* length = taille du contenu en question. *
* *
* Description : Charge si possible un nouvel exécutable binaire. *
* *
* Retour : Adresse du nouveau gestionnaire de format ou NULL si erreur. *
* *
* Remarques : - *
* *
******************************************************************************/
exe_format *load_new_exe_format(const uint8_t *content, off_t length)
{
exe_format *result; /* Adresse à retourner */
size_t i; /* Boucle de parcours */
result = NULL;
for (i = 0; i < exe_formats_count && result == NULL; i++)
if (exe_formats[i].match(content, length))
{
log_variadic_message(LMT_INFO, _("%s is matching..."), exe_formats[i].name);
result = exe_formats[i].load(content, length);
}
return result;
}
/* ---------------------------------------------------------------------------------- */
/* MANIPULATION DES PARTIES DE CODE */
/* ---------------------------------------------------------------------------------- */
/******************************************************************************
* *
* Paramètres : format = description de l'exécutable à consulter. *
* target = nom de la section recherchée. *
* length = taille du contenu à fournir. [OUT] *
* *
* Description : Fournit une référence vers le contenu binaire analysé. *
* *
* Retour : Adresse du tampon contenant le contenu du binaire. *
* *
* Remarques : - *
* *
******************************************************************************/
const uint8_t *get_exe_content(const exe_format *format, off_t *length)
{
if (length != NULL) *length = format->length;
return format->content;
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* *
* Description : Indique le type d'architecture visée par le format. *
* *
* Retour : Identifiant de l'architecture ciblée par le format. *
* *
* Remarques : - *
* *
******************************************************************************/
FormatTargetMachine get_exe_target_machine(const exe_format *format)
{
return format->get_target_machine(format);
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* *
* Description : Fournit l'adresse mémoire du point d'entrée du programme. *
* *
* Retour : Adresse de mémoire. *
* *
* Remarques : - *
* *
******************************************************************************/
uint64_t get_exe_entry_point(const exe_format *format)
{
return format->get_entry_point(format);
}
/******************************************************************************
* *
* Paramètres : format = description de l'exécutable à consulter. *
* target = nom de la section recherchée. *
* offset = position de la section trouvée. [OUT] *
* size = taille de la section trouvée. [OUT] *
* voffset = adresse virtuelle de la section trouvée. [OUT] *
* *
* Description : Recherche une section donnée au sein de binaire. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
bool find_exe_section(const exe_format *format, const char *target, off_t *offset, off_t *size, uint64_t *voffset)
{
return format->find_section(format, target, offset, size, voffset);
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* labels = liste des commentaires à insérer. [OUT] *
* types = type des symboles listés. [OUT] *
* offsets = liste des indices des commentaires. [OUT] *
* *
* Description : Récupère tous les symboles présents dans le contenu binaire. *
* *
* Retour : Nombre d'éléments mis en place. *
* *
* Remarques : - *
* *
******************************************************************************/
size_t get_exe_symbols(const exe_format *format, char ***labels, SymbolType **types, uint64_t **offsets)
{
return format->get_symbols(format, labels, types, offsets);
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* labels = liste des commentaires à insérer. [OUT] *
* types = type des symboles listés. [OUT] *
* offsets = liste des indices des commentaires. [OUT] *
* *
* Description : Récupère tous les éléments identifiées dans le binaire. *
* *
* Retour : Nombre d'éléments mis en place. *
* *
* Remarques : - *
* *
******************************************************************************/
size_t get_exe_resolved_items(const exe_format *format, char ***labels, ResolvedType **types, uint64_t **offsets)
{
return format->get_resolved(format, labels, types, offsets);
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* label = étiquette du symbole si trouvé. [OUT] *
* type = type du symbole trouvé. [OUT] *
* address = adresse à cibler, puis décallage final. [OUT] *
* *
* Description : Recherche le symbole correspondant à une adresse. *
* *
* Retour : true si l'opération a été un succès, false sinon. *
* *
* Remarques : - *
* *
******************************************************************************/
bool resolve_exe_symbol(const exe_format *format, char **label, SymbolType *type, vmpa_t *address)
{
return format->resolve_symbol(format, label, type, address);
}
/******************************************************************************
* *
* Paramètres : format = informations chargées à consulter. *
* count = taille du tableau créé. [OUT] *
* *
* Description : Fournit le prototype de toutes les routines détectées. *
* *
* Retour : Tableau créé ou NULL si aucun symbole de routine trouvé. *
* *
* Remarques : - *
* *
******************************************************************************/
GBinRoutine **get_all_exe_routines(const exe_format *format, size_t *count)
{
return format->get_all_routines(format, count);
}