path: root/plugins/elf/loading.c

/* Chrysalide - Outil d'analyse de fichiers binaires
 * loading.c - chargements parallèles des symboles de format ELF
 *
 * Copyright (C) 2016-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 Chrysalide.  If not, see <http://www.gnu.org/licenses/>.
 */


#include "loading.h"


#include <assert.h>
#include <string.h>


#include <i18n.h>
#include <common/extstr.h>
#include <common/sort.h>
#include <core/logs.h>
#include <core/params.h>
#include <glibext/delayed-int.h>


#include "elf-int.h"



/* Fraction de routines à limiter (instance) */
struct _GElfLoading
{
    GDelayedWork parent;                    /* A laisser en premier        */

    GElfFormat *format;                     /* Format à faire évoluer      */

    phys_t str_start;                       /* Chaînes à disposition       */

    union
    {
        struct
        {
            bool use_virt;                  /* Représentatio par défaut    */

        };

        struct
        {
            elf_rel *relocs_to_fill;        /* Tableau à remplir           */

        };

        struct
        {
            elf_rel *relocs;                /* Relocalisations présentes   */
            size_t rel_count;               /* Qté de ces relocalisations  */

            phys_t sym_start;               /* Début de zone des symboles  */
            uint32_t sym_count;             /* Nombre de symboles présents */

        };


    };

    union
    {
        struct
        {
            phys_t begin;                   /* Point de départ du parcours */
            phys_t end;                     /* Point d'arrivée exclu       */

            elf_loading_cb callback_0;      /* Routine de traitement #0    */

        };

        struct
        {
            sym_iter_t *iter;               /* Symboles à parcourir        */

            elf_applying_cb callback_1;     /* Routine de traitement #1    */

        };

    };

    unsigned int kind;                      /* Type de traitements         */
    bool status;                            /* Bilan des traitements       */

    activity_id_t id;                       /* Identifiant pour messages   */

};

/* Fraction de routines à limiter (classe) */
struct _GElfLoadingClass
{
    GDelayedWorkClass parent;               /* A laisser en premier        */

};


/* Initialise la classe des tâches des chargements pour ELF. */
static void g_elf_loading_class_init(GElfLoadingClass *);

/* Initialise une tâche de chargements pour ELF. */
static void g_elf_loading_init(GElfLoading *);

/* Supprime toutes les références externes. */
static void g_elf_loading_dispose(GElfLoading *);

/* Procède à la libération totale de la mémoire. */
static void g_elf_loading_finalize(GElfLoading *);

/* Assure le chargement pour un format ELF en différé. */
static void g_elf_loading_process(GElfLoading *, GtkStatusStack *);



/* Indique le type défini pour les tâches de chargements pour format ELF. */
G_DEFINE_TYPE(GElfLoading, g_elf_loading, G_TYPE_DELAYED_WORK);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des tâches des chargements pour ELF.    *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_elf_loading_class_init(GElfLoadingClass *klass)
{
    GObjectClass *object;                   /* Autre version de la classe  */
    GDelayedWorkClass *work;                /* Version en classe parente   */

    object = G_OBJECT_CLASS(klass);

    object->dispose = (GObjectFinalizeFunc/* ! */)g_elf_loading_dispose;
    object->finalize = (GObjectFinalizeFunc)g_elf_loading_finalize;

    work = G_DELAYED_WORK_CLASS(klass);

    work->run = (run_task_fc)g_elf_loading_process;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : loading = instance à initialiser.                            *
*                                                                             *
*  Description : Initialise une tâche de chargements pour ELF.                *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_elf_loading_init(GElfLoading *loading)
{
    loading->status = false;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : loading = instance d'objet GLib à traiter.                   *
*                                                                             *
*  Description : Supprime toutes les références externes.                     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_elf_loading_dispose(GElfLoading *loading)
{
    G_OBJECT_CLASS(g_elf_loading_parent_class)->dispose(G_OBJECT(loading));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : loading = instance d'objet GLib à traiter.                   *
*                                                                             *
*  Description : Procède à la libération totale de la mémoire.                *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_elf_loading_finalize(GElfLoading *loading)
{
    G_OBJECT_CLASS(g_elf_loading_parent_class)->finalize(G_OBJECT(loading));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format    = ensemble d'instructions désassemblées.           *
*                str_start = début des chaînes de caractères à consulter.     *
*                first     = position du premier élément.                     *
*                begin     = point de départ du parcours de liste.            *
*                end       = point d'arrivée exclu du parcours.               *
*                id        = identifiant du message affiché à l'utilisateur.  *
*                callback  = routine de traitements particuliers.             *
*                                                                             *
*  Description : Crée une tâche de chargement pour ELF différée.              *
*                                                                             *
*  Retour      : Tâche créée.                                                 *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GElfLoading *g_elf_loading_new_for_symbols(GElfFormat *format, phys_t str_start, phys_t first, phys_t begin, phys_t end, activity_id_t id, elf_loading_cb callback)
{
    GElfLoading *result;                    /* Tâche à retourner           */
#ifndef NDEBUG
    bool status;                            /* Etat d'une consultation     */
#endif

    result = g_object_new(G_TYPE_ELF_LOADING, NULL);

    result->format = format;

    result->str_start = str_start;

#ifndef NDEBUG
    status = g_generic_config_get_value(get_main_configuration(), MPK_FORMAT_NO_NAME, &result->use_virt);
    assert(status);
#else
    g_generic_config_get_value(get_main_configuration(), MPK_FORMAT_NO_NAME, &result->use_virt);
#endif

    result->begin = begin;
    result->end = end;
    result->callback_0 = callback;

    result->kind = 0;

    result->id = id;

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format   = ensemble d'instructions désassemblées.            *
*                begin    = point de départ du parcours de liste.             *
*                end      = point d'arrivée exclu du parcours.                *
*                relocs   = table des relocalisations à remplir.              *
*                id       = identifiant du message affiché à l'utilisateur.   *
*                callback = routine de traitements particuliers.              *
*                                                                             *
*  Description : Crée une tâche de chargement pour ELF différée.              *
*                                                                             *
*  Retour      : Tâche créée.                                                 *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GElfLoading *g_elf_loading_new_for_relocations(GElfFormat *format, phys_t begin, phys_t end, elf_rel *relocs, activity_id_t id, elf_loading_cb callback)
{
    GElfLoading *result;                    /* Tâche à retourner           */

    result = g_object_new(G_TYPE_ELF_LOADING, NULL);

    result->format = format;

    result->str_start = VMPA_NO_PHYSICAL;

    result->relocs_to_fill = relocs;

    result->begin = begin;
    result->end = end;
    result->callback_0 = callback;

    result->kind = 0;

    result->id = id;

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format    = ensemble d'instructions désassemblées.           *
*                iter      = itérateur sur les symboles à parcourir.          *
*                str_start = début de la zone contenant les descriptions.     *
*                relocs    = table des relocalisations chargées.              *
*                rel_count = nombre de ces éléments à interpréter.            *
*                sym_start = localisation du début de la zone de symboles.    *
*                sym_count = nombre de descriptions de symbole attendues.     *
*                id        = identifiant du message affiché à l'utilisateur.  *
*                callback  = routine de traitements particuliers.             *
*                                                                             *
*  Description : Crée une tâche de chargement pour ELF différée.              *
*                                                                             *
*  Retour      : Tâche créée.                                                 *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GElfLoading *g_elf_loading_new_for_applying(GElfFormat *format, sym_iter_t *iter, phys_t str_start, elf_rel *relocs, size_t rel_count, phys_t sym_start, uint32_t sym_count, activity_id_t id, elf_applying_cb callback)
{
    GElfLoading *result;                    /* Tâche à retourner           */

    result = g_object_new(G_TYPE_ELF_LOADING, NULL);

    result->format = format;

    result->str_start = str_start;

    result->relocs = relocs;
    result->rel_count = rel_count;
    result->sym_start = sym_start;
    result->sym_count = sym_count;

    result->iter = iter;
    result->callback_1 = callback;

    result->kind = 1;

    result->id = id;

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : loading = traitements différés à mener.                      *
*                status  = barre de statut à tenir informée.                  *
*                                                                             *
*  Description : Assure le chargement pour un format ELF en différé.          *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_elf_loading_process(GElfLoading *loading, GtkStatusStack *status)
{
    GElfFormat *format;                     /* Format plus accessible      */
    phys_t iter;                            /* Boucle de parcours          */
    phys_t old;                             /* Sauvegarde du point d'avant */
    bool ret;                               /* Bilan d'un appel            */
    size_t processed;                       /* Nombre de symboles traités  */
    GBinSymbol *symbol;                     /* Symbole analysé             */

    format = loading->format;

    switch (loading->kind)
    {
        case 0:

            for (iter = loading->begin; iter < loading->end; )
            {
                old = iter;
                ret = loading->callback_0(loading, format, &iter);

                if (!ret)
                {
                    log_variadic_message(LMT_ERROR, _("Error while loading ELF data @ 0x%08x!"), old);
                    break;
                }

                gtk_status_stack_update_activity_value(status, loading->id, 1);

            }

            loading->status = (iter == loading->end);
            break;

        case 1:

            ret = true;

            processed = 0;

            for (symbol = get_symbol_iterator_next(loading->iter);
                 symbol != NULL && ret;
                 symbol = get_symbol_iterator_next(loading->iter))
            {
                ret = loading->callback_1(loading, format, symbol);

                if (!ret)
                {
                    log_variadic_message(LMT_ERROR, _("Error while applying ELF relocation %zu!"), processed);
                    break;
                }

                processed++;

                gtk_status_stack_update_activity_value(status, loading->id, 1);

                if (processed == loading->rel_count)
                    break;

            }

            loading->status = (processed == loading->rel_count);
            break;

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : loading = procédure de chargements écoulés à consulter.      *
*                                                                             *
*  Description : Fournit le bilan des traitements différés.                   *
*                                                                             *
*  Retour      : true si tout s'est bien déroulé.                             *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_elf_loading_get_status(const GElfLoading *loading)
{
    return loading->status;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : loading = chargement pour ELF à mener.                       *
*                name    = indice de la désignation du symbole concerné.      *
*                virt    = adresse virtuelle du symbole en mémoire.           *
*                prefix  = préfixe d'une désignation par défaut.              *
*                alt     = zone de constitution d'un nom alternatif. [OUT]    *
*                addr    = localisation compléte à associer au symbole. [OUT] *
*                                                                             *
*  Description : Construit la désignation adaptée à un symbole.               *
*                                                                             *
*  Retour      : Pointeur vers une étiquette constituée.                      *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const char *g_elf_loading_build_name(const GElfLoading *loading, uint32_t name, virt_t virt, const char *prefix, char *alt, vmpa2t *addr)
{
    const char *result;                     /* Désignation à retourner     */
    GElfFormat *format;                     /* Format plus accessible      */
    vmpa2t pos;                             /* Position de lecture         */
    const GBinContent *content;             /* Contenu binaire à lire      */
    size_t plen;                            /* Taille du préfixe           */

    result = NULL;

    format = loading->format;

    if (g_exe_format_translate_address_into_vmpa(G_EXE_FORMAT(format), virt, addr))
    {
        init_vmpa(&pos, loading->str_start + name, VMPA_NO_VIRTUAL);

        content = G_BIN_FORMAT(format)->content;

        result = (const char *)g_binary_content_get_raw_access(content, &pos, 1);

        if (result != NULL && result[0] == '\0')
            result = NULL;

        if (result == NULL)
        {
            /**
             * Charge à l'appelant de s'assurer que la zone tampon est assez grande !
             */

            strcpy(alt, prefix);
            plen = strlen(prefix);

            if (loading->use_virt)
                vmpa2_virt_to_string(addr, MDS_UNDEFINED, alt + plen, NULL);
            else
                vmpa2_phys_to_string(addr, MDS_UNDEFINED, alt + plen, NULL);

            result = alt;

        }

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : loading = chargement pour ELF à compléter.                   *
*                iter    = tête de lecture courante.                          *
*                reloc   = relocalisation à conserver en mémoire.             *
*                                                                             *
*  Description : Intègre dans la liste adaptée une relocalisation chargée.    *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_elf_loading_store_relocation(const GElfLoading *loading, const phys_t *iter, const elf_rel *reloc)
{
    GElfFormat *format;                     /* Format plus accessible      */
    size_t index;                           /* Indice de l'élément         */

    format = loading->format;

    index = (*iter - loading->begin);

    assert(index % sizeof(ELF_SIZEOF_REL(format)) == 0);

    index /= sizeof(ELF_SIZEOF_REL(format));

    /* La tête de lecture a consommé un élément ! */
    index--;

    memcpy(&loading->relocs_to_fill[index], reloc, sizeof(elf_rel));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : loading = chargement pour ELF à consulter.                   *
*                offset = décalage à retrouver idéalement.                    *
*                reloc  = informations quant à la relocalisation. [OUT]       *
*                                                                             *
*  Description : Recherche une relocalisation par son décalage.               *
*                                                                             *
*  Retour      : Bilan de l'opération.                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_elf_loading_search_for_relocation(const GElfLoading *loading, const uint64_t *offset, elf_rel **reloc)
{
    bool result;                            /* Validité à faire remonter   */
    void *found;                            /* Eventuel élément trouvé     */

    int compare_relocations(const uint64_t *off, const elf_rel *rel)
    {
        return sort_uint64_t(*off, ELF_REL(loading->format, *rel, r_offset));
    }

    found = bsearch(offset, loading->relocs, loading->rel_count,
                    sizeof(elf_rel), (__compar_fn_t)compare_relocations);

    result = (found != NULL);

    if (result)
        *reloc = (elf_rel *)found;

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : loading = chargement pour ELF à poursuivre.                  *
*                index   = indice du symbole concerné.                        *
*                                                                             *
*  Description : Construit la désignation adaptée à un symbole importé.       *
*                                                                             *
*  Retour      : Nouvelle étiquette constituée ou NULL en cas d'échec.        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

char *g_elf_loading_build_plt_name(const GElfLoading *loading, uint64_t index)
{
    char *result;                           /* Désignation à retourner     */
    GElfFormat *format;                     /* Format plus accessible      */
    phys_t offset;                          /* Tête de lecture brute       */
    elf_sym sym;                            /* Symbole aux infos visées    */
    bool status;                            /* Bilan de récupération       */
    uint32_t name;                          /* Indice du nom du symbole    */
    vmpa2t pos;                             /* Position de lecture         */
    const GBinContent *content;             /* Contenu binaire à lire      */
    const char *prefix;                     /* Première partie de nom      */

    format = loading->format;

    offset = loading->sym_start + index * ELF_SIZEOF_SYM(format);

    status = read_elf_symbol(format, &offset, &sym);

    if (!status)
        result = NULL;

    else
    {
        name = ELF_SYM(format, sym, st_name);

        offset = loading->str_start + name;

        init_vmpa(&pos, offset, VMPA_NO_VIRTUAL);

        content = G_BIN_FORMAT(format)->content;

        prefix = (const char *)g_binary_content_get_raw_access(content, &pos, 1);

        if (prefix != NULL && prefix[0] == '\0')
            result = NULL;

        else
        {
            result = strdup(prefix);
            result = stradd(result, "@plt");
        }

    }

    return result;

}