/* Chrysalide - Outil d'analyse de fichiers binaires
* pool.c - extraction des informations issues des tables globales
*
* Copyright (C) 2010-2012 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 .
*/
#include "pool.h"
#include
#include
#include "dex-int.h"
#include "../mangling/demangler.h"
#include "../mangling/dex/context.h"
/******************************************************************************
* *
* Paramètres : format = description de l'exécutable à analyser. *
* *
* Description : Charge en mémoire toutes les chaînes trouvées. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
bool find_all_dex_strings(GDexFormat *format)
{
uint32_t i; /* Boucle de parcours */
const char *text; /* Texte issu du binaire */
GBinSymbol *symbol; /* Nouveau symbole construit */
for (i = 0; i < format->header.string_ids_size; i++)
{
text = get_string_from_dex_pool(format, i);
if (text == NULL) continue;
symbol = g_binary_symbol_new(STP_STRING);
g_binary_symbol_set_alt_label(symbol, text);
g_binary_format_add_symbol(G_BIN_FORMAT(format), symbol);
}
return true;
}
/******************************************************************************
* *
* Paramètres : format = représentation interne du format DEX à consulter. *
* index = index du type recherchée. *
* *
* Description : Extrait une chaîne de caractères d'une table DEX. *
* *
* Retour : Chaîne de caractères trouvées ou NULL en cas d'erreur. *
* *
* Remarques : - *
* *
******************************************************************************/
const char *get_string_from_dex_pool(const GDexFormat *format, uint32_t index)
{
off_t pos; /* Tête de lecture */
vmpa2t addr; /* Tête de lecture générique */
string_id_item str_id; /* Identifiant de chaîne */
string_data_item str_data; /* Description de chaîne */
if (index >= format->header.string_ids_size)
return NULL;
pos = format->header.string_ids_off + index * sizeof(string_id_item);
init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
if (!read_dex_string_id_item(format, &addr, &str_id))
return NULL;
pos = str_id.string_data_off;
init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
if (!read_dex_string_data_item(format, &addr, &str_data))
return NULL;
return (const char *)str_data.data;
}
/******************************************************************************
* *
* Paramètres : format = description de l'exécutable à compléter. *
* *
* Description : Charge en mémoire l'ensemble des types du format DEX. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
bool load_all_dex_types(GDexFormat *format)
{
bool result; /* Bilan à retourner */
uint32_t i; /* Boucle de parcours */
GDataType *type; /* Type récupéré */
result = true;
format->types = (GDataType **)calloc(format->header.type_ids_size, sizeof(GDataType *));
for (i = 0; i < format->header.type_ids_size && result; i++)
{
type = get_type_from_dex_pool(format, i);
if (type != NULL)
g_object_unref(G_OBJECT(type));
else
result = false;
}
return result;
}
/******************************************************************************
* *
* Paramètres : format = représentation interne du format DEX à consulter. *
* index = index du type recherchée. *
* *
* Description : Extrait une représentation de type d'une table DEX. *
* *
* Retour : Composant GLib créé. *
* *
* Remarques : - *
* *
******************************************************************************/
GDataType *get_type_from_dex_pool(GDexFormat *format, uint32_t index)
{
GDataType *result; /* Instance à retourner */
phys_t pos; /* Tête de lecture */
vmpa2t addr; /* Tête de lecture générique */
type_id_item type_id; /* Définition de la classe */
string_id_item str_id; /* Identifiant de chaîne */
string_data_item str_data; /* Description de chaîne */
result = NULL;
if (index >= format->header.type_ids_size)
goto gtfdp_error;
if (format->types[index] == NULL)
{
pos = format->header.type_ids_off + index * sizeof(type_id_item);
init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
if (!read_dex_type_id_item(format, &addr, &type_id))
goto gtfdp_error;
pos = format->header.string_ids_off + type_id.descriptor_idx * sizeof(string_id_item);
init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
if (!read_dex_string_id_item(format, &addr, &str_id))
goto gtfdp_error;
pos = str_id.string_data_off;
init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
if (!read_dex_string_data_item(format, &addr, &str_data))
goto gtfdp_error;
format->types[index] = demangle_type(G_TYPE_DEX_DEMANGLER, (char *)str_data.data);
}
result = format->types[index];
if (result != NULL)
g_object_ref(G_OBJECT(result));
gtfdp_error:
return result;
}
/******************************************************************************
* *
* Paramètres : format = description de l'exécutable à compléter. *
* *
* Description : Charge en mémoire l'ensemble des champs du format DEX. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
bool load_all_dex_fields(GDexFormat *format)
{
bool result; /* Bilan à retourner */
uint32_t i; /* Boucle de parcours */
GBinVariable *field; /* Champ récupéré */
result = true;
format->fields = (GBinVariable **)calloc(format->header.field_ids_size, sizeof(GBinVariable *));
for (i = 0; i < format->header.field_ids_size && result; i++)
{
field = get_field_from_dex_pool(format, i);
if (field != NULL)
g_object_unref(G_OBJECT(field));
else
result = false;
}
return result;
}
/******************************************************************************
* *
* Paramètres : format = représentation interne du format DEX à consulter. *
* index = index du champ recherché. *
* *
* Description : Extrait une représentation de champ d'une table DEX. *
* *
* Retour : Composant GLib créé. *
* *
* Remarques : - *
* *
******************************************************************************/
GBinVariable *get_field_from_dex_pool(GDexFormat *format, uint32_t index)
{
GBinVariable *result; /* Instance à retourner */
phys_t pos; /* Tête de lecture */
vmpa2t addr; /* Tête de lecture générique */
field_id_item field_id; /* Description du champ */
GDataType *type; /* Type du champ */
const char *name; /* Désignation humaine */
GBinVariable *field; /* Instance nouvelle à définir */
GDataType *owner; /* Propriétaire du champ */
result = NULL;
if (index >= format->header.field_ids_size)
goto gffdp_error;
if (format->fields[index] == NULL)
{
pos = format->header.field_ids_off + index * sizeof(field_id_item);
init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
if (!read_dex_field_id_item(format, &addr, &field_id))
goto gffdp_error;
type = get_type_from_dex_pool(format, field_id.type_idx);
if (type == NULL) goto gffdp_error;
name = get_string_from_dex_pool(format, field_id.name_idx);
if (name == NULL) goto gffdp_bad_name;
field = g_binary_variable_new(type);
g_binary_variable_set_name(field, name);
if (field_id.class_idx != NO_INDEX)
{
owner = get_type_from_dex_pool(format, field_id.class_idx);
if (owner == NULL) goto gffdp_bad_owner;
g_binary_variable_set_owner(field, owner);
}
format->fields[index] = field;
}
result = format->fields[index];
if (result != NULL)
g_object_ref(G_OBJECT(result));
gffdp_error:
return result;
gffdp_bad_owner:
g_object_ref(G_OBJECT(type));
g_object_unref(G_OBJECT(result));
gffdp_bad_name:
g_object_unref(G_OBJECT(type));
return NULL;
}
/******************************************************************************
* *
* Paramètres : format = représentation interne du format DEX à compléter. *
* *
* Description : Charge tous les prototypes listés dans le contenu binaire. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
bool load_all_dex_prototypes(GDexFormat *format)
{
bool result; /* Bilan à retourner */
uint32_t i; /* Boucle de parcours */
GBinRoutine *proto; /* Prototype récupéré */
result = true;
format->prototypes = (GBinRoutine **)calloc(format->header.proto_ids_size, sizeof(GBinRoutine *));
for (i = 0; i < format->header.proto_ids_size && result; i++)
{
proto = get_prototype_from_dex_pool(format, i);
if (proto != NULL)
g_object_unref(G_OBJECT(proto));
else
result = false;
}
return result;
}
/******************************************************************************
* *
* Paramètres : format = représentation interne du format DEX à consulter. *
* index = index de la routine recherchée. *
* *
* Description : Extrait une représentation de routine d'une table DEX. *
* *
* Retour : Composant GLib créé. *
* *
* Remarques : - *
* *
******************************************************************************/
GBinRoutine *get_prototype_from_dex_pool(GDexFormat *format, uint32_t index)
{
GBinRoutine *result; /* Instance à retourner */
phys_t pos; /* Tête de lecture */
vmpa2t addr; /* Tête de lecture générique */
proto_id_item proto_id; /* Prototype de routine */
GDataType *type; /* Type de retour */
const char *name; /* Description compressée */
type_list args; /* Liste des arguments */
uint32_t i; /* Boucle de parcours */
GBinVariable *arg; /* Argument reconstitué */
result = NULL;
if (index >= format->header.method_ids_size)
goto grfdp_error;
if (format->prototypes[index] == NULL)
{
pos = format->header.proto_ids_off + index * sizeof(proto_id_item);
init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
if (!read_dex_proto_id_item(format, &addr, &proto_id))
goto grfdp_error;
/* Type de retour */
type = get_type_from_dex_pool(format, proto_id.return_type_idx);
/* Nom de la méthode */
name = get_string_from_dex_pool(format, proto_id.shorty_idx);
/* Liste des arguments */
pos = proto_id.parameters_off;
init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
if (read_dex_type_list(format, &addr, &args))
for (i = 0; i < args.size; i++)
{
type = get_type_from_dex_pool(format, args.list[i].type_idx);
if (type == NULL) continue;
arg = g_binary_variable_new(type);
//g_binary_routine_add_arg(result, arg);
}
/* Mise en place finale */
format->prototypes[index] = demangle_routine(G_TYPE_DEX_DEMANGLER, name);
#if 0
if (format->prototypes[index] != NULL)
g_binary_routine_set_return_type(format->prototypes[index], type);
#endif
}
result = format->prototypes[index];
if (result != NULL)
g_object_ref(G_OBJECT(result));
grfdp_error:
return result;
}
/******************************************************************************
* *
* Paramètres : format = représentation interne du format DEX à compléter. *
* *
* Description : Charge toutes les méthodes listées dans le contenu binaire. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
bool load_all_dex_methods(GDexFormat *format)
{
bool result; /* Bilan à retourner */
uint32_t i; /* Boucle de parcours */
GDexMethod *method; /* Méthode récupérée */
result = true;
format->methods = (GDexMethod **)calloc(format->header.method_ids_size, sizeof(GDexMethod *));
for (i = 0; i < format->header.method_ids_size && result; i++)
{
method = get_method_from_dex_pool(format, i);
if (method != NULL)
g_object_unref(G_OBJECT(method));
else
result = false;
}
return result;
}
/******************************************************************************
* *
* Paramètres : format = représentation interne du format DEX à consulter. *
* index = index de la classe recherchée. *
* *
* Description : Extrait une représentation de méthode d'une table DEX. *
* *
* Retour : Composant GLib créé. *
* *
* Remarques : - *
* *
******************************************************************************/
GDexMethod *get_method_from_dex_pool(GDexFormat *format, uint32_t index)
{
GDexMethod *result; /* Instance à retourner */
phys_t pos; /* Tête de lecture */
vmpa2t addr; /* Tête de lecture générique */
method_id_item method_id; /* Définition de la méthode */
result = NULL;
if (index >= format->header.method_ids_size)
goto gmfdp_error;
if (format->methods[index] == NULL)
{
pos = format->header.method_ids_off + index * sizeof(method_id_item);
init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
if (!read_dex_method_id_item(format, &addr, &method_id))
goto gmfdp_error;
format->methods[index] = g_dex_method_new_empty(format, &method_id);
}
result = format->methods[index];
if (result != NULL)
g_object_ref(G_OBJECT(result));
gmfdp_error:
return result;
}
/******************************************************************************
* *
* Paramètres : format = représentation interne du format DEX à compléter. *
* *
* Description : Charge toutes les classes listées dans le contenu binaire. *
* *
* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
bool load_all_dex_classes(GDexFormat *format)
{
bool result; /* Bilan à retourner */
uint32_t i; /* Boucle de parcours */
GDexClass *class; /* Classe récupérée */
result = true;
format->classes = (GDexClass **)calloc(format->header.class_defs_size, sizeof(GDexClass *));
for (i = 0; i < format->header.class_defs_size && result; i++)
{
class = get_class_from_dex_pool(format, i);
if (class != NULL)
g_object_unref(G_OBJECT(class));
else
result = false;
}
return result;
}
/******************************************************************************
* *
* Paramètres : format = représentation interne du format DEX à consulter. *
* index = index de la classe recherchée. *
* *
* Description : Extrait une représentation de classe d'une table DEX. *
* *
* Retour : Composant GLib créé. *
* *
* Remarques : - *
* *
******************************************************************************/
GDexClass *get_class_from_dex_pool(GDexFormat *format, uint32_t index)
{
GDexClass *result; /* Instance à retourner */
phys_t pos; /* Tête de lecture */
vmpa2t addr; /* Tête de lecture générique */
class_def_item class_def; /* Définition de la classe */
result = NULL;
if (index >= format->header.class_defs_size)
goto gcfdp_error;
if (format->classes[index] == NULL)
{
pos = format->header.class_defs_off + index * sizeof(class_def_item);
init_vmpa(&addr, pos, VMPA_NO_VIRTUAL);
if (!read_dex_class_def_item(format, &addr, &class_def))
goto gcfdp_error;
format->classes[index] = g_dex_class_new(format, &class_def);
}
result = format->classes[index];
if (result != NULL)
g_object_ref(G_OBJECT(result));
gcfdp_error:
return result;
}