path: root/src/format/format.c

/* Chrysalide - Outil d'analyse de fichiers binaires
 * format.c - support des différents formats binaires
 *
 * Copyright (C) 2009-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 "format.h"


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


#include "format-int.h"
#include "dex/dex.h"
#include "dwarf/dwarf.h"
#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"



/* Initialise la classe des formats binaires génériques. */
static void g_binary_format_class_init(GBinFormatClass *);

/* Initialise une instance de format binaire générique. */
static void g_binary_format_init(GBinFormat *);

/* Retire un symbole de la collection du format binaire. */
static void _g_binary_format_remove_symbol(GBinFormat *, size_t);



/* Indique le type défini pour un format binaire générique. */
G_DEFINE_TYPE(GBinFormat, g_binary_format, G_TYPE_OBJECT);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des formats binaires génériques.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_binary_format_class_init(GBinFormatClass *klass)
{

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = instance à initialiser.                             *
*                                                                             *
*  Description : Initialise une instance de format binaire générique.         *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_binary_format_init(GBinFormat *format)
{

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format  = description de l'exécutable à consulter.           *
*                content = contenu binaire à parcourir.                       *
*                length  = taille du contenu fourni.                          *
*                                                                             *
*  Description : Définit le contenu binaire à analyser.                       *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_set_content(GBinFormat *format, GBinContent *content)
{

    format->conten_ = content;

    format->content = g_binary_content_get(content, &format->length);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = description de l'exécutable à consulter.            *
*                length = taille du contenu à fournir. [OUT]                  *
*                                                                             *
*  Description : Fournit une référence vers le contenu binaire analysé.       *
*                                                                             *
*  Retour      : Adresse du tampon contenant le contenu du binaire.           *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const bin_t *g_binary_format_get_content(const GBinFormat *format, off_t *length)
{
    if (length != NULL) *length = format->length;

    return format->content;

}




GBinContent *g_binary_format_get_conten_(const GBinFormat *format)
{
    g_object_ref(G_OBJECT(format->conten_));


    return format->conten_;

}




/******************************************************************************
*                                                                             *
*  Paramètres  : format = description de l'exécutable à consulter.            *
*                ctx    = contexte de désassemblage à préparer.               *
*                                                                             *
*  Description : Fournit un contexte initialisé pour un désassemblage.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_setup_disassembling_context(const GBinFormat *format, GProcContext *ctx)
{
    size_t i;                               /* Boucle de parcours          */

    for (i = 0; i < format->ep_count; i++)
        g_proc_context_push_drop_point(ctx, format->entry_points[i]);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à compléter.                  *
*                symbol = symbole à ajouter à la liste.                       *
*                                                                             *
*  Description : Ajoute un symbole à la collection du format binaire.         *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_add_symbol(GBinFormat *format, GBinSymbol *symbol)
{
    format->symbols = (GBinSymbol **)realloc(format->symbols,
                                             ++format->symbols_count * sizeof(GBinSymbol *));

    format->symbols[format->symbols_count - 1] = symbol;

	qsort(format->symbols, format->symbols_count,
		  sizeof(GBinSymbol *), (__compar_fn_t)g_binary_symbol_cmp);

    switch (g_binary_symbol_get_target_type(symbol))
    {
        case STP_ROUTINE:
        case STP_ENTRY_POINT:

            format->routines = (GBinRoutine **)realloc(format->routines,
                                                       ++format->routines_count * sizeof(GBinRoutine *));

            format->routines[format->routines_count - 1] = g_binary_symbol_get_routine(symbol);
            
            qsort(format->routines, format->routines_count,
                  sizeof(GBinRoutine *), (__compar_fn_t)g_binary_routine_compare);

            break;

        default:
            break;

    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à compléter.                  *
*                index  = indice du symbole à retirer de la liste.            *
*                                                                             *
*  Description : Retire un symbole de la collection du format binaire.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void _g_binary_format_remove_symbol(GBinFormat *format, size_t index)
{
    GBinSymbol *symbol;                     /* Symbole visé par l'opération*/
    GBinRoutine *routine;                   /* Eventuelle routine associée */
    size_t i;                               /* Boucle de parcours          */

    /**
     * TODO : envoyer un signal pour avertir les opérandes concernées.
     */

    symbol = format->symbols[index];

    switch (g_binary_symbol_get_target_type(symbol))
    {
        case STP_ROUTINE:
        case STP_ENTRY_POINT:

            routine = g_binary_symbol_get_routine(symbol);

            for (i = 0; i < format->routines_count; i++)
                if (format->routines[i] == routine)
                    break;

            assert(i < format->routines_count);

            if ((i + 1) < format->routines_count)
                memmove(&format->routines[i], &format->routines[i + 1],
                        (format->routines_count - i - 1) * sizeof(GBinRoutine *));

            format->routines = (GBinRoutine **)realloc(format->routines,
                                                       --format->routines_count * sizeof(GBinRoutine *));

            break;

        default:
            break;

    }

    assert(index < format->symbols_count);

    if ((index + 1) < format->symbols_count)
        memmove(&format->symbols[index], &format->symbols[index + 1],
                (format->symbols_count - index - 1) * sizeof(GBinSymbol *));

    format->symbols = (GBinSymbol **)realloc(format->symbols,
                                             --format->symbols_count * sizeof(GBinSymbol *));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à compléter.                  *
*                symbol = symbole à retirer de la liste.                      *
*                                                                             *
*  Description : Retire un symbole de la collection du format binaire.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_remove_symbol(GBinFormat *format, GBinSymbol *symbol)
{
    size_t i;                               /* Boucle de parcours          */

    for (i = 0; i < format->symbols_count; i++)
        if (format->symbols[i] == symbol)
            break;

    _g_binary_format_remove_symbol(format, i);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                count  = taille du tableau créé. [OUT]                       *
*                                                                             *
*  Description : Fournit la liste de tous les symboles détectés.              *
*                                                                             *
*  Retour      : Tableau créé ou NULL si aucun symbole trouvé.                *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GBinSymbol **g_binary_format_get_symbols(const GBinFormat *format, size_t *count)
{
    *count = format->symbols_count;

    return format->symbols;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                addr   = adresse liée à la chaîne à traiter.                 *
*                base   = contenu complet et original d'une chaîne.           *
*                length = taille de la chaîne à représenter.                  *
*                                                                             *
*  Description : Construit une désignation pour chaîne de caractères.         *
*                                                                             *
*  Retour      : Chaîne de caractères à libérer de la mémoire.                *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

char *create_string_label(GBinFormat *format, const vmpa2t *addr, const char *base, size_t length)
{
    char *result;                           /* Nouvelle chaîne à retourner */
    unsigned int wc;                        /* Nombre de mots rencontrés   */
    size_t iter;                            /* Tête d'écriture de recopie  */
    size_t i;                               /* Boucle de parcours          */
    bool empty;                             /* Base de l'étiquette vide ?  */
    GBinSymbol *found;                      /* Symbole similaire trouvé    */
    VMPA_BUFFER(last_sfx);                  /* Dernier suffixe à intégrer  */

    result = (char *)calloc(length + 5 + VMPA_MAX_LEN + 1, sizeof(char));

    wc = 0;

    iter = 0;

    for (i = 0; i < length; i++)
    {
        if (isalnum(base[i])) result[iter++] = tolower(base[i]);

        else if (iter > 0)
        {
            if (result[iter - 1] != '_') wc++;

            if (wc == 3) break;

            if (result[iter - 1] != '_') result[iter++] = '_';

        }

    }

    /* Détermination du suffixe suffisant */

    empty = (iter == 0);

    if (iter > 0 && result[iter - 1] != '_') result[iter++] = '_';

    strcpy(&result[iter], "str");
    iter += 3;

    found = NULL;

    if (empty || g_binary_format_find_symbol_by_label(format, result, &found))
    {
        if (found != NULL)
            g_object_unref(G_OBJECT(found));

        if (iter > 0 && result[iter - 1] != '_') result[iter++] = '_';

        assert(has_phys_addr(addr) || has_virt_addr(addr));

        /* TODO : use_phy_instead_of_virt */
        if (has_virt_addr(addr))
            vmpa2_virt_to_string(addr, MDS_UNDEFINED, last_sfx, NULL);
        else
            vmpa2_phys_to_string(addr, MDS_UNDEFINED, last_sfx, NULL);

        strcpy(&result[iter], last_sfx);

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                label  = étiquette à retrouver lors des recherches.          *
*                symbol = éventuel symbole trouvé à déréfenrencer. [OUT]      *
*                                                                             *
*  Description : Recherche le symbole correspondant à une étiquette.          *
*                                                                             *
*  Retour      : true si l'opération a été un succès, false sinon.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_binary_format_find_symbol_by_label(const GBinFormat *format, const char *label, GBinSymbol **symbol)
{
    bool result;                            /* Bilan à retourner           */
    size_t i;                               /* Boucle de parcours          */
    const char *cur_lbl;                    /* Etiquette courante          */

    result = false;

    for (i = 0; i < format->symbols_count && !result; i++)
    {
        cur_lbl = g_binary_symbol_get_label(format->symbols[i]);
        if (cur_lbl == NULL) continue;

        if (strcmp(label, cur_lbl) == 0)
        {
            *symbol = format->symbols[i];
            g_object_ref(G_OBJECT(*symbol));

            result = true;

        }

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                addr   = adresse à cibler lors des recherches.               *
*                symbol = éventuel symbole trouvé à déréfenrencer. [OUT]      *
*                                                                             *
*  Description : Recherche le symbole correspondant à une adresse.            *
*                                                                             *
*  Retour      : true si l'opération a été un succès, false sinon.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_binary_format_find_symbol_at(const GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol)
{
    bool result;                            /* Bilan à retourner           */
    size_t i;                               /* Boucle de parcours          */
    const mrange_t *range;                  /* Espace mémoire parcouru     */

    result = false;

    *symbol = NULL; /* TODO : vérifier les doublons côtés appelants */

    for (i = 0; i < format->symbols_count && !result; i++)
    {
        range = g_binary_symbol_get_range(format->symbols[i]);

        if (cmp_vmpa(get_mrange_addr(range), addr) == 0)
        {
            *symbol = format->symbols[i];
            g_object_ref(G_OBJECT(*symbol));

            result = true;

        }

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                addr   = adresse à cibler lors des recherches.               *
*                symbol = éventuel symbole trouvé à déréfenrencer. [OUT]      *
*                                                                             *
*  Description : Recherche le symbole suivant celui lié à une adresse.        *
*                                                                             *
*  Retour      : true si l'opération a été un succès, false sinon.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_binary_format_find_next_symbol_at(const GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol)
{
    bool result;                            /* Bilan à retourner           */
    size_t i;                               /* Boucle de parcours          */
    const mrange_t *range;                  /* Espace mémoire parcouru     */

    result = false;

    *symbol = NULL;

    for (i = 0; i < format->symbols_count && !result; i++)
    {
        range = g_binary_symbol_get_range(format->symbols[i]);

        if (cmp_vmpa(get_mrange_addr(range), addr) == 0 && (i + 1) < format->symbols_count)
        {
            *symbol = format->symbols[i + 1];
            g_object_ref(G_OBJECT(*symbol));

            result = true;

        }

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                addr   = adresse à cibler lors des recherches.               *
*                symbol = éventuel symbole trouvé à déréfenrencer. [OUT]      *
*                diff   = décallage entre l'adresse et le symbole. [OUT]      *
*                                                                             *
*  Description : Recherche le symbole correspondant à une adresse.            *
*                                                                             *
*  Retour      : true si l'opération a été un succès, false sinon.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_binary_format_resolve_symbol(const GBinFormat *format, const vmpa2t *addr, GBinSymbol **symbol, phys_t *diff)
{
    bool result;                            /* Bilan à retourner           */
    size_t i;                               /* Boucle de parcours          */
    const mrange_t *range;                  /* Espace mémoire parcouru     */

    result = false;

    //for (i = 0; i < format->symbols_count && !result; i++)
    for (i = format->symbols_count; i > 0 && !result; i--)
    {
        range = g_binary_symbol_get_range(format->symbols[i - 1]);

        if (mrange_contains_addr(range, addr))
        {
            *symbol = format->symbols[i - 1];
            g_object_ref(G_OBJECT(*symbol));

            *diff = compute_vmpa_diff(get_mrange_addr(range), addr);

            result = true;

        }

    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format  = informations chargées à compléter.                 *
*                routine = routine à ajouter à la liste.                      *
*                                                                             *
*  Description : Ajoute une routine à la collection du format binaire.        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_add_routine(GBinFormat *format, GBinRoutine *routine)
{
    format->routines = (GBinRoutine **)realloc(format->routines,
                                               ++format->routines_count * sizeof(GBinRoutine *));

    format->routines[format->routines_count - 1] = routine;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format  = informations chargées à compléter.                 *
*                routine = routine à ajouter à la liste.                      *
*                                                                             *
*  Description : Retire une routine de la collection du format binaire.       *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_remove_routine(GBinFormat *format, GBinRoutine *routine)
{
    size_t index;                           /* Indice trouvé à utiliser    */
    size_t i;                               /* Boucle de parcours          */
    GBinSymbol *symbol;                     /* Symbole en cours d'analyse  */

    index = format->symbols_count;

    for (i = 0; i < format->symbols_count && index == format->symbols_count; i++)
    {
        symbol = format->symbols[i];

        switch (g_binary_symbol_get_target_type(symbol))
        {
            case STP_ROUTINE:
            case STP_ENTRY_POINT:

                if (g_binary_symbol_get_routine(symbol) == routine)
                    index = i;

                break;

            default:
                break;

        }

    }

    _g_binary_format_remove_symbol(format, index);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                count  = taille du tableau créé. [OUT]                       *
*                                                                             *
*  Description : Fournit le prototype de toutes les routines détectées.       *
*                                                                             *
*  Retour      : Tableau créé ou NULL si aucun symbole de routine trouvé.     *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GBinRoutine **g_binary_format_get_routines(const GBinFormat *format, size_t *count)
{
    *count = format->routines_count;

    return format->routines;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format = informations chargées à consulter.                  *
*                count  = taille de la liste retournée. [OUT]                 *
*                defsrc = fichier de code principal. [OUT]                    *
*                                                                             *
*  Description : Fournit la liste des fichiers source détectés.               *
*                                                                             *
*  Retour      : Liste de noms de fichier ou NULL si aucun.                   *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const char * const *g_binary_format_get_source_files(const GBinFormat *format, size_t *count, size_t *defsrc)
{
    *count = format->src_count;
    *defsrc = format->def_source;

    return format->src_files;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format   = informations chargées à consulter.                *
*                buffer   = tampon mis à disposition pour la sortie.          *
*                filename = nom du fichier source à cibler.                   *
*                                                                             *
*  Description : Procède à la décompilation complète du format.               *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_binary_format_decompile(const GBinFormat *format, GCodeBuffer *buffer, const char *filename)
{


    GBinRoutine **routines;
    size_t count;

    size_t i;

    GDecInstruction *instr;

    if (format->decompile != NULL)
        format->decompile(format, buffer, filename);
    

    routines = g_binary_format_get_routines(format, &count);



    for (i = 0; i < count; i++)
    {
        //printf(" -- %s --\n", g_binary_routine_get_name(routines[i]));

        //if (strcmp("cryptself", g_binary_routine_get_name(routines[i])) == 0)
        {
            instr = g_binary_routine_get_decomp_instructions(routines[i]);

            if (instr == NULL) continue;

            //g_dec_instruction_print(instr, buffer, NULL, g_java_output_new());



        }


    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : format  = informations chargées à consulter.                 *
*                label   = étiquette du symbole si trouvé. [OUT]              *
*                address = adresse à cibler, puis décallage final. [OUT]      *
*                                                                             *
*  Description : Recherche une position dans une routine selon une adresse.   *
*                                                                             *
*  Retour      : true si l'opération a été un succès, false sinon.            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_binary_format_resolve_relative_routine(const GBinFormat *format, const char **label, vmpa_t *address)
{
    bool result;                            /* Bilan à retourner           */
    size_t i;                               /* Boucle de parcours          */
    vmpa_t addr;                            /* Adresse de symbole          */
    off_t size;                             /* Taille du symole            */

    result = false;

    for (i = 0; i < format->routines_count && !result; i++)
    {
        addr = g_binary_routine_get_address(format->routines[i]);
        size = g_binary_routine_get_size(format->routines[i]);

        if (addr <= *address && *address < (addr + size))
        {
            *label = g_binary_routine_get_long_name(format->routines[i]);
            *address -= addr;

            result = true;

        }

    }

    return result;

}