Defined the ELF support as plugin.

1 files changed, 891 insertions, 0 deletions

diff --git a/plugins/elf/symbols.c b/plugins/elf/symbols.c
new file mode 100644
index 0000000..292913b
--- /dev/null
+++ b/plugins/elf/symbols.c
@@ -0,0 +1,891 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * symbols.c - gestion des symboles d'un ELF
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "symbols.h"
+
+
+#include <assert.h>
+#include <malloc.h>
+#include <string.h>
+
+
+#include <i18n.h>
+#include <arch/raw.h>
+#include <common/extstr.h>
+#include <core/global.h>
+#include <core/params.h>
+#include <format/mangling/demangler.h>
+#include <gui/panels/log.h>
+
+
+#include "dynamic.h"
+#include "elf-int.h"
+#include "helper_arm.h"
+#include "loading.h"
+#include "program.h"
+#include "section.h"
+
+
+
+
+
+
+
+
+
+
+/* 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 *);
+
+
+
+
+
+
+
+
+
+/* -------------------------- DETAIL DES SYMBOLES INTERNES -------------------------- */
+
+
+/* Assure le chargement des symboles internes ELF en différé. */
+static bool do_elf_internal_symbol_loading(GElfLoading *, GElfFormat *, phys_t *);
+
+/* Charge tous les symboles internes possibles. */
+static bool load_elf_internal_symbols(GElfFormat *, wgroup_id_t, GtkStatusStack *);
+
+
+
+/* -------------------------- DETAIL DES SYMBOLES EXTERNES -------------------------- */
+
+
+/* Retrouve un élément donné dans la section dynamique. */
+static bool find_elf_dynamic_item(const GElfFormat *, const elf_shdr *, int32_t, elf_dyn *);
+
+/* Charge tous les éléments dynamiques externes possibles. */
+static bool load_elf_external_symbols(GElfFormat *, const elf_shdr *);
+
+
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = description de l'exécutable à compléter.            *
+                 status = barre de statut à tenir informée.                   *
+*                                                                             *
+*  Description : Charge en mémoire la liste humaine des symboles.             *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool load_elf_symbols(GElfFormat *format, GtkStatusStack *status)
+{
+    bool result;                            /* Bilan à retourner           */
+    wgroup_id_t gid;                        /* Identifiant pour les tâches */
+
+    elf_shdr *sections;                     /* Groupe de sections trouvées */
+    size_t count;                           /* Quantité de données         */
+
+    result = true;
+
+    gid = g_work_queue_define_work_group(get_work_queue());
+
+    /* Symboles internes */
+
+    result &= load_elf_internal_symbols(format, gid, status);
+
+
+
+
+    /* Symboles externes */
+
+    if (find_elf_sections_by_type(format, SHT_DYNAMIC, &sections, &count))
+    {
+        log_variadic_message(LMT_INFO, _("Binary is dynamically linked"));
+
+        result &= load_elf_external_symbols(format, &sections[0]);
+
+        free(sections);
+
+    }
+    else log_variadic_message(LMT_INFO, _("Binary is statically linked"));
+
+
+
+
+    /* Symboles d'entrée, si encore besoin */
+
+    /**
+     * Le tri en préalable
+     */
+
+
+
+
+
+    result &= load_all_elf_basic_entry_points(format);
+
+    return result;
+
+}
+
+
+
+
+
+/******************************************************************************
+*                                                                             *
+*  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 du format   */
+    virt_t final_vaddr;                     /* Adresse virtuelle retenue   */
+    bool status;                            /* Bilan d'une opération       */
+    vmpa2t addr;                            /* Localisation d'une routine  */
+    mrange_t range;                         /* Couverture mémoire associée */
+    GBinSymbol *symbol;                     /* Nouveau symbole construit   */
+
+    /* Localisation complète du symbole */
+
+	if (ELF_HDR(format, format->header, e_machine) == EM_ARM)
+		final_vaddr = vaddr & ~0x1;
+    else
+        final_vaddr = vaddr;
+
+    status = g_exe_format_translate_address_into_vmpa(G_EXE_FORMAT(format), final_vaddr, &addr);
+    if (!status) return;
+
+    /* Comptabilisation en tant que symbole */
+
+    if (g_binary_format_find_symbol_at(G_BIN_FORMAT(format), &addr, &symbol))
+        g_object_unref(G_OBJECT(routine));
+
+    else
+    {
+        base = G_BIN_FORMAT(format);
+
+        init_mrange(&range, &addr, len);
+
+        symbol = G_BIN_SYMBOL(routine);
+
+        g_binary_symbol_set_range(symbol, &range);
+        g_binary_symbol_set_target_type(symbol, STP_ENTRY_POINT);
+
+        g_binary_format_add_symbol(base, symbol);
+
+        /* Comptabilisation pour le désassemblage brut */
+        g_binary_format_register_code_point(base, vaddr, true);
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  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 GBinContent *content;             /* Contenu binaire à lire      */
+    phys_t length;                          /* Taille totale du contenu    */
+    bool status;                            /* Bilan d'une opération       */
+    vmpa2t pos;                             /* Tête de lecture courante    */
+    uint32_t virt_32;                       /* Adresse virtuelle sur 32b   */
+    uint64_t virt_64;                       /* Adresse virtuelle sur 64b   */
+
+    /* 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;
+
+        status = g_exe_format_translate_address_into_vmpa(G_EXE_FORMAT(format),
+                                                          ELF_DYN(fmt, *ar, d_un.d_val),
+                                                          &pos);
+        if (!status) return;
+
+        length = get_phy_addr(&pos) + ELF_DYN(fmt, *sz, d_un.d_val);
+
+        for (i = 0; get_phy_addr(&pos) < length; i++)
+        {
+            /**
+             * Selon la libc d'Android (https://www.codeaurora.org/.../android/bionic/linker/README.TXT) :
+             *
+             *      DT_INIT_ARRAY
+             *          Points to an array of function addresses that must be
+             *          called, in-order, to perform initialization. Some of
+             *          the entries in the array can be 0 or -1, and should
+             *          be ignored.
+             *
+             * On étend le principe aux sections DT_FINI_ARRAY et DT_PREINIT_ARRAY.
+             */
+
+            if (fmt->is_32b)
+            {
+                status = g_binary_content_read_u32(content, &pos, fmt->endian, &virt_32);
+                status &= (virt_32 != 0x0 && virt_32 != 0xffffffff);
+                ep = virt_32;
+            }
+            else
+            {
+                status = g_binary_content_read_u64(content, &pos, fmt->endian, &virt_64);
+                status &= (virt_64 != 0x0 && virt_64 != 0xffffffffffffffff);
+                ep = virt_64;
+            }
+
+            if (!status) break;
+
+            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))
+    {
+        status = g_exe_format_translate_address_into_vmpa(G_EXE_FORMAT(format),
+                                                          ELF_DYN(format, item_a, d_un.d_val),
+                                                          &pos);
+
+        if (status)
+        {
+            content = G_BIN_FORMAT(format)->content;
+
+            /* On saute le premier élément... */
+            if (format->is_32b)
+                status = g_binary_content_read_u32(content, &pos, format->endian, &virt_32);
+            else
+                status = g_binary_content_read_u64(content, &pos, format->endian, &virt_64);
+
+            while (1)
+            {
+                if (format->is_32b)
+                {
+                    status = g_binary_content_read_u32(content, &pos, format->endian, &virt_32);
+                    ep = virt_32;
+                }
+                else
+                {
+                    status = g_binary_content_read_u64(content, &pos, format->endian, &virt_64);
+                    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.                    *
+*                symbol = ensemble d'informations lues. [OUT]                 *
+*                                                                             *
+*  Description : Récupère la définition complète d'un symbole donné.          *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool get_elf_symbol_by_index(GElfFormat *format, const elf_shdr *sym, off_t index, elf_sym *symbol)
+{
+    phys_t sym_start;                       /* Début de section            */
+    phys_t sym_size;                        /* Taille de section           */
+    phys_t offset;                          /* Emplacement à venir lire    */
+
+    get_elf_section_content(format, sym, &sym_start, &sym_size, NULL);
+
+    offset = sym_start + index * ELF_SIZEOF_SYM(format);
+    if ((offset + ELF_SIZEOF_SYM(format)) > (sym_start + sym_size)) return NULL;
+
+    return read_elf_symbol(format, &offset, symbol);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = description de l'exécutable à consulter.            *
+*                sym    = section comprenant les symboles à venir lire.       *
+*                str    = section de chaînes de caractères pour les noms.     *
+*                index  = indice de l'entrée à venir lire.                    *
+*                                                                             *
+*  Description : Récupère la désignation d'un symbole donné.                  *
+*                                                                             *
+*  Retour      : Nom du symbole trouvé, ou NULL si erreur ou non adapté.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const char *get_elf_symbol_name(GElfFormat *format, const elf_shdr *sym, const elf_shdr *str, off_t index)
+{
+    const char *result;                     /* Résultat à retourner        */
+    elf_sym symbol;                         /* Symbole aux infos visées    */
+
+    result = NULL;
+
+    if (get_elf_symbol_by_index(format, sym, index, &symbol))
+        result = extract_name_from_elf_string_section(format, str, ELF_SYM(format, symbol, st_name));
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                            DETAIL DES SYMBOLES INTERNES                            */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : loading = chargement de symboles internes en cours.          *
+*                format  = format ELF à compléter.                            *
+*                iter    = tête de lecture évoluant avec le temps. [OUT]      *
+*                                                                             *
+*  Description : Assure le chargement des symboles internes ELF en différé.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool do_elf_internal_symbol_loading(GElfLoading *loading, GElfFormat *format, phys_t *iter)
+{
+    bool result;                            /* Bilan à retourner           */
+    elf_sym sym;                            /* Symbole aux infos visées    */
+    virt_t virt;                            /* Adresse virtuelle           */
+    const elf_shdr *section;                /* Groupe de sections trouvées */
+    bool use_virt;                          /* Choix de construction de nom*/
+    const elf_shdr *strtab;                 /* Section .strtab trouvée     */
+    bool has_strtab;                        /* Présence de cette section   */
+    phys_t first;                           /* Position du premier élément */
+    const char *name;                       /* Nom du symbole trouvé       */
+    GBinFormat *base;                       /* Version basique du format   */
+    vmpa2t addr;                            /* Localisation d'une routine  */
+    GBinSymbol *symbol;                     /* Nouveau symbole construit   */
+    char alt_name[6 + VMPA_MAX_LEN];        /* Nom abstrait de substitution*/
+    virt_t final_virt;                      /* Adresse virtuelle retenue   */
+    mrange_t range;                         /* Couverture mémoire associée */
+    GBinRoutine *routine;                   /* Nouvelle routine trouvée    */
+
+    result = read_elf_symbol(format, iter, &sym);
+    if (!result) goto geslp_done;
+
+    /* On rejette les symboles qui ne sont pas définis au sein du binaire */
+
+    if (ELF_SYM(format, sym, st_shndx) == 0) goto geslp_done;
+
+    /* Résolution précise d'adresse */
+
+    virt = ELF_SYM(format, sym, st_value);
+    if (virt == 0) goto geslp_done;
+
+
+    /* TODO */
+
+    //init_vmpa(&addr, VMPA_NO_PHYSICAL, ELF_SYM(format, sym, st_value));
+
+
+    //init_mrange(&range, &addr, 0);
+
+
+    /* Première ébauche de nom */
+
+    g_elf_loading_get_internal_info(loading, &section, &use_virt, &strtab, &has_strtab, &first);
+
+    if (!has_strtab)
+        name = NULL;
+
+    else
+        name = get_elf_symbol_name(format, section, strtab,
+                                   ((*iter - first) / ELF_SIZEOF_SYM(format)) - 1);
+
+    /* Traitements particuliers */
+
+    base = G_BIN_FORMAT(format);
+
+    switch (ELF_ST_TYPE(format, sym))
+    {
+        case STT_OBJECT:
+
+            /* Ajustement de la position */
+
+            if (!g_exe_format_translate_address_into_vmpa(G_EXE_FORMAT(format), virt, &addr))
+            {
+                symbol = NULL;
+                break;
+            }
+
+            /* Création d'un nom unique ? */
+
+            if (name == NULL)
+            {
+                strcpy(alt_name, "obj_");
+
+                if (use_virt)
+                    vmpa2_virt_to_string(&addr, MDS_UNDEFINED, alt_name + 4, NULL);
+                else
+                    vmpa2_phys_to_string(&addr, MDS_UNDEFINED, alt_name + 4, NULL);
+
+                name = alt_name;
+
+            }
+
+
+            /* TODO */
+
+            symbol = NULL;
+
+
+            break;
+
+        case STT_FUNC:
+
+            /* Ajustement de la position */
+
+            if (ELF_HDR(format, format->header, e_machine) == EM_ARM)
+                final_virt = virt & ~0x1;
+            else
+                final_virt = virt;
+
+            if (!g_exe_format_translate_address_into_vmpa(G_EXE_FORMAT(format), final_virt, &addr))
+            {
+                symbol = NULL;
+                break;
+            }
+
+            init_mrange(&range, &addr, ELF_SYM(format, sym, st_size));
+
+            /* Création d'un nom unique ? */
+
+            if (name == NULL)
+            {
+                strcpy(alt_name, "func_");
+
+                if (use_virt)
+                    vmpa2_virt_to_string(&addr, MDS_UNDEFINED, alt_name + 5, NULL);
+                else
+                    vmpa2_phys_to_string(&addr, MDS_UNDEFINED, alt_name + 5, NULL);
+
+                name = alt_name;
+
+            }
+
+            /* Routine */
+
+            routine = try_to_demangle_routine(name);
+            symbol = G_BIN_SYMBOL(routine);
+
+            g_binary_symbol_set_range(symbol, &range);
+
+            /* Comptabilisation pour le désassemblage brut */
+
+            g_binary_format_register_code_point(G_BIN_FORMAT(format), virt, false);
+
+            break;
+
+        default:
+            symbol = NULL;
+            break;
+
+    }
+
+    if (symbol != NULL)
+        g_binary_format_add_symbol(base, symbol);
+
+ geslp_done:
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = description de l'exécutable à compléter.            *
+*                gid    = groupe de travail impliqué.                         *
+                 status = barre de statut à tenir informée.                   *
+*                                                                             *
+*  Description : Charge tous les symboles internes possibles.                 *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool load_elf_internal_symbols(GElfFormat *format, wgroup_id_t gid, GtkStatusStack *status)
+{
+    bool result;                            /* Bilan à retourner           */
+    bool no_name;                           /* Choix de construction de nom*/
+    activity_id_t msg;                      /* Message de progression      */
+    GWorkQueue *queue;                      /* Gestionnaire de différés    */
+    elf_shdr *dynsym_sections;              /* Groupe de sections trouvées */
+    size_t count;                           /* Quantité de données         */
+    elf_shdr *symtab_sections;              /* Groupe de sections trouvées */
+    size_t i;                               /* Boucle de parcours          */
+
+    result = true;
+
+    /* Charge tous les symboles définis dans une section */
+    void add_all_symbols_from_section(const elf_shdr *section, bool use_virt, GWorkQueue *wq, activity_id_t id)
+    {
+        phys_t start;                       /* Début de la zone à traiter  */
+        phys_t size;                        /* Taille de cette même zone   */
+        phys_t sym_size;                    /* Taille de chaque symbole lu */
+        guint runs_count;                   /* Qté d'exécutions parallèles */
+        phys_t run_size;                    /* Volume réparti par exécution*/
+        guint i;                            /* Boucle de parcours          */
+        phys_t begin;                       /* Début de zone de traitement */
+        phys_t end;                         /* Fin d'un zone de traitement */
+        GElfLoading *loading;               /* Tâche de chargement à lancer*/
+
+        get_elf_section_content(format, section, &start, &size, NULL);
+
+        sym_size = ELF_SIZEOF_SYM(format);
+
+        runs_count = g_get_num_processors();
+
+        run_size = size / (sym_size * runs_count);
+
+        gtk_status_stack_extend_activity(status, id, size / sym_size);
+
+        for (i = 0; i < runs_count; i++)
+        {
+            begin = start + i * run_size * sym_size;
+
+            if ((i + 1) == runs_count)
+                end = start + size;
+            else
+                end = begin + run_size * sym_size;
+
+            loading = g_elf_loading_new(format, section, use_virt, start, begin, end,
+                                        id, do_elf_internal_symbol_loading);
+
+            g_work_queue_schedule_work(wq, G_DELAYED_WORK(loading), gid);
+
+        }
+
+    }
+
+    if (!g_generic_config_get_value(get_main_configuration(), MPK_FORMAT_NO_NAME, &no_name))
+        return false;
+
+    msg = gtk_status_stack_add_activity(status, _("Loading internal symbols..."), 0);
+
+    queue = get_work_queue();
+
+    if (find_elf_sections_by_type(format, SHT_DYNSYM, &dynsym_sections, &count))
+        for (i = 0; i < count; i++)
+            add_all_symbols_from_section(&dynsym_sections[i], no_name, queue, msg);
+
+    if (find_elf_sections_by_type(format, SHT_SYMTAB, &symtab_sections, &count))
+        for (i = 0; i < count; i++)
+            add_all_symbols_from_section(&symtab_sections[i], no_name, queue, msg);
+
+    g_work_queue_wait_for_completion(queue, gid);
+
+    gtk_status_stack_remove_activity(status, msg);
+
+    if (dynsym_sections != NULL) free(dynsym_sections);
+    if (symtab_sections != NULL) free(symtab_sections);
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                            DETAIL DES SYMBOLES EXTERNES                            */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format  = informations chargées à consulter.                 *
+*                dynamic = section de type SHT_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   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool find_elf_dynamic_item(const GElfFormat *format, const elf_shdr *section, int32_t type, elf_dyn *item)
+{
+    bool result;                            /* Bilan à retourner           */
+    const GBinContent *content;             /* Contenu binaire à lire      */
+    phys_t pos;                             /* Position de lecture         */
+    vmpa2t tmp;                             /* Position écrasable          */
+    int32_t tag32;                          /* Type de l'entrée (32 bits)  */
+    int64_t tag64;                          /* Type de l'entrée (64 bits)  */
+
+    result = true;
+
+    content = G_BIN_FORMAT(format)->content;
+
+    for (pos = ELF_SHDR(format, *section, sh_offset);
+         result;
+         pos += ELF_SIZEOF_DYN(format))
+    {
+        init_vmpa(&tmp, pos, VMPA_NO_VIRTUAL);
+
+        if (format->is_32b)
+        {
+            result = g_binary_content_read_s32(content, &tmp, format->endian, &tag32);
+            if (tag32 == type) break;
+        }
+        else
+        {
+            result = g_binary_content_read_s64(content, &tmp, format->endian, &tag64);
+            if (tag64 == type) break;
+        }
+
+    }
+
+    if (result)
+    {
+        init_vmpa(&tmp, pos, VMPA_NO_VIRTUAL);
+
+        if (format->is_32b)
+        {
+            result = g_binary_content_read_s32(content, &tmp, format->endian, &item->dyn32.d_tag);
+            result &= g_binary_content_read_s32(content, &tmp, format->endian, &item->dyn32.d_un.d_val);
+        }
+        else
+        {
+            result = g_binary_content_read_s64(content, &tmp, format->endian, &item->dyn64.d_tag);
+            result &= g_binary_content_read_s64(content, &tmp, format->endian, &item->dyn64.d_un.d_val);
+        }
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format  = informations chargées à consulter.                 *
+*                dynamic = section de type SHT_DYNAMIC.                       *
+*                                                                             *
+*  Description : Charge tous les éléments dynamiques externes possibles.      *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool load_elf_external_symbols(GElfFormat *format, const elf_shdr *section)
+{
+    bool result;                            /* Bilan à retourner           */
+    elf_dyn item;                           /* Elément dynamique           */
+    elf_shdr relxxx;                        /* Section .rel.xxx trouvée    */
+    elf_shdr dynsym;                        /* Section .dynsym trouvée     */
+    elf_shdr dynstr;                        /* Section .dynstr trouvée     */
+
+    result = true;
+
+    /* Section .rel.plt */
+    if (find_elf_dynamic_item(format, section, DT_JMPREL, &item))
+    {
+        result &= find_elf_section_by_virtual_address(format, ELF_DYN(format, item, d_un.d_ptr), &relxxx);
+
+        if (result)
+            result = find_elf_section_by_index(format, ELF_SHDR(format, relxxx, sh_link), &dynsym);
+
+        if (result)
+            result = find_elf_section_by_index(format, ELF_SHDR(format, dynsym, sh_link), &dynstr);
+
+        if (result)
+            switch (ELF_HDR(format, format->header, e_machine))
+            {
+                case EM_ARM:
+                    result = load_elf_arm_relocated_symbols(format, &relxxx, &dynsym, &dynstr);
+                    break;
+
+                default:
+                    break;
+
+            }
+
+    }
+
+    return result;
+
+}