summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/analysis/disass/links.c31
-rw-r--r--src/analysis/type-int.h67
-rw-r--r--src/arch/instruction-int.h1
-rw-r--r--src/arch/instruction.c28
-rw-r--r--src/arch/instruction.h7
-rw-r--r--src/common/leb128.h11
-rw-r--r--src/format/dex/class.c59
-rw-r--r--src/format/dex/class.h6
-rw-r--r--src/format/dex/dex-int.c266
-rwxr-xr-xsrc/format/dex/dex-int.h30
-rwxr-xr-xsrc/format/dex/dex.c41
-rwxr-xr-xsrc/format/dex/dex.h2
-rwxr-xr-xsrc/format/dex/dex_def.h47
-rw-r--r--src/format/dex/method.c46
-rw-r--r--src/format/dex/method.h6
-rw-r--r--src/gtkext/graph/dot.c18
-rw-r--r--src/gtkext/graph/layout.c35
-rw-r--r--src/gtkext/gtkgraphview.c2
-rw-r--r--src/gtkext/gtklinkrenderer.c16
-rw-r--r--src/gtkext/gtklinkrenderer.h1
-rw-r--r--src/plugins/plugin.c11
21 files changed, 681 insertions, 50 deletions
diff --git a/src/analysis/disass/links.c b/src/analysis/disass/links.c
index 4d799fc..7cc3c27 100644
--- a/src/analysis/disass/links.c
+++ b/src/analysis/disass/links.c
@@ -50,12 +50,14 @@ void establish_links_between_lines(GArchInstruction *list, GBinRoutine **routine
vmpa_t addr; /* Adresse référencée */
InstructionLinkType type; /* Type de référence */
GArchInstruction *target; /* Ligne visée par la référence*/
+ GArchInstruction *prev; /* Instruction précédente */
for (i = 0; i < count; i++)
{
start = g_binary_routine_get_address(routines[i]);
end = start + g_binary_routine_get_size(routines[i]);
+ /* Définition de toutes les destinations */
for (iter = g_arch_instruction_find_by_address(list, start, true);
iter != NULL;
iter = g_arch_instruction_get_next_iter(list, iter, end))
@@ -104,10 +106,39 @@ void establish_links_between_lines(GArchInstruction *list, GBinRoutine **routine
break;
+ default:
+ /**
+ * Note pour GCC : à ce stade du désassemblage, ILT_CATCH_EXCEPTION
+ * ne peut être présente, car ne provenant que de greffons.
+ * Pour ILT_EXEC_FLOW, sa seule insertion est ici, plus bas.
+ */
+ break;
+
}
}
+ /* Rattachement de deux blocs selon le flux normal */
+
+ iter = g_arch_instruction_find_by_address(list, start, true);
+
+ for (iter = g_arch_instruction_get_next_iter(list, iter, end);
+ iter != NULL;
+ iter = g_arch_instruction_get_next_iter(list, iter, end))
+ {
+ if (!g_arch_instruction_has_sources(iter))
+ continue;
+
+ prev = g_arch_instruction_get_prev_iter(list, iter);
+
+ if (g_arch_instruction_is_return(prev))
+ continue;
+
+ if (!g_arch_instruction_has_destinations(prev))
+ g_arch_instruction_link_with(prev, iter, ILT_EXEC_FLOW);
+
+ }
+
gtk_extended_status_bar_update_activity(statusbar, id, (i + 1) * 1.0 / count);
}
diff --git a/src/analysis/type-int.h b/src/analysis/type-int.h
new file mode 100644
index 0000000..a26deeb
--- /dev/null
+++ b/src/analysis/type-int.h
@@ -0,0 +1,67 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * type-int.h - prototypes pour la définition interne des types de données
+ *
+ * Copyright (C) 2012 Cyrille Bagard
+ *
+ * This file is part of OpenIDA.
+ *
+ * OpenIDA is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenIDA is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_TYPE_INT_H
+#define _ANALYSIS_TYPE_INT_H
+
+
+#include "type.h"
+
+
+
+/* Décrit le type fourni sous forme de caractères. */
+typedef GDataType * (* type_dup_fc) (const GDataType *);
+
+/* Décrit le type fourni sous forme de caractères. */
+typedef char * (* type_to_string_fc) (const GDataType *);
+
+/* Procède à l'impression de la description d'un type. */
+typedef void (* output_type_fc) (const GDataType *, GLangOutput *, GBufferLine *, bool, bool);
+
+
+/* Description de type quelconque (instance) */
+struct _GDataType
+{
+ GObject parent; /* A laisser en premier */
+
+ type_dup_fc dup; /* Copie d'instance existante */
+ type_to_string_fc to_string; /* Conversion au format texte */
+ output_type_fc output; /* Impression à l'écran */
+
+ GDataType *namespace; /* Espace de noms / classe */
+ TypeQualifier qualifiers; /* Eventuels qualificatifs */
+
+ GTypesManager *manager; /* Gestionnaire global */
+
+};
+
+/* Description de type quelconque (classe) */
+struct _GDataTypeClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+
+#endif /* _ANALYSIS_TYPE_INT_H */
diff --git a/src/arch/instruction-int.h b/src/arch/instruction-int.h
index e323d6c..c89a51b 100644
--- a/src/arch/instruction-int.h
+++ b/src/arch/instruction-int.h
@@ -83,6 +83,7 @@ struct _GArchInstructionClass
};
+#define ainstr_list_prev_iter(iter, head) dl_list_prev_iter(iter, head, GArchInstruction, flow)
#define ainstr_list_next_iter(iter, head) dl_list_next_iter(iter, head, GArchInstruction, flow)
#define ainstr_list_add_tail(new, head) dl_list_add_tail(new, head, GArchInstruction, flow)
#define ainstr_list_for_each(pos, head) dl_list_for_each(pos, head, GArchInstruction, flow)
diff --git a/src/arch/instruction.c b/src/arch/instruction.c
index b553aec..98d7c85 100644
--- a/src/arch/instruction.c
+++ b/src/arch/instruction.c
@@ -381,7 +381,9 @@ bool g_arch_instruction_has_sources(const GArchInstruction *instr)
bool g_arch_instruction_has_destinations(const GArchInstruction *instr)
{
- return (instr->to_count > 1 || (instr->to_count == 1 && instr->links_type[0] != ILT_CALL));
+ /* FIXME !? */
+ //return (instr->to_count > 1 || (instr->to_count == 1 && instr->links_type[0] != ILT_CALL));
+ return (instr->to_count > 0);
}
@@ -607,6 +609,30 @@ void g_arch_instruction_add_to_list(GArchInstruction **list, GArchInstruction *i
* *
* Paramètres : list = liste d'instructions à consulter. *
* : iter = position actuelle dans la liste. *
+* *
+* Description : Fournit l'élement suivant un autre pour un parcours. *
+* *
+* Retour : Elément suivant ou NULL si aucun. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GArchInstruction *g_arch_instruction_get_prev_iter(const GArchInstruction *list, const GArchInstruction *iter)
+{
+ GArchInstruction *result; /* Elément suivant à renvoyer */
+
+ result = ainstr_list_prev_iter(iter, list);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : list = liste d'instructions à consulter. *
+* : iter = position actuelle dans la liste. *
* max = adresse marquant la limite (exclue) du parcours. *
* *
* Description : Fournit l'élement suivant un autre pour un parcours. *
diff --git a/src/arch/instruction.h b/src/arch/instruction.h
index efd2b75..a4e26d4 100644
--- a/src/arch/instruction.h
+++ b/src/arch/instruction.h
@@ -42,10 +42,12 @@
typedef enum _InstructionLinkType
{
ILT_NONE, /* Aucune instruction visée */
+ ILT_EXEC_FLOW, /* Raccord attendu entre blocs */
ILT_JUMP, /* Saut inconditionnel */
ILT_JUMP_IF_TRUE, /* Saut conditionnel (si vrai) */
ILT_JUMP_IF_FALSE, /* Saut conditionnel (si faux) */
- ILT_CALL /* Appel d'une fonction */
+ ILT_CALL, /* Appel d'une fonction */
+ ILT_CATCH_EXCEPTION /* Gestion d'une exception */
} InstructionLinkType;
@@ -133,6 +135,9 @@ GDecInstruction *g_arch_instruction_decompile(const GArchInstruction *, GDecCont
void g_arch_instruction_add_to_list(GArchInstruction **, GArchInstruction *);
/* Fournit l'élement suivant un autre pour un parcours. */
+GArchInstruction *g_arch_instruction_get_prev_iter(const GArchInstruction *, const GArchInstruction *);
+
+/* Fournit l'élement suivant un autre pour un parcours. */
GArchInstruction *g_arch_instruction_get_next_iter(const GArchInstruction *, const GArchInstruction *, vmpa_t);
/* Recherche une instruction d'après son adresse. */
diff --git a/src/common/leb128.h b/src/common/leb128.h
index 0364cf7..398785f 100644
--- a/src/common/leb128.h
+++ b/src/common/leb128.h
@@ -26,6 +26,7 @@
#include <stdbool.h>
+#include <stdlib.h>
#include "../arch/archbase.h"
@@ -37,6 +38,16 @@ typedef uint64_t uleb128_t;
typedef int64_t leb128_t;
+/* Récupération de la valeur absolue */
+#define leb128_abs(v) llabs(v)
+
+
+/* Valeurs minimales et maximales */
+#define ULEB128_MIN UINT64_MIN
+#define ULEB128_MAX UINT64_MAX
+#define LEB128_MIN INT64_MIN
+#define LEB128_MAX INT64_MAX
+
/* Lit un nombre non signé encodé au format LEB128. */
bool read_uleb128(uleb128_t *, const bin_t *, off_t *, off_t);
diff --git a/src/format/dex/class.c b/src/format/dex/class.c
index 52389c4..52141ae 100644
--- a/src/format/dex/class.c
+++ b/src/format/dex/class.c
@@ -254,6 +254,61 @@ static void g_dex_class_register_method(const GDexClass *class, GBinFormat *form
/******************************************************************************
* *
+* Paramètres : class = informations chargées à consulter. *
+* virtual = précise la nature des méthodes ciblées. *
+* *
+* Description : Dénombre les méthodes chargées d'un type donné. *
+* *
+* Retour : Quantité de méthodes trouvées. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+size_t g_dex_class_count_methods(const GDexClass *class, bool virtual)
+{
+ size_t result; /* Compte à retourner */
+
+ if (virtual)
+ result = class->vmethods_count;
+ else
+ result = class->dmethods_count;
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : class = informations chargées à consulter. *
+* virtual = précise la nature des méthodes ciblées. *
+* index = indique l'indice de la méthode désirée. *
+* *
+* Description : Fournit une méthode chargée correspondant à un type donné. *
+* *
+* Retour : Quantité de méthodes trouvées. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GDexMethod *g_dex_class_get_method(const GDexClass *class, bool virtual, size_t index)
+{
+ GDexMethod *result; /* Instance à renvoyer */
+
+ if (virtual)
+ result = class->virtual_methods[index];
+ else
+ result = class->direct_methods[index];
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : class = informations chargées à consulter. *
* parts = liste à venir compléter. *
* count = quantité de zones listées. [OUT] *
@@ -294,6 +349,10 @@ GBinPart **g_dex_class_get_parts(const GDexClass *class, GBinPart **parts, size_
}
+
+
+
+
/******************************************************************************
* *
* Paramètres : class = informations chargées à consulter. *
diff --git a/src/format/dex/class.h b/src/format/dex/class.h
index 998c1b7..e7094ff 100644
--- a/src/format/dex/class.h
+++ b/src/format/dex/class.h
@@ -54,6 +54,12 @@ typedef struct _GDexClassClass GDexClassClass;
/* Détermine le type d'une classe issue du code source. */
GType g_dex_class_get_type(void);
+/* Dénombre les méthodes chargées d'un type donné. */
+size_t g_dex_class_count_methods(const GDexClass *, bool);
+
+/* Fournit une méthode chargée correspondant à un type donné. */
+GDexMethod *g_dex_class_get_method(const GDexClass *, bool, size_t);
+
/* Fournit les références aux zones binaires à analyser. */
GBinPart **g_dex_class_get_parts(const GDexClass *, GBinPart **, size_t *);
diff --git a/src/format/dex/dex-int.c b/src/format/dex/dex-int.c
index 5628e6b..200b01f 100644
--- a/src/format/dex/dex-int.c
+++ b/src/format/dex/dex-int.c
@@ -529,10 +529,226 @@ void reset_dex_class_data_item(class_data_item *item)
+/* ---------------------------------------------------------------------------------- */
+/* PORTION DE CODE EXECUTABLE */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* pos = position de début de lecture. [OUT] *
+* pair = structure lue à retourner. [OUT] *
+* *
+* Description : Procède à la lecture d'une association exception <-> code. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_encoded_type_addr_pair(const GDexFormat *format, off_t *pos, encoded_type_addr_pair *pair)
+{
+ bool result; /* Bilan à retourner */
+ const bin_t *content; /* Contenu binaire à lire */
+ off_t length; /* Taille totale du contenu */
+
+ result = true;
+
+ content = G_BIN_FORMAT(format)->content;
+ length = G_BIN_FORMAT(format)->length;
+
+ result &= read_uleb128(&pair->type_idx, content, pos, length);
+ result &= read_uleb128(&pair->addr, content, pos, length);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* pos = position de début de lecture. [OUT] *
+* handler = structure lue à retourner. [OUT] *
+* *
+* Description : Procède à la lecture d'une association exception <-> code. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_encoded_catch_handler(const GDexFormat *format, off_t *pos, encoded_catch_handler *handler)
+{
+ bool result; /* Bilan à retourner */
+ const bin_t *content; /* Contenu binaire à lire */
+ off_t length; /* Taille totale du contenu */
+ leb128_t count; /* Nombre de gestionnaires */
+ leb128_t i; /* Boucle de parcours */
+
+ result = true;
+
+ content = G_BIN_FORMAT(format)->content;
+ length = G_BIN_FORMAT(format)->length;
+
+ handler->offset = *pos;
+
+ result &= read_leb128(&handler->size, content, pos, length);
+
+ count = leb128_abs(handler->size);
+
+ if (count > 0 && result)
+ {
+ handler->handlers = (encoded_type_addr_pair *)calloc(count, sizeof(encoded_type_addr_pair));
+
+ for (i = 0; i < count && result; i++)
+ result &= read_dex_encoded_type_addr_pair(format, pos, &handler->handlers[i]);
+
+ }
+ else handler->handlers = NULL;
+
+ if (handler->size < 0)
+ result &= read_uleb128(&handler->catch_all_addr, content, pos, length);
+ else
+ handler->catch_all_addr = ULEB128_MAX;
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : handler = structure à nettoyer. *
+* *
+* Description : Supprime tous les éléments chargés en mémoire à la lecture. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void reset_dex_encoded_catch_handler(encoded_catch_handler *handler)
+{
+ if (handler->handlers != NULL)
+ free(handler->handlers);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* pos = position de début de lecture. [OUT] *
+* list = structure lue à retourner. [OUT] *
+* *
+* Description : Procède à la lecture d'une association exception <-> code. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_encoded_catch_handler_list(const GDexFormat *format, off_t *pos, encoded_catch_handler_list *list)
+{
+ bool result; /* Bilan à retourner */
+ const bin_t *content; /* Contenu binaire à lire */
+ off_t length; /* Taille totale du contenu */
+ off_t saved_off; /* Sauvegarde de position */
+ uleb128_t i; /* Boucle de parcours */
+ result = true;
+ content = G_BIN_FORMAT(format)->content;
+ length = G_BIN_FORMAT(format)->length;
+
+ saved_off = *pos;
+
+ result &= read_uleb128(&list->size, content, pos, length);
+ if (list->size > 0 && result)
+ {
+ list->list = (encoded_catch_handler *)calloc(list->size, sizeof(encoded_catch_handler));
+ for (i = 0; i < list->size && result; i++)
+ {
+ result &= read_dex_encoded_catch_handler(format, pos, &list->list[i]);
+ if (result) list->list[i].offset -= saved_off;
+ }
+
+ }
+ else list->list = NULL;
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : list = structure à nettoyer. *
+* *
+* Description : Supprime tous les éléments chargés en mémoire à la lecture. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void reset_dex_encoded_catch_handler_list(encoded_catch_handler_list *list)
+{
+ uleb128_t i; /* Boucle de parcours */
+
+ if (list->list != NULL)
+ {
+ for (i = 0; i < list->size; i++)
+ reset_dex_encoded_catch_handler(&list->list[i]);
+
+ free(list->list);
+
+ }
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* pos = position de début de lecture. [OUT] *
+* item = structure lue à retourner. [OUT] *
+* *
+* Description : Procède à la lecture d'une association exception <-> code. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_try_item(const GDexFormat *format, off_t *pos, try_item *item)
+{
+ bool result; /* Bilan à retourner */
+ const bin_t *content; /* Contenu binaire à lire */
+ off_t length; /* Taille totale du contenu */
+
+ result = true;
+
+ content = G_BIN_FORMAT(format)->content;
+ length = G_BIN_FORMAT(format)->length;
+
+ result &= read_u32(&item->start_addr, content, pos, length, SRE_LITTLE);
+ result &= read_u16(&item->insn_count, content, pos, length, SRE_LITTLE);
+ result &= read_u16(&item->handler_off, content, pos, length, SRE_LITTLE);
+
+ return result;
+
+}
/******************************************************************************
@@ -554,6 +770,8 @@ bool read_dex_code_item(const GDexFormat *format, off_t *pos, code_item *item)
bool result; /* Bilan à retourner */
const bin_t *content; /* Contenu binaire à lire */
off_t length; /* Taille totale du contenu */
+ uint16_t padding; /* Eventuel alignement */
+ uint16_t i; /* Boucle de parcours */
result = true;
@@ -569,11 +787,59 @@ bool read_dex_code_item(const GDexFormat *format, off_t *pos, code_item *item)
item->insns = (uint16_t *)pos;
+ *pos += item->insns_size * sizeof(uint16_t);
+
+ /* Padding ? */
+ if (item->tries_size > 0 && item->insns_size % 2 == 1)
+ result &= read_u16(&padding, content, pos, length, SRE_LITTLE);
+
+ if (item->tries_size > 0 && result)
+ {
+ item->tries = (try_item *)calloc(item->tries_size, sizeof(try_item));
+
+ for (i = 0; i < item->tries_size && result; i++)
+ result &= read_dex_try_item(format, pos, &item->tries[i]);
+
+ if (result)
+ {
+ item->handlers = (encoded_catch_handler_list *)calloc(1, sizeof(encoded_catch_handler_list));
+ result &= read_dex_encoded_catch_handler_list(format, pos, item->handlers);
+ }
+
+ }
+
return result;
}
+/******************************************************************************
+* *
+* Paramètres : item = structure à nettoyer. *
+* *
+* Description : Supprime tous les éléments chargés en mémoire à la lecture. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+void reset_dex_code_item(code_item *item)
+{
+ if (item->tries != NULL)
+ free(item->tries);
+
+ if (item->handlers != NULL)
+ {
+ reset_dex_encoded_catch_handler_list(item->handlers);
+ free(item->handlers);
+ }
+
+}
+
+
+
diff --git a/src/format/dex/dex-int.h b/src/format/dex/dex-int.h
index 5feb427..6a153c1 100755
--- a/src/format/dex/dex-int.h
+++ b/src/format/dex/dex-int.h
@@ -61,6 +61,12 @@ struct _GDexFormatClass
/* Retrouve si possible la méthode associée à une adresse. */
GDexMethod *g_dex_format_find_method_by_address(const GDexFormat *, vmpa_t);
+/* Dénombre le nombre de classes trouvées. */
+size_t g_dex_format_count_classes(const GDexFormat *);
+
+/* Fournit une classe du format chargée en mémoire. */
+GDexClass *g_dex_format_get_class(const GDexFormat *, size_t);
+
/* ------------------------ ELEMENTS DE TABLE DES CONSTANTES ------------------------ */
@@ -112,9 +118,33 @@ void reset_dex_class_data_item(class_data_item *);
+/* --------------------------- PORTION DE CODE EXECUTABLE --------------------------- */
+
+
+/* Procède à la lecture d'une association exception <-> code. */
+bool read_dex_encoded_type_addr_pair(const GDexFormat *, off_t *, encoded_type_addr_pair *);
+
+/* Procède à la lecture d'une association exception <-> code. */
+bool read_dex_encoded_catch_handler(const GDexFormat *, off_t *, encoded_catch_handler *);
+
+/* Supprime tous les éléments chargés en mémoire à la lecture. */
+void reset_dex_encoded_catch_handler(encoded_catch_handler *);
+
+/* Procède à la lecture d'une association exception <-> code. */
+bool read_dex_encoded_catch_handler_list(const GDexFormat *, off_t *, encoded_catch_handler_list *);
+
+/* Supprime tous les éléments chargés en mémoire à la lecture. */
+void reset_dex_encoded_catch_handler_list(encoded_catch_handler_list *);
+
+/* Procède à la lecture d'une association exception <-> code. */
+bool read_dex_try_item(const GDexFormat *, off_t *, try_item *);
+
/* Procède à la lecture d'une portion de code DEX. */
bool read_dex_code_item(const GDexFormat *, off_t *, code_item *);
+/* Supprime tous les éléments chargés en mémoire à la lecture. */
+void reset_dex_code_item(code_item *);
+
diff --git a/src/format/dex/dex.c b/src/format/dex/dex.c
index f0fb421..841f72f 100755
--- a/src/format/dex/dex.c
+++ b/src/format/dex/dex.c
@@ -2,7 +2,7 @@
/* OpenIDA - Outil d'analyse de fichiers binaires
* dex.c - support du format DEX
*
- * Copyright (C) 2010-2011 Cyrille Bagard
+ * Copyright (C) 2010-2012 Cyrille Bagard
*
* This file is part of OpenIDA.
*
@@ -450,3 +450,42 @@ static bool g_dex_format_translate_offset_into_address(const GDexFormat *format,
return result;
}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = description de l'exécutable à consulter. *
+* *
+* Description : Dénombre le nombre de classes trouvées. *
+* *
+* Retour : Quantité de classes présentes. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+size_t g_dex_format_count_classes(const GDexFormat *format)
+{
+ return format->classes_count;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = description de l'exécutable à consulter. *
+* index = indice de la classe visée. *
+* *
+* Description : Fournit une classe du format chargée en mémoire. *
+* *
+* Retour : Instance représentant une classe chargée. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GDexClass *g_dex_format_get_class(const GDexFormat *format, size_t index)
+{
+ return format->classes[index];
+
+}
diff --git a/src/format/dex/dex.h b/src/format/dex/dex.h
index cfa72c1..9b769c2 100755
--- a/src/format/dex/dex.h
+++ b/src/format/dex/dex.h
@@ -2,7 +2,7 @@
/* OpenIDA - Outil d'analyse de fichiers binaires
* dex.h - prototypes pour le support du format DEX
*
- * Copyright (C) 2010 Cyrille Bagard
+ * Copyright (C) 2010-2012 Cyrille Bagard
*
* This file is part of OpenIDA.
*
diff --git a/src/format/dex/dex_def.h b/src/format/dex/dex_def.h
index ba88d69..d21ac15 100755
--- a/src/format/dex/dex_def.h
+++ b/src/format/dex/dex_def.h
@@ -179,6 +179,49 @@ typedef struct _class_data_item
/* --------------------------- PORTION DE CODE EXECUTABLE --------------------------- */
+/* Exception gérée */
+typedef struct _encoded_type_addr_pair
+{
+ uleb128_t type_idx; /* Type d'exception couverte */
+ uleb128_t addr; /* Adresse du début du code */
+
+} encoded_type_addr_pair;
+
+/* Ensemble d'exceptions prises en compte */
+typedef struct _encoded_catch_handler
+{
+ leb128_t size; /* Quantité d'exceptions */
+ encoded_type_addr_pair *handlers; /* Gestionnaires explicites */
+ uleb128_t catch_all_addr; /* Adresse par défaut */
+
+ /**
+ * Note : les spécifications indiquent que le champ handler_off de
+ * try_item renvoie vers le gestionnaire à partir de la base de la structure
+ * encoded_catch_handler_list. Comme la représentation interne de cette
+ * structure efface la représentation physique, on conserve en mémoire
+ * le décalage rencontré à la lecture dans un champ artificiel.
+ */
+ off_t offset; /* Position dans le binaire */
+
+} encoded_catch_handler;
+
+/* Liste des différents gestionnaires d'exceptions */
+typedef struct _encoded_catch_handler_list
+{
+ uleb128_t size; /* Taille de la liste */
+ encoded_catch_handler *list; /* Gestionnaires en place */
+
+} encoded_catch_handler_list;
+
+/* Zone couverte en cas de pépin */
+typedef struct _try_item
+{
+ uint32_t start_addr; /* Adresse du début couvert */
+ uint16_t insn_count; /* Nbre de doubles-octets gérés*/
+ uint16_t handler_off; /* Indice du gestionnaire */
+
+} try_item;
+
/* Description de la zone */
typedef struct _code_item
{
@@ -190,13 +233,13 @@ typedef struct _code_item
uint32_t insns_size; /* Nbre de blocs de 2 octets */
uint16_t *insns; /* Code exécutable */
-
+ try_item *tries; /* Zone d'exceptions */
+ encoded_catch_handler_list *handlers; /* Gestionnaires associés */
} code_item;
-
/* -------------------------- DESCRIPTION DU FORMAT DALVIK -------------------------- */
diff --git a/src/format/dex/method.c b/src/format/dex/method.c
index 25145f5..6ea9697 100644
--- a/src/format/dex/method.c
+++ b/src/format/dex/method.c
@@ -147,7 +147,9 @@ GDexMethod *g_dex_method_new(const GDexFormat *format, const encoded_method *see
result->info = *seed;
result->body = item;
- //printf(" ==== %s ====\n", g_binary_routine_get_name(routine));
+ //printf(" ==== (%p) %s ====\n", routine, g_binary_routine_to_string(routine));
+
+ //printf(" try ? %d\n", item.tries_size);
//printf(" method idx :: %d\n", seed->method_idx_diff);
//printf(" code size :: %d\n", item.insns_size);
@@ -180,6 +182,44 @@ GDexMethod *g_dex_method_new(const GDexFormat *format, const encoded_method *see
/******************************************************************************
* *
+* Paramètres : method = représentation interne de la méthode à consulter. *
+* *
+* Description : Fournit les indications Dex concernant la méthode. *
+* *
+* Retour : Données brutes du binaire. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+const encoded_method *g_dex_method_get_dex_info(const GDexMethod *method)
+{
+ return &method->info;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : method = représentation interne de la méthode à consulter. *
+* *
+* Description : Fournit les indications Dex relatives au corps de la méthode.*
+* *
+* Retour : Données brutes du binaire. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+const code_item *g_dex_method_get_dex_body(const GDexMethod *method)
+{
+ return &method->body;
+
+}
+
+
+/******************************************************************************
+* *
* Paramètres : method = représentation interne du format DEX à consulter. *
* *
* Description : Fournit la routine OpenIDA correspondant à la méthode. *
@@ -272,7 +312,7 @@ DexVariableIndex g_dex_method_get_variable(const GDexMethod *method, uint32_t in
pivot = body->registers_size - body->ins_size;
- if (!(method->info.access_flags & ACC_STATIC))
+ if (!(info->access_flags & ACC_STATIC))
pivot++;
if (index >= pivot)
@@ -280,7 +320,7 @@ DexVariableIndex g_dex_method_get_variable(const GDexMethod *method, uint32_t in
/* S'agit-il de "this" ? */
- if (!(method->info.access_flags & ACC_STATIC)
+ if (!(info->access_flags & ACC_STATIC)
&& index == (body->registers_size - body->ins_size))
return DVI_THIS;
diff --git a/src/format/dex/method.h b/src/format/dex/method.h
index c06df73..33f23b1 100644
--- a/src/format/dex/method.h
+++ b/src/format/dex/method.h
@@ -69,6 +69,12 @@ GType g_dex_method_get_type(void);
/* Crée une nouvelle représentation de methode issue de code. */
GDexMethod *g_dex_method_new(const GDexFormat *, const encoded_method *, uleb128_t *);
+/* Fournit les indications Dex concernant la méthode. */
+const encoded_method *g_dex_method_get_dex_info(const GDexMethod *);
+
+/* Fournit les indications Dex relatives au corps de la méthode. */
+const code_item *g_dex_method_get_dex_body(const GDexMethod *);
+
/* Fournit la routine OpenIDA correspondant à la méthode. */
GBinRoutine *g_dex_method_get_routine(const GDexMethod *);
diff --git a/src/gtkext/graph/dot.c b/src/gtkext/graph/dot.c
index 4c35089..0e7091e 100644
--- a/src/gtkext/graph/dot.c
+++ b/src/gtkext/graph/dot.c
@@ -25,6 +25,7 @@
#include <malloc.h>
+#include <string.h>
#include <graphviz/gvc.h>
#include <graphviz/types.h>
@@ -210,14 +211,19 @@ GtkLinkRenderer **create_links_from_graph_layout(const graph_layout *layout, siz
/* Détermination de la couleur */
+ color = LKC_DEFAULT;
+
attrib = agfindedgeattr(agraphof(agtail(eiter)), "color");
- if (eiter->attr[attrib->index][0] == 'g') /* "green" */
- color = LKC_GREEN;
- else if (eiter->attr[attrib->index][0] == 'r') /* "red" */
- color = LKC_RED;
- else
- color = LKC_DEFAULT;
+ if (attrib != NULL)
+ {
+ if (strcmp("green", eiter->attr[attrib->index]) == 0)
+ color = LKC_GREEN;
+ else if (strcmp("red", eiter->attr[attrib->index]) == 0)
+ color = LKC_RED;
+ else if (strcmp("gray", eiter->attr[attrib->index]) == 0)
+ color = LKC_DASHED_GRAY;
+ }
/* Raccordement au point de départ */
diff --git a/src/gtkext/graph/layout.c b/src/gtkext/graph/layout.c
index 64a8236..3a2f4e3 100644
--- a/src/gtkext/graph/layout.c
+++ b/src/gtkext/graph/layout.c
@@ -137,7 +137,6 @@ static char *complete_graph_links(const GtkGraphView *view, GtkViewPanel **views
size_t j; /* Boucle de parcours #2 */
size_t k; /* Boucle de parcours #3 */
char cmd[LINKS_DESC_LEN]; /* Tampon pour l'ajout de liens*/
- GArchInstruction *next; /* Instruction suivante */
if (count == 0)
return desc;
@@ -168,6 +167,7 @@ static char *complete_graph_links(const GtkGraphView *view, GtkViewPanel **views
if (k < count)
switch (types[j])
{
+ case ILT_EXEC_FLOW:
case ILT_JUMP:
snprintf(cmd, LINKS_DESC_LEN,
"_%p:s -> _%p:n [ltail=cluster_%p, lhead=cluster_%p];\n",
@@ -191,6 +191,14 @@ static char *complete_graph_links(const GtkGraphView *view, GtkViewPanel **views
desc = stradd(desc, cmd);
break;
+ case ILT_CATCH_EXCEPTION:
+ snprintf(cmd, LINKS_DESC_LEN,
+ "_%p:s -> _%p:n [ltail=cluster_%p, lhead=cluster_%p, " \
+ "color=gray];\n",
+ views[i], views[k], views[i], views[k]);
+ desc = stradd(desc, cmd);
+ break;
+
default:
break;
@@ -200,31 +208,6 @@ static char *complete_graph_links(const GtkGraphView *view, GtkViewPanel **views
}
- /* Sinon on suit le flux normal */
- else
- {
- if (g_arch_instruction_is_return(last))
- continue;
-
- next = g_arch_instruction_get_next_iter(instrs, last, VMPA_MAX);
- if (next == NULL) continue;
-
- g_arch_instruction_get_location(next, NULL, NULL, &addr);
-
- for (k = 0; k < count; k++)
- if (gtk_view_panel_contain_address(views[k], addr))
- break;
-
- if (k < count)
- {
- snprintf(cmd, LINKS_DESC_LEN,
- "_%p:s -> _%p:n [ltail=cluster_%p, lhead=cluster_%p];\n",
- views[i], views[k], views[i], views[k]);
- desc = stradd(desc, cmd);
- }
-
- }
-
}
return desc;
diff --git a/src/gtkext/gtkgraphview.c b/src/gtkext/gtkgraphview.c
index f205ee2..1a48680 100644
--- a/src/gtkext/gtkgraphview.c
+++ b/src/gtkext/gtkgraphview.c
@@ -650,7 +650,7 @@ static GtkViewPanel **gtk_graph_view_load_nodes(GtkGraphView *view, GLoadedBinar
g_arch_instruction_get_location(iter, NULL, NULL, &last);
if (first == VMPA_MAX) first = last;
- if (g_arch_instruction_has_destinations(iter))
+ if (g_arch_instruction_has_destinations(iter) || g_arch_instruction_is_return(iter))
{
result = (GtkViewPanel **)realloc(result, ++(*count) * sizeof(GtkViewPanel *));
diff --git a/src/gtkext/gtklinkrenderer.c b/src/gtkext/gtklinkrenderer.c
index 43eda38..8b43fa8 100644
--- a/src/gtkext/gtklinkrenderer.c
+++ b/src/gtkext/gtklinkrenderer.c
@@ -189,6 +189,22 @@ void _gtk_link_renderer_draw(const GtkLinkRenderer *renderer, cairo_t *cairo, bo
case LKC_RED:
cairo_set_source_rgb(cairo, 0.8, 0, 0);
break;
+ case LKC_DASHED_GRAY:
+ cairo_set_source_rgb(cairo, 0.4, 0.4, 0.4);
+ break;
+ }
+
+ switch (renderer->color)
+ {
+ default:
+ case LKC_DEFAULT:
+ case LKC_GREEN:
+ case LKC_RED:
+ cairo_set_dash(cairo, (double []) { 6.0 }, 0, 0.0);
+ break;
+ case LKC_DASHED_GRAY:
+ cairo_set_dash(cairo, (double []) { 6.0 }, 1, 0.0);
+ break;
}
/**
diff --git a/src/gtkext/gtklinkrenderer.h b/src/gtkext/gtklinkrenderer.h
index 574bd1d..3f6442c 100644
--- a/src/gtkext/gtklinkrenderer.h
+++ b/src/gtkext/gtklinkrenderer.h
@@ -52,6 +52,7 @@ typedef enum _LinkColor
LKC_DEFAULT, /* Noir, par défaut */
LKC_GREEN, /* Condition vérifiée */
LKC_RED, /* Condition non vérifiée */
+ LKC_DASHED_GRAY, /* Exception omniprésente */
LKC_COUNT
diff --git a/src/plugins/plugin.c b/src/plugins/plugin.c
index 89b46f0..416c647 100644
--- a/src/plugins/plugin.c
+++ b/src/plugins/plugin.c
@@ -125,10 +125,7 @@ GPluginModule *g_plugin_module_new(const gchar *filename, GObject *ref)
result->name = get_name();
if (!g_module_symbol(result->module, "init_plugin", (gpointer *)&result->init))
- {
- printf("Err plugin init sym\n");
- /* TODO */
- }
+ result->init = NULL;
/*
@@ -156,8 +153,7 @@ GPluginModule *g_plugin_module_new(const gchar *filename, GObject *ref)
result->get_action = get_action;
- /*
- if (result->action & (PGA_DISASSEMBLE | PGA_CODE_PROCESS))
+ if (g_plugin_module_get_action(result) & (PGA_DISASSEMBLE | PGA_DISASS_PROCESS | PGA_CODE_PROCESS))
{
if (!g_module_symbol(result->module, "execute_action_on_binary", (gpointer *)&result->exec_on_bin))
{
@@ -168,14 +164,13 @@ GPluginModule *g_plugin_module_new(const gchar *filename, GObject *ref)
}
- */
- if (!result->init(result, ref))
+ if (result->init != NULL && !result->init(result, ref))
{
log_variadic_message(LMT_ERROR, _("Initialization of plugin '%s' failed !"), filename);
goto bad_plugin;