diff options
Diffstat (limited to 'src/format')
| -rwxr-xr-x | src/format/dex/dex.c | 23 | ||||
| -rw-r--r-- | src/format/elf/Makefile.am | 1 | ||||
| -rw-r--r-- | src/format/elf/dynamic.c | 109 | ||||
| -rw-r--r-- | src/format/elf/dynamic.h | 41 | ||||
| -rw-r--r-- | src/format/elf/elf-int.c | 39 | ||||
| -rw-r--r-- | src/format/elf/elf-int.h | 3 | ||||
| -rw-r--r-- | src/format/elf/elf.c | 23 | ||||
| -rw-r--r-- | src/format/elf/elf_def.h | 20 | ||||
| -rw-r--r-- | src/format/elf/symbols.c | 288 | ||||
| -rw-r--r-- | src/format/exe_format.c | 19 | ||||
| -rw-r--r-- | src/format/exe_format.h | 4 | ||||
| -rw-r--r-- | src/format/executable-int.h | 4 | ||||
| -rw-r--r-- | src/format/executable.c | 19 | ||||
| -rw-r--r-- | src/format/executable.h | 3 | ||||
| -rw-r--r-- | src/format/format-int.h | 3 | ||||
| -rw-r--r-- | src/format/format.c | 20 | ||||
| -rw-r--r-- | src/format/format.h | 5 | ||||
| -rwxr-xr-x | src/format/java/java.c | 23 | ||||
| -rw-r--r-- | src/format/pe/pe.c | 23 | ||||
| -rw-r--r-- | src/format/symbol.h | 1 |
20 files changed, 489 insertions, 182 deletions
diff --git a/src/format/dex/dex.c b/src/format/dex/dex.c index 579abde..94ec34a 100755 --- a/src/format/dex/dex.c +++ b/src/format/dex/dex.c @@ -54,9 +54,6 @@ static void g_dex_format_decompile(const GDexFormat *, GCodeBuffer *, const char /* Indique le type d'architecture visée par le format. */ static FormatTargetMachine g_dex_format_get_target_machine(const GDexFormat *); -/* Fournit l'adresse mémoire du point d'entrée du programme. */ -static vmpa_t g_dex_format_get_entry_point(const GDexFormat *); - /* Fournit les références aux zones binaires à analyser. */ static GBinPart **g_dex_format_get_parts(const GDexFormat *, size_t *); @@ -142,7 +139,6 @@ static void g_dex_format_init(GDexFormat *format) exe_format = G_EXE_FORMAT(format); exe_format->get_machine = (get_target_machine_fc)g_dex_format_get_target_machine; - exe_format->get_entry_point = (get_entry_point_fc)g_dex_format_get_entry_point; exe_format->get_parts = (get_parts_fc)g_dex_format_get_parts; exe_format->translate_addr = (translate_addr_fc)g_dex_format_translate_address_into_offset; @@ -357,25 +353,6 @@ static FormatTargetMachine g_dex_format_get_target_machine(const GDexFormat *for /****************************************************************************** * * * 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 : - * -* * -******************************************************************************/ - -static vmpa_t g_dex_format_get_entry_point(const GDexFormat *format) -{ - return 0;//(format->is_32b ? format->header.e_entry.addr32 : format->header.e_entry.addr64); - -} - - -/****************************************************************************** -* * -* Paramètres : format = informations chargées à consulter. * * count = quantité de zones listées. [OUT] * * * * Description : Fournit les références aux zones binaires à analyser. * diff --git a/src/format/elf/Makefile.am b/src/format/elf/Makefile.am index 67fe148..4317e1d 100644 --- a/src/format/elf/Makefile.am +++ b/src/format/elf/Makefile.am @@ -5,6 +5,7 @@ libformatelf_la_SOURCES = \ elf-int.h elf-int.c \ elf.h elf.c \ elf_def.h \ + dynamic.h dynamic.c \ helper_arm.h helper_arm.c \ helper_x86.h helper_x86.c \ program.h program.c \ diff --git a/src/format/elf/dynamic.c b/src/format/elf/dynamic.c new file mode 100644 index 0000000..e1f50b0 --- /dev/null +++ b/src/format/elf/dynamic.c @@ -0,0 +1,109 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * program.c - gestion des en-têtes de programme d'un ELF + * + * 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 <http://www.gnu.org/licenses/>. + */ + + +#include "dynamic.h" + + +#include "elf-int.h" +#include "program.h" + + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à consulter. * +* index = indice de la section recherchée. * +* dynamic = ensemble d'informations à faire remonter. [OUT] * +* * +* Description : Recherche un en-tête de programme DYNAMIC au sein de binaire.* +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool find_elf_dynamic_program_header(const GElfFormat *format, elf_phdr *dynamic) +{ + bool result; /* Bilan d'opération à renvoyer*/ + uint16_t max; /* Nombre d'en-têtes présents */ + uint16_t i; /* Boucle de parcours */ + + result = false; + + max = ELF_HDR(format, format->header, e_phnum); + + for (i = 0; i < max && !result; i++) + { + if (!find_elf_program_by_index(format, i, dynamic)) + break; + + result = (ELF_PHDR(format, *dynamic, p_type) == PT_DYNAMIC); + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : format = informations chargées à consulter. * +* dynamic = programme de type PT_DYNAMIC. * +* type = sorte d'élément recherché. * +* item = élément retrouvé dans la section. [OUT] * +* * +* Description : Retrouve un élément donné dans la section dynamique. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool find_elf_dynamic_item_from_pheader(const GElfFormat *format, const elf_phdr *dynamic, int64_t type, elf_dyn *item) +{ + bool result; /* Bilan à retourner */ + off_t max; /* Nombre d'entités présentes */ + off_t i; /* Boucle de parcours */ + off_t pos; /* Position de lecture */ + + result = false; + + max = ELF_PHDR(format, *dynamic, p_filesz) / ELF_SIZEOF_DYN(format); + + for (i = 0; i < max && !result; i++) + { + pos = ELF_PHDR(format, *dynamic, p_offset) + i * ELF_SIZEOF_DYN(format); + + if (!read_elf_dynamic_entry(format, &pos, item)) + break; + + result = (ELF_DYN(format, *item, d_tag) == type); + + } + + return result; + +} diff --git a/src/format/elf/dynamic.h b/src/format/elf/dynamic.h new file mode 100644 index 0000000..1de8ee1 --- /dev/null +++ b/src/format/elf/dynamic.h @@ -0,0 +1,41 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * dynamic.h - prototypes pour la manipulation de l'en-ête de programme 'DYNAMIC' + * + * Copyright (C) 2015 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 <http://www.gnu.org/licenses/>. + */ + + +#ifndef _FORMAT_ELF_DYNAMIC_H +#define _FORMAT_ELF_DYNAMIC_H + + +#include "elf.h" +#include "elf_def.h" + + + +/* Recherche un en-tête de programme DYNAMIC au sein de binaire. */ +bool find_elf_dynamic_program_header(const GElfFormat *, elf_phdr *); + +/* Retrouve un élément donné dans la section dynamique. */ +bool find_elf_dynamic_item_from_pheader(const GElfFormat *, const elf_phdr *, int64_t, elf_dyn *); + + + +#endif /* _FORMAT_ELF_DYNAMIC_H */ diff --git a/src/format/elf/elf-int.c b/src/format/elf/elf-int.c index 677a9ef..a2ef9b2 100644 --- a/src/format/elf/elf-int.c +++ b/src/format/elf/elf-int.c @@ -251,6 +251,45 @@ bool read_elf_section_header(const GElfFormat *format, off_t pos, elf_shdr *sect * * * Paramètres : format = informations chargées à consulter. * * pos = position de début de lecture. [OUT] * +* dyn = structure lue à retourner. [OUT] * +* * +* Description : Procède à la lecture d'une entrée de type 'DYNAMIC' ELF. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool read_elf_dynamic_entry(const GElfFormat *format, off_t *pos, elf_dyn *dyn) +{ + bool result; /* Bilan à retourner */ + const bin_t *content; /* Contenu binaire à lire */ + off_t length; /* Taille totale du contenu */ + + content = G_BIN_FORMAT(format)->content; + length = G_BIN_FORMAT(format)->length; + + if (format->is_32b) + { + result = read_s32(&dyn->dyn32.d_tag, content, pos, length, format->endian); + result &= read_u32(&dyn->dyn32.d_un.d_val, content, pos, length, format->endian); + } + else + { + result = read_s64(&dyn->dyn64.d_tag, content, pos, length, format->endian); + result &= read_u64(&dyn->dyn64.d_un.d_val, content, pos, length, format->endian); + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : format = informations chargées à consulter. * +* pos = position de début de lecture. [OUT] * * sym = structure lue à retourner. [OUT] * * * * Description : Procède à la lecture d'un symbole ELF. * diff --git a/src/format/elf/elf-int.h b/src/format/elf/elf-int.h index 783d27e..34b6cc9 100644 --- a/src/format/elf/elf-int.h +++ b/src/format/elf/elf-int.h @@ -61,6 +61,9 @@ bool read_elf_program_header(const GElfFormat *, off_t *, elf_phdr *); /* Procède à la lecture d'une en-tête de section ELF. */ bool read_elf_section_header(const GElfFormat *, off_t, elf_shdr *); +/* Procède à la lecture d'une entrée de type 'DYNAMIC' ELF. */ +bool read_elf_dynamic_entry(const GElfFormat *, off_t *, elf_dyn *); + /* Procède à la lecture d'un symbole ELF. */ bool read_elf_symbol(const GElfFormat *, off_t *, elf_sym *); diff --git a/src/format/elf/elf.c b/src/format/elf/elf.c index 6d2138a..00af26d 100644 --- a/src/format/elf/elf.c +++ b/src/format/elf/elf.c @@ -59,9 +59,6 @@ static void g_elf_format_init(GElfFormat *); /* Indique le type d'architecture visée par le format. */ static FormatTargetMachine g_elf_format_get_target_machine(const GElfFormat *); -/* Fournit l'adresse mémoire du point d'entrée du programme. */ -static vmpa_t g_elf_format_get_entry_point(const GElfFormat *); - /* Etend la définition des portions au sein d'un binaire. */ static void g_elf_format_refine_portions(const GElfFormat *, GBinPortion *); @@ -145,7 +142,6 @@ static void g_elf_format_init(GElfFormat *format) exe_format = G_EXE_FORMAT(format); exe_format->get_machine = (get_target_machine_fc)g_elf_format_get_target_machine; - exe_format->get_entry_point = (get_entry_point_fc)g_elf_format_get_entry_point; exe_format->refine_portions = (refine_portions_fc)g_elf_format_refine_portions; exe_format->get_parts = (get_parts_fc)g_elf_format_get_parts; @@ -280,25 +276,6 @@ static FormatTargetMachine g_elf_format_get_target_machine(const GElfFormat *for /****************************************************************************** * * * 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 : - * -* * -******************************************************************************/ - -static vmpa_t g_elf_format_get_entry_point(const GElfFormat *format) -{ - return ELF_HDR(format, format->header, e_entry); - -} - - -/****************************************************************************** -* * -* Paramètres : format = informations chargées à consulter. * * raw = portion de binaire brut à raffiner. * * * * Description : Etend la définition des portions au sein d'un binaire. * diff --git a/src/format/elf/elf_def.h b/src/format/elf/elf_def.h index b02469a..a43b417 100644 --- a/src/format/elf/elf_def.h +++ b/src/format/elf/elf_def.h @@ -278,7 +278,7 @@ typedef union _elf_phdr } elf_phdr; -#define ELF_PHDR(fmt, hdr, fld) (fmt->is_32b ? hdr.phdr32.fld : hdr.phdr64.fld) +#define ELF_PHDR(fmt, hdr, fld) (fmt->is_32b ? (hdr).phdr32.fld : (hdr).phdr64.fld) #define ELF_SIZEOF_PHDR(fmt) (fmt->is_32b ? sizeof(elf32_phdr) : sizeof(elf64_phdr)) @@ -481,6 +481,20 @@ typedef union _elf_dyn #define DT_JMPREL 23 /* Relocalisations PLT */ +#define DT_PLTGOT 3 /* Processor defined value */ + +#define DT_INIT 12 /* Address of init function */ +#define DT_FINI 13 /* Address of termination function */ + +#define DT_INIT_ARRAY 25 /* Array with addresses of init fct */ +#define DT_FINI_ARRAY 26 /* Array with addresses of fini fct */ +#define DT_INIT_ARRAYSZ 27 /* Size in bytes of DT_INIT_ARRAY */ +#define DT_FINI_ARRAYSZ 28 /* Size in bytes of DT_FINI_ARRAY */ + +#define DT_PREINIT_ARRAY 32 /* Array with addresses of preinit fct*/ +#define DT_PREINIT_ARRAYSZ 33 /* size in bytes of DT_PREINIT_ARRAY */ + + /* ---------------------------- SYMBOLES DE BINAIRES ELF ---------------------------- */ @@ -517,7 +531,7 @@ typedef union _elf_sym } elf_sym; -#define ELF_SYM(fmt, sb, fld) (fmt->is_32b ? sb.sym32.fld : sb.sym64.fld) +#define ELF_SYM(fmt, sb, fld) (fmt->is_32b ? (sb).sym32.fld : (sb).sym64.fld) #define ELF_ST_BIND(fmt, sym) (fmt->is_32b ? ELF32_ST_BIND(sym.sym32.st_info) : ELF64_ST_BIND(sym.sym64.st_info)) #define ELF_ST_TYPE(fmt, sym) (fmt->is_32b ? ELF32_ST_TYPE(sym.sym32.st_info) : ELF64_ST_TYPE(sym.sym64.st_info)) @@ -568,7 +582,7 @@ typedef union _elf_rel } elf_rel; -#define ELF_REL(fmt, rl, fld) (fmt->is_32b ? rl.rel32.fld : rl.rel64.fld) +#define ELF_REL(fmt, rl, fld) (fmt->is_32b ? (rl).rel32.fld : (rl).rel64.fld) #define ELF_REL_SYM(fmt, rl) (fmt->is_32b ? ELF32_R_SYM(rl.rel32.r_info) : ELF64_R_SYM(rl.rel64.r_info)) #define ELF_REL_TYPE(fmt, rl) (fmt->is_32b ? ELF32_R_TYPE(rl.rel32.r_info) : ELF64_R_TYPE(rl.rel64.r_info)) diff --git a/src/format/elf/symbols.c b/src/format/elf/symbols.c index d69e41a..2d8057e 100644 --- a/src/format/elf/symbols.c +++ b/src/format/elf/symbols.c @@ -24,6 +24,7 @@ #include "symbols.h" +#include <assert.h> #include <malloc.h> #include <string.h> @@ -31,9 +32,11 @@ #include <i18n.h> +#include "dynamic.h" #include "elf-int.h" #include "helper_arm.h" #include "helper_x86.h" +#include "program.h" #include "section.h" #include "../mangling/demangler.h" #include "../../arch/raw.h" @@ -44,6 +47,12 @@ +/* Enregistre un point d'entrée au sein d'un binaire ELF. */ +static void register_elf_entry_point(GElfFormat *, virt_t, phys_t, GBinRoutine *); + +/* Enumère tous les points d'entrée principaux d'un binaire ELF. */ +static bool load_all_elf_basic_entry_points(GElfFormat *); + @@ -115,18 +124,17 @@ bool load_elf_symbols(GElfFormat *format) { bool result; /* Bilan à retourner */ - virt_t entry_point; - vmpa2t addr; /* Localisation d'une routine */ - mrange_t range; /* Couverture mémoire associée */ - GBinRoutine *routine; /* Nouvelle routine trouvée */ - GBinSymbol *symbol; /* Nouveau symbole construit */ - elf_shdr *sections; /* Groupe de sections trouvées */ size_t count; /* Quantité de données */ result = true; + + result &= load_all_elf_basic_entry_points(format); + + + #if 1 annotate_elf_header(format); @@ -143,31 +151,6 @@ bool load_elf_symbols(GElfFormat *format) - entry_point = ELF_HDR(format, format->header, e_entry); - - G_BIN_FORMAT(format)->entry_point = entry_point; - - - - printf("E_ENTRY : 0x%08lx\n", (unsigned long)entry_point); - - if (ELF_HDR(format, format->header, e_machine) == EM_ARM) - entry_point &= ~0x1; - - - init_vmpa(&addr, VMPA_NO_PHYSICAL, entry_point); - - init_mrange(&range, &addr, 0); - - routine = try_to_demangle_routine("entry_point"); - - g_binary_routine_set_range(routine, &range); - - symbol = g_binary_symbol_new(STP_ROUTINE, "entry_point", ~0); - g_binary_symbol_attach_routine(symbol, routine); - g_binary_format_add_symbol(G_BIN_FORMAT(format), symbol); - - /* Symboles externes */ #if 1 if (find_elf_sections_by_type(format, SHT_DYNAMIC, §ions, &count)) @@ -222,6 +205,249 @@ bool load_elf_symbols(GElfFormat *format) /****************************************************************************** * * +* Paramètres : format = description de l'exécutable à compléter. * +* vaddr = adresse virtuelle du symbole à insérer. * +* len = taille de la routine à ajouter. * +* routine = représentation de la fonction repérée. * +* * +* Description : Enregistre un point d'entrée au sein d'un binaire ELF. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void register_elf_entry_point(GElfFormat *format, virt_t vaddr, phys_t len, GBinRoutine *routine) +{ + GBinFormat *base; /* Version basique de l'instance */ + vmpa2t addr; /* Localisation d'une routine */ + mrange_t range; /* Couverture mémoire associée */ + GBinSymbol *symbol; /* Nouveau symbole construit */ + + base = G_BIN_FORMAT(format); + + /* Comptabilisation pour le désassemblage brut */ + + base->entry_points = (virt_t *)realloc(base->entry_points, ++base->ep_count * sizeof(virt_t)); + + base->entry_points[base->ep_count - 1] = vaddr; + + /* Comptabilisation en tant que symbole */ + + if (ELF_HDR(format, format->header, e_machine) == EM_ARM) + vaddr &= ~0x1; + + init_vmpa(&addr, VMPA_NO_PHYSICAL, vaddr); + + init_mrange(&range, &addr, len); + + g_binary_routine_set_range(routine, &range); + + symbol = g_binary_symbol_new(STP_ROUTINE, "XXX", ~0); + g_binary_symbol_attach_routine(symbol, routine); + g_binary_format_add_symbol(base, symbol); + +} + + +/****************************************************************************** +* * +* Paramètres : format = description de l'exécutable à consulter. * +* * +* Description : Enumère tous les points d'entrée principaux d'un binaire ELF.* +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool load_all_elf_basic_entry_points(GElfFormat *format) +{ + virt_t ep; /* Point d'entrée détecté */ + GBinRoutine *routine; /* Routine à associer à un pt. */ + elf_phdr dynamic; /* En-tête de programme DYNAMIC*/ + elf_dyn item_a; /* Premier élément DYNAMIC */ + elf_dyn item_b; /* Second élément DYNAMIC */ + const bin_t *content; /* Contenu binaire à lire */ + off_t length; /* Taille totale du contenu */ + off_t pos; /* Tête de lecture courante */ + uint32_t virt_32; /* Adresse virtuelle sur 32b */ + uint64_t virt_64; /* Adresse virtuelle sur 64b */ + bool status; /* Bilan d'une opération */ + + /* Point d'entrée principal éventuel */ + + ep = ELF_HDR(format, format->header, e_entry); + + if (ep != 0x0) + { + routine = try_to_demangle_routine("entry_point"); + register_elf_entry_point(format, ep, 0, routine); + } + + /* Chargemet de l'en-tête de programme DYNAMIC */ + + if (!find_elf_dynamic_program_header(format, &dynamic)) + goto laebep_exit; + + /* Détection des constructeurs & destructeurs */ + + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_INIT, &item_a)) + { + ep = ELF_DYN(format, item_a, d_un.d_ptr); + + if (ep != 0x0) + { + routine = try_to_demangle_routine("init_function"); + register_elf_entry_point(format, ep, 0, routine); + } + + } + + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_FINI, &item_a)) + { + ep = ELF_DYN(format, item_a, d_un.d_ptr); + + if (ep != 0x0) + { + routine = try_to_demangle_routine("termination_function"); + register_elf_entry_point(format, ep, 0, routine); + } + + } + + void load_entry_points_from_array(GElfFormat *fmt, const elf_dyn *ar, const elf_dyn *sz, const char *prefix) + { + unsigned int i; /* Boucle de parcours */ + char fullname[64]; /* Désignation humaine */ + + assert(sizeof(fullname) >= (strlen(prefix) + sizeof(XSTR(UINT64_MAX) + 1))); + + content = G_BIN_FORMAT(fmt)->content; + length = G_BIN_FORMAT(fmt)->length; + + if (!translate_address_into_offset_using_elf_programs(fmt, ELF_DYN(fmt, *ar, d_un.d_val), &pos)) + return; + + if ((pos + ELF_DYN(fmt, *sz, d_un.d_val)) < length) + length = pos + ELF_DYN(fmt, *sz, d_un.d_val); + + for (i = 0; pos < length; i++) + { + if (fmt->is_32b) + { + status = read_u32(&virt_32, content, &pos, length, fmt->endian); + ep = virt_32; + } + else + { + status = read_u64(&virt_64, content, &pos, length, fmt->endian); + ep = virt_64; + } + + if (!status) break; + + if (ep != 0x0) + { + snprintf(fullname, sizeof(fullname), "%s%u", prefix, i); + + routine = try_to_demangle_routine(fullname); + register_elf_entry_point(fmt, ep, 0, routine); + + } + + } + + } + + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_INIT_ARRAY, &item_a)) + { + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_INIT_ARRAYSZ, &item_b)) + { + load_entry_points_from_array(format, &item_a, &item_b, "init_array_function_"); + } + + } + + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_FINI_ARRAY, &item_a)) + { + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_FINI_ARRAYSZ, &item_b)) + { + load_entry_points_from_array(format, &item_a, &item_b, "fini_array_function_"); + } + + } + + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_PREINIT_ARRAY, &item_a)) + { + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_PREINIT_ARRAYSZ, &item_b)) + { + load_entry_points_from_array(format, &item_a, &item_b, "preinit_array_function_"); + } + + } + + /* Identification de l'entrée de la PLT */ + + if (find_elf_dynamic_item_from_pheader(format, &dynamic, DT_PLTGOT, &item_a)) + { + if (translate_address_into_offset_using_elf_programs(format, ELF_DYN(format, item_a, d_un.d_val), &pos)) + { + content = G_BIN_FORMAT(format)->content; + length = G_BIN_FORMAT(format)->length; + + /* On saute le premier élément... */ + if (format->is_32b) + status = read_u32(&virt_32, content, &pos, length, format->endian); + else + status = read_u64(&virt_64, content, &pos, length, format->endian); + + while (1) + { + if (format->is_32b) + { + status = read_u32(&virt_32, content, &pos, length, format->endian); + ep = virt_32; + } + else + { + status = read_u64(&virt_64, content, &pos, length, format->endian); + ep = virt_64; + } + + if (!status) break; + + if (ep != 0x0) + { + routine = try_to_demangle_routine("plt_entry"); + register_elf_entry_point(format, ep, 0, routine); + break; + } + + } + + } + + } + + laebep_exit: + + return true; + +} + + + + + + + + + +/****************************************************************************** +* * * Paramètres : format = description de l'exécutable à consulter. * * sym = section comprenant les symboles à venir lire. * * index = indice de l'entrée à venir lire. * diff --git a/src/format/exe_format.c b/src/format/exe_format.c index fe8450c..14f1541 100644 --- a/src/format/exe_format.c +++ b/src/format/exe_format.c @@ -370,25 +370,6 @@ FormatTargetMachine get_exe_target_machine(const exe_format *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); - -} - - diff --git a/src/format/exe_format.h b/src/format/exe_format.h index 9c29675..b4cecb3 100644 --- a/src/format/exe_format.h +++ b/src/format/exe_format.h @@ -126,10 +126,6 @@ typedef enum _ResolvedType const uint8_t *get_exe_content(const exe_format *, off_t *); -/* Fournit l'adresse mémoire du point d'entrée du programme. */ -uint64_t get_exe_entry_point(const exe_format *); - - /* Indique le type d'architecture visée par le format. */ FormatTargetMachine get_exe_target_machine(const exe_format *); diff --git a/src/format/executable-int.h b/src/format/executable-int.h index a421ce3..51a2625 100644 --- a/src/format/executable-int.h +++ b/src/format/executable-int.h @@ -35,9 +35,6 @@ /* Indique le type d'architecture visée par le format. */ typedef FormatTargetMachine (* get_target_machine_fc) (const GExeFormat *); -/* Fournit l'adresse mémoire du point d'entrée du programme. */ -typedef vmpa_t (* get_entry_point_fc) (const GExeFormat *); - /* Etend la définition des portions au sein d'un binaire. */ typedef void (* refine_portions_fc) (const GExeFormat *, GBinPortion *); @@ -59,7 +56,6 @@ struct _GExeFormat GBinFormat parent; /* A laisser en premier */ get_target_machine_fc get_machine; /* Architecture ciblée */ - get_entry_point_fc get_entry_point; /* Obtention du point d'entrée */ refine_portions_fc refine_portions; /* Décrit les portions binaires*/ get_parts_fc get_parts; /* Liste des parties binaires */ diff --git a/src/format/executable.c b/src/format/executable.c index 0ae6934..db846e2 100644 --- a/src/format/executable.c +++ b/src/format/executable.c @@ -110,25 +110,6 @@ FormatTargetMachine g_exe_format_get_target_machine(const GExeFormat *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 : - * -* * -******************************************************************************/ - -vmpa_t g_exe_format_get_entry_point(const GExeFormat *format) -{ - return format->get_entry_point(format); - -} - - -/****************************************************************************** -* * * Paramètres : format = description de l'exécutable à consulter. * * * * Description : Décrit les différentes portions qui composent le binaire. * diff --git a/src/format/executable.h b/src/format/executable.h index 28ac201..1a3febf 100644 --- a/src/format/executable.h +++ b/src/format/executable.h @@ -72,9 +72,6 @@ GType g_executable_format_get_type(void); /* Indique le type d'architecture visée par le format. */ FormatTargetMachine g_exe_format_get_target_machine(const GExeFormat *); -/* Fournit l'adresse mémoire du point d'entrée du programme. */ -vmpa_t g_exe_format_get_entry_point(const GExeFormat *); - /* Décrit les différentes portions qui composent le binaire. */ GBinPortion *g_exe_format_get_portions(GExeFormat *); diff --git a/src/format/format-int.h b/src/format/format-int.h index 21a97b3..85244b6 100644 --- a/src/format/format-int.h +++ b/src/format/format-int.h @@ -44,7 +44,8 @@ struct _GBinFormat const bin_t *content; /* Contenu binaire à étudier */ off_t length; /* Taille de ce contenu */ - virt_t entry_point; /* Point d'entrée dans le code */ + virt_t *entry_points; /* Points d'entrée du code */ + size_t ep_count; /* Nombre de ces points */ GBinSymbol **symbols; /* Liste des symboles trouvés */ size_t symbols_count; /* Quantité de ces symboles */ diff --git a/src/format/format.c b/src/format/format.c index ab5b372..73e6794 100644 --- a/src/format/format.c +++ b/src/format/format.c @@ -33,6 +33,7 @@ #include "elf/elf.h" #include "java/java.h" #include "pe/pe.h" +#include "../arch/processor.h" #include "../decomp/expr/block.h" #include "../gui/panels/log.h" #include "../plugins/pglist.h" @@ -182,17 +183,28 @@ const bin_t *g_binary_format_get_content(const GBinFormat *format, off_t *length * * * Paramètres : format = description de l'exécutable à consulter. * * * -* Description : Fournit l'adresse mémoire du point d'entrée d'un binaire. * +* Description : Fournit un contexte initialisé pour un désassemblage. * * * -* Retour : Adresse de mémoire virtuelle, voire VMPA_NO_VIRTUAL. * +* Retour : Nouveau contexte pour désassemblage prêt à emploi. * * * * Remarques : - * * * ******************************************************************************/ -virt_t g_binary_format_get_entry_point(const GBinFormat *format) +GProcContext *g_binary_format_get_disassembling_context(const GBinFormat *format) { - return format->entry_point; + GProcContext *result; /* Contexte à retourner */ + GArchProcessor *proc; /* Architecture du binaire */ + size_t i; /* Boucle de parcours */ + + proc = get_arch_processor_from_format(G_EXE_FORMAT(format)); + + result = g_arch_processor_get_context(proc); + + for (i = 0; i < format->ep_count; i++) + g_proc_context_push_drop_point(result, format->entry_points[i]); + + return result; } diff --git a/src/format/format.h b/src/format/format.h index 9b2e0f6..d2034ef 100644 --- a/src/format/format.h +++ b/src/format/format.h @@ -32,6 +32,7 @@ #include "symbol.h" #include "../analysis/routine.h" +#include "../arch/context.h" @@ -58,8 +59,8 @@ GType g_binary_format_get_type(void); /* Fournit une référence vers le contenu binaire analysé. */ const bin_t *g_binary_format_get_content(const GBinFormat *, off_t *); -/* Fournit l'adresse mémoire du point d'entrée d'un binaire. */ -virt_t g_binary_format_get_entry_point(const GBinFormat *); +/* Fournit un contexte initialisé pour un désassemblage. */ +GProcContext *g_binary_format_get_disassembling_context(const GBinFormat *); /* Ajoute un symbole à la collection du format binaire. */ void g_binary_format_add_symbol(GBinFormat *, GBinSymbol *); diff --git a/src/format/java/java.c b/src/format/java/java.c index 78cf717..3235711 100755 --- a/src/format/java/java.c +++ b/src/format/java/java.c @@ -48,9 +48,6 @@ static void g_java_format_init(GJavaFormat *); /* Indique le type d'architecture visée par le format. */ static FormatTargetMachine g_java_format_get_target_machine(const GJavaFormat *); -/* Fournit l'adresse mémoire du point d'entrée du programme. */ -static vmpa_t g_java_format_get_entry_point(const GJavaFormat *); - /* Fournit les références aux zones binaires à analyser. */ static GBinPart **g_java_format_get_parts(const GJavaFormat *, size_t *); @@ -131,7 +128,6 @@ static void g_java_format_init(GJavaFormat *format) exe_format = G_EXE_FORMAT(format); exe_format->get_machine = (get_target_machine_fc)g_java_format_get_target_machine; - exe_format->get_entry_point = (get_entry_point_fc)g_java_format_get_entry_point; exe_format->get_parts = (get_parts_fc)g_java_format_get_parts; exe_format->translate_addr = (translate_addr_fc)g_java_format_translate_address_into_offset; @@ -222,25 +218,6 @@ static FormatTargetMachine g_java_format_get_target_machine(const GJavaFormat *f /****************************************************************************** * * * 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 : - * -* * -******************************************************************************/ - -static vmpa_t g_java_format_get_entry_point(const GJavaFormat *format) -{ - return 0;//(format->is_32b ? format->header.e_entry.addr32 : format->header.e_entry.addr64); - -} - - -/****************************************************************************** -* * -* Paramètres : format = informations chargées à consulter. * * count = quantité de zones listées. [OUT] * * * * Description : Fournit les références aux zones binaires à analyser. * diff --git a/src/format/pe/pe.c b/src/format/pe/pe.c index 54defeb..2692560 100644 --- a/src/format/pe/pe.c +++ b/src/format/pe/pe.c @@ -42,9 +42,6 @@ static void g_pe_format_init(GPeFormat *); /* Indique le type d'architecture visée par le format. */ static FormatTargetMachine g_pe_format_get_target_machine(const GPeFormat *); -/* Fournit l'adresse mémoire du point d'entrée du programme. */ -static vmpa_t g_pe_format_get_entry_point(const GPeFormat *); - /* Fournit les références aux zones binaires à analyser. */ static GBinPart **g_pe_format_get_parts(const GPeFormat *, size_t *); @@ -140,7 +137,6 @@ static void g_pe_format_init(GPeFormat *format) exe_format = G_EXE_FORMAT(format); exe_format->get_machine = (get_target_machine_fc)g_pe_format_get_target_machine; - exe_format->get_entry_point = (get_entry_point_fc)g_pe_format_get_entry_point; exe_format->get_parts = (get_parts_fc)g_pe_format_get_parts; exe_format->translate_addr = (translate_addr_fc)g_pe_format_translate_address_into_offset; @@ -258,25 +254,6 @@ static FormatTargetMachine g_pe_format_get_target_machine(const GPeFormat *forma /****************************************************************************** * * * 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 : - * -* * -******************************************************************************/ - -static vmpa_t g_pe_format_get_entry_point(const GPeFormat *format) -{ - return 0;//(format->is_32b ? format->header.e_entry.addr32 : format->header.e_entry.addr64); - -} - - -/****************************************************************************** -* * -* Paramètres : format = informations chargées à consulter. * * count = quantité de zones listées. [OUT] * * * * Description : Fournit les références aux zones binaires à analyser. * diff --git a/src/format/symbol.h b/src/format/symbol.h index c5bf750..e123898 100644 --- a/src/format/symbol.h +++ b/src/format/symbol.h @@ -41,6 +41,7 @@ typedef enum _SymbolType STP_ROUTINE, /* Simple morceau de code */ STP_OBJECT, /* Objet quelconque */ STP_FUNCTION, /* Simple morceau de code */ + STP_ENTRY_POINT, /* Morceau de code en entrée */ STP_STRING /* Chaîne de caractères */ } SymbolType; |