summaryrefslogtreecommitdiff
path: root/src/format/elf
diff options
context:
space:
mode:
authorCyrille Bagard <nocbos@gmail.com>2015-01-31 00:55:26 (GMT)
committerCyrille Bagard <nocbos@gmail.com>2015-01-31 00:55:26 (GMT)
commit21a05df6423bdc13ca148ff2b96aec80bf7af2b2 (patch)
tree87043734800103178ee49e771dcacab18b19cc74 /src/format/elf
parentd246c98c515cb44c5bc4c742a674bae2e824872b (diff)
Defined many entry points from many identified potential candidates.
git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@463 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a
Diffstat (limited to 'src/format/elf')
-rw-r--r--src/format/elf/Makefile.am1
-rw-r--r--src/format/elf/dynamic.c109
-rw-r--r--src/format/elf/dynamic.h41
-rw-r--r--src/format/elf/elf-int.c39
-rw-r--r--src/format/elf/elf-int.h3
-rw-r--r--src/format/elf/elf.c23
-rw-r--r--src/format/elf/elf_def.h20
-rw-r--r--src/format/elf/symbols.c288
8 files changed, 467 insertions, 57 deletions
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, &sections, &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. *