summaryrefslogtreecommitdiff
path: root/src/format
diff options
context:
space:
mode:
Diffstat (limited to 'src/format')
-rw-r--r--src/format/Makefile.am4
-rwxr-xr-xsrc/format/dex/Makefile.am19
-rw-r--r--src/format/dex/class.c298
-rw-r--r--src/format/dex/class.h71
-rw-r--r--src/format/dex/dex-int.c518
-rwxr-xr-xsrc/format/dex/dex-int.h117
-rwxr-xr-xsrc/format/dex/dex.c307
-rwxr-xr-xsrc/format/dex/dex.h62
-rwxr-xr-xsrc/format/dex/dex_def.h189
-rw-r--r--src/format/dex/method.c193
-rw-r--r--src/format/dex/method.h68
-rw-r--r--src/format/dex/pool.c197
-rw-r--r--src/format/dex/pool.h48
-rw-r--r--src/format/executable.h1
-rw-r--r--src/format/format-int.h2
-rw-r--r--src/format/format.c6
-rw-r--r--src/format/format.h3
-rwxr-xr-xsrc/format/java/java-int.h2
-rw-r--r--src/format/mangling/Makefile.am26
-rw-r--r--src/format/mangling/context-int.h53
-rw-r--r--src/format/mangling/context.c95
-rw-r--r--src/format/mangling/context.h57
-rw-r--r--src/format/mangling/demangler.c99
-rw-r--r--src/format/mangling/demangler.h12
-rw-r--r--src/format/mangling/java.h59
-rw-r--r--src/format/mangling/java_gram.y271
-rw-r--r--src/format/mangling/java_tok.l33
27 files changed, 2759 insertions, 51 deletions
diff --git a/src/format/Makefile.am b/src/format/Makefile.am
index b080536..61fc0c6 100644
--- a/src/format/Makefile.am
+++ b/src/format/Makefile.am
@@ -21,6 +21,7 @@ libformat_la_SOURCES = \
# part.h part.c
libformat_la_LIBADD = \
+ dex/libformatdex.la \
dwarf/libformatdwarf.la \
elf/libformatelf.la \
java/libformatjava.la \
@@ -36,4 +37,5 @@ AM_CPPFLAGS =
AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
-SUBDIRS = dwarf elf java mangling pe
+SUBDIRS = dex elf java mangling pe
+#SUBDIRS = dex dwarf elf java mangling pe
diff --git a/src/format/dex/Makefile.am b/src/format/dex/Makefile.am
new file mode 100755
index 0000000..76cd63e
--- /dev/null
+++ b/src/format/dex/Makefile.am
@@ -0,0 +1,19 @@
+
+noinst_LTLIBRARIES = libformatdex.la
+
+libformatdex_la_SOURCES = \
+ class.h class.c \
+ dex-int.h dex-int.c \
+ dex.h dex.c \
+ dex_def.h \
+ method.h method.c \
+ pool.h pool.c
+
+libformatdex_la_LDFLAGS =
+
+
+INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
+
+AM_CPPFLAGS =
+
+AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
diff --git a/src/format/dex/class.c b/src/format/dex/class.c
new file mode 100644
index 0000000..03431f0
--- /dev/null
+++ b/src/format/dex/class.c
@@ -0,0 +1,298 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * class.c - manipulation des classes du format DEX
+ *
+ * Copyright (C) 2010 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/>.
+ */
+
+
+#include "class.h"
+
+
+#include <malloc.h>
+
+
+#include "dex-int.h"
+#include "method.h"
+
+
+
+
+
+
+
+
+/* Classe issue du code source (instance) */
+struct _GDexClass
+{
+ GObject parent; /* A laisser en premier */
+
+ GDexMethod **direct_methods; /* Méthodes propres */
+ size_t dmethods_count; /* Quantité de ces méthodes */
+ GDexMethod **virtual_methods; /* Méthodes virtuelles */
+ size_t vmethods_count; /* Quantité de ces méthodes */
+
+};
+
+/* Classe issue du code source (classe) */
+struct _GDexClassClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Procède à l'initialisation d'une classe issue du code source. */
+static void g_dex_class_class_init(GDexClassClass *);
+
+/* Procède à l'initialisation d'une classe issue du code source. */
+static void g_dex_class_init(GDexClass *);
+
+/* Crée une nouvelle représentation de classe issue de code. */
+static GDexClass *g_dex_class_new(const GDexFormat *, off_t);
+
+
+
+
+
+
+
+
+
+
+/* Détermine le type d'une classe issue du code source. */
+G_DEFINE_TYPE(GDexClass, g_dex_class, G_TYPE_OBJECT);
+
+
+
+/******************************************************************************
+* *
+* Paramètres : class = classe de composant GLib à initialiser. *
+* *
+* Description : Procède à l'initialisation d'une classe issue du code source.*
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_dex_class_class_init(GDexClassClass *class)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : class = composant GLib à initialiser. *
+* *
+* Description : Procède à l'initialisation d'une classe issue du code source.*
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_dex_class_init(GDexClass *class)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = représentation interne du format DEX à consulter. *
+* offset = tête de lecture des données initiale. *
+* *
+* Description : Crée une nouvelle représentation de classe issue de code. *
+* *
+* Retour : Composant GLib créé. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GDexClass *g_dex_class_new(const GDexFormat *format, off_t offset)
+{
+ GDexClass *result; /* Composant à retourner */
+ class_def_item def; /* Définition de la classe */
+ class_data_item data; /* Contenu de la classe */
+ uleb128_t i; /* Boucle de parcours */
+ GDexMethod *method; /* Méthode chargée */
+
+ if (!read_dex_class_def_item(format, &offset, &def))
+ return NULL;
+
+ offset = def.class_data_off;
+
+ if (!read_dex_class_data_item(format, &offset, &data))
+ return NULL;
+
+
+
+ printf(" Classe :: d meth count == 0x%lld\n", data.direct_methods_size);
+ printf(" Classe :: v meth count == 0x%lld\n", data.virtual_methods_size);
+
+
+
+ result = g_object_new(G_TYPE_DEX_CLASS, NULL);
+
+ for (i = 0; i < data.direct_methods_size; i++)
+ {
+ method = g_dex_method_new(format, &data.direct_methods[i]);
+
+ if (method != NULL)
+ {
+ result->dmethods_count++;
+ result->direct_methods = (GDexMethod **)realloc(result->direct_methods,
+ result->dmethods_count * sizeof(GDexMethod *));
+
+ result->direct_methods[result->dmethods_count - 1] = method;
+
+ }
+
+ }
+
+
+
+ for (i = 0; i < data.virtual_methods_size; i++)
+ {
+ method = g_dex_method_new(format, &data.virtual_methods[i]);
+
+ if (method != NULL)
+ {
+ result->vmethods_count++;
+ result->virtual_methods = (GDexMethod **)realloc(result->virtual_methods,
+ result->vmethods_count * sizeof(GDexMethod *));
+
+ result->virtual_methods[result->vmethods_count - 1] = method;
+
+ }
+
+ }
+
+
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : class = informations chargées à consulter. *
+* parts = liste à venir compléter. *
+* count = quantité de zones listées. [OUT] *
+* *
+* Description : Fournit les références aux zones binaires à analyser. *
+* *
+* Retour : Zones binaires à analyser. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBinPart **g_dex_class_get_parts(const GDexClass *class, GBinPart **parts, size_t *count)
+{
+ size_t i; /* Boucle de parcours */
+ GBinPart *part; /* Partie à intégrer à la liste*/
+
+ for (i = 0; i < class->dmethods_count; i++)
+ {
+ part = g_dex_method_as_part(class->direct_methods[i]);
+
+ parts = (GBinPart **)realloc(parts, ++(*count) * sizeof(GBinPart *));
+ parts[*count - 1] = part;
+
+ }
+
+ for (i = 0; i < class->vmethods_count; i++)
+ {
+ part = g_dex_method_as_part(class->virtual_methods[i]);
+
+ parts = (GBinPart **)realloc(parts, ++(*count) * sizeof(GBinPart *));
+ parts[*count - 1] = part;
+
+ }
+
+ return parts;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+* *
+* 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)
+{
+ const dex_header *header; /* Raccourci d'usage */
+ uint32_t i; /* Boucle de parcours */
+ GDexClass *class; /* Représentation chargée */
+
+ header = &format->header;
+
+ for (i = 0; i < header->class_defs_size; i++)
+ {
+ class = g_dex_class_new(format, header->class_defs_off + i * sizeof(class_def_item));
+
+ if (class != NULL)
+ {
+ format->classes_count++;
+ format->classes = (GDexClass **)realloc(format->classes,
+ format->classes_count * sizeof(GDexClass *));
+
+ format->classes[format->classes_count - 1] = class;
+
+ }
+
+ }
+
+ return true;
+
+}
diff --git a/src/format/dex/class.h b/src/format/dex/class.h
new file mode 100644
index 0000000..d78e6e9
--- /dev/null
+++ b/src/format/dex/class.h
@@ -0,0 +1,71 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * class.h - prototypes pour la manipulation des classes du format DEX
+ *
+ * Copyright (C) 2010 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 _FORMAT_DEX_CLASS_H
+#define _FORMAT_DEX_CLASS_H
+
+
+#include <glib-object.h>
+
+
+#include "dex.h"
+
+
+
+#define G_TYPE_DEX_CLASS (g_dex_class_get_type())
+#define G_DEX_CLASS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_DEX_CLASS, GDexClass))
+#define G_DEX_CLASS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DEX_CLASS, GDexClassClass))
+#define G_IS_DEX_CLASS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_DEX_CLASS))
+#define G_IS_DEX_CLASS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DEX_CLASS))
+#define G_DEX_CLASS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DEX_CLASS, GDexClassClass))
+
+
+
+/* Classe issue du code source (instance) */
+typedef struct _GDexClass GDexClass;
+
+/* Classe issue du code source (classe) */
+typedef struct _GDexClassClass GDexClassClass;
+
+
+
+/* Détermine le type d'une classe issue du code source. */
+GType g_dex_class_get_type(void);
+
+/* Fournit les références aux zones binaires à analyser. */
+GBinPart **g_dex_class_get_parts(const GDexClass *, GBinPart **, size_t *);
+
+
+
+
+
+
+
+/* Charge toutes les classes listées dans le contenu binaire. */
+bool load_all_dex_classes(GDexFormat *);
+
+
+
+
+
+#endif /* _FORMAT_DEX_CLASS_H */
diff --git a/src/format/dex/dex-int.c b/src/format/dex/dex-int.c
new file mode 100644
index 0000000..be1c211
--- /dev/null
+++ b/src/format/dex/dex-int.c
@@ -0,0 +1,518 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * dex-int.c - structures internes du format DEX
+ *
+ * Copyright (C) 2010 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/>.
+ */
+
+
+#include "dex-int.h"
+
+
+#include <malloc.h>
+
+
+#include "../../common/endianness.h"
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* ELEMENTS DE TABLE DES CONSTANTES */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* pos = position de début de lecture. [OUT] *
+* str_id = structure lue à retourner. [OUT] *
+* *
+* Description : Procède à la lecture d'un identifiant de chaîne DEX. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_string_id_item(const GDexFormat *format, off_t *pos, string_id_item *str_id)
+{
+ 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(&str_id->string_data_off, content, pos, length, SRE_LITTLE);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* pos = position de début de lecture. [OUT] *
+* str_data = structure lue à retourner. [OUT] *
+* *
+* Description : Procède à la lecture de proriétés de chaîne DEX. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_string_data_item(const GDexFormat *format, off_t *pos, string_data_item *str_data)
+{
+ 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(&str_data->utf16_size, content, pos, length);
+
+ str_data->data = &content[*pos];
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* 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'un identifiant de type DEX. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_type_id_item(const GDexFormat *format, off_t *pos, type_id_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->descriptor_idx, content, pos, length, SRE_LITTLE);
+
+ return result;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* pos = position de début de lecture. [OUT] *
+* meth_id = structure lue à retourner. [OUT] *
+* *
+* Description : Procède à la lecture d'une description de méthode. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_method_id_item(const GDexFormat *format, off_t *pos, method_id_item *meth_id)
+{
+ 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_u16(&meth_id->class_idx, content, pos, length, SRE_LITTLE);
+ result &= read_u16(&meth_id->proto_idx, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&meth_id->name_idx, content, pos, length, SRE_LITTLE);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* pos = position de début de lecture. [OUT] *
+* class_def = structure lue à retourner. [OUT] *
+* *
+* Description : Procède à la lecture des propriétés d'une classe DEX. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_class_def_item(const GDexFormat *format, off_t *pos, class_def_item *class_def)
+{
+ 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(&class_def->class_idx, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&class_def->access_flags, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&class_def->superclass_idx, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&class_def->interfaces_off, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&class_def->source_file_idx, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&class_def->annotations_off, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&class_def->class_data_off, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&class_def->static_values_off, content, pos, length, SRE_LITTLE);
+
+ return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* DESCRIPTION DE CLASSES DEX */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* pos = position de début de lecture. [OUT] *
+* field = structure lue à retourner. [OUT] *
+* *
+* Description : Procède à la lecture d'un champ quelconque DEX. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_encoded_field(const GDexFormat *format, off_t *pos, encoded_field *field)
+{
+ 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(&field->field_idx_diff, content, pos, length);
+ result &= read_uleb128(&field->access_flags, content, pos, length);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* pos = position de début de lecture. [OUT] *
+* method = structure lue à retourner. [OUT] *
+* *
+* Description : Procède à la lecture d'une méthode quelconque DEX. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_encoded_method(const GDexFormat *format, off_t *pos, encoded_method *method)
+{
+ 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(&method->method_idx_diff, content, pos, length);
+ result &= read_uleb128(&method->access_flags, content, pos, length);
+ result &= read_uleb128(&method->code_off, content, pos, length);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* 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'un contenu de classe DEX. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_class_data_item(const GDexFormat *format, off_t *pos, class_data_item *item)
+{
+ bool result; /* Bilan à retourner */
+ const bin_t *content; /* Contenu binaire à lire */
+ off_t length; /* Taille totale du contenu */
+ uleb128_t i; /* Boucle de parcours */
+
+ result = true;
+
+ content = G_BIN_FORMAT(format)->content;
+ length = G_BIN_FORMAT(format)->length;
+
+ item->static_fields = NULL;
+ item->instance_fields = NULL;
+ item->direct_methods = NULL;
+ item->virtual_methods = NULL;
+
+ result &= read_uleb128(&item->static_fields_size, content, pos, length);
+ result &= read_uleb128(&item->instance_fields_size, content, pos, length);
+ result &= read_uleb128(&item->direct_methods_size, content, pos, length);
+ result &= read_uleb128(&item->virtual_methods_size, content, pos, length);
+
+ if (result && item->static_fields_size > 0)
+ {
+ item->static_fields = (encoded_field *)calloc(item->static_fields_size, sizeof(encoded_field));
+
+ for (i = 0; i < item->static_fields_size && result; i++)
+ result = read_dex_encoded_field(format, pos, &item->static_fields[i]);
+
+ }
+
+ if (result && item->instance_fields_size > 0)
+ {
+ item->instance_fields = (encoded_field *)calloc(item->instance_fields_size, sizeof(encoded_field));
+
+ for (i = 0; i < item->instance_fields_size && result; i++)
+ result = read_dex_encoded_field(format, pos, &item->instance_fields[i]);
+
+ }
+
+ if (result && item->direct_methods_size > 0)
+ {
+ item->direct_methods = (encoded_method *)calloc(item->direct_methods_size, sizeof(encoded_method));
+
+ for (i = 0; i < item->direct_methods_size && result; i++)
+ result = read_dex_encoded_method(format, pos, &item->direct_methods[i]);
+
+ }
+
+ if (result && item->virtual_methods_size > 0)
+ {
+ item->virtual_methods = (encoded_method *)calloc(item->virtual_methods_size, sizeof(encoded_method));
+
+ for (i = 0; i < item->virtual_methods_size && result; i++)
+ result = read_dex_encoded_method(format, pos, &item->virtual_methods[i]);
+
+ }
+
+ if (!result)
+ reset_dex_class_data_item(item);
+
+ 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_class_data_item(class_data_item *item)
+{
+ if (item->static_fields != NULL)
+ free(item->static_fields);
+
+ if (item->instance_fields != NULL)
+ free(item->instance_fields);
+
+ if (item->direct_methods != NULL)
+ free(item->direct_methods);
+
+ if (item->virtual_methods != NULL)
+ free(item->virtual_methods);
+
+}
+
+
+
+
+
+
+
+
+
+/******************************************************************************
+* *
+* 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 portion de code DEX. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+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 */
+
+ result = true;
+
+ content = G_BIN_FORMAT(format)->content;
+ length = G_BIN_FORMAT(format)->length;
+
+ result &= read_u16(&item->registers_size, content, pos, length, SRE_LITTLE);
+ result &= read_u16(&item->ins_size, content, pos, length, SRE_LITTLE);
+ result &= read_u16(&item->outs_size, content, pos, length, SRE_LITTLE);
+ result &= read_u16(&item->tries_size, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&item->debug_info_off, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&item->insns_size, content, pos, length, SRE_LITTLE);
+
+ item->insns = (uint16_t *)pos;
+
+ return result;
+
+}
+
+
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* pos = position de début de lecture. [OUT] *
+* header = structure lue à retourner. [OUT] *
+* *
+* Description : Procède à la lecture d'une en-tête de programme DEX. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool read_dex_header(const GDexFormat *format, off_t *pos, dex_header *header)
+{
+ bool result; /* Bilan à retourner */
+ const bin_t *content; /* Contenu binaire à lire */
+ off_t length; /* Taille totale du contenu */
+ size_t i; /* Boucle de parcours */
+
+ result = true;
+
+ content = G_BIN_FORMAT(format)->content;
+ length = G_BIN_FORMAT(format)->length;
+
+ for (i = 0; i < DEX_FILE_MAGIC_LEN && result; i++)
+ result = read_u8(&header->magic[i], content, pos, length, SRE_LITTLE);
+
+ result &= read_u32(&header->checksum, content, pos, length, SRE_LITTLE);
+
+ for (i = 0; i < 20 && result; i++)
+ result = read_u8(&header->signature[i], content, pos, length, SRE_LITTLE);
+
+ result &= read_u32(&header->file_size, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->header_size, content, pos, length, SRE_LITTLE);
+
+ result &= read_u32(&header->endian_tag, content, pos, length, SRE_LITTLE);
+
+ result &= read_u32(&header->link_size, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->link_off, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->map_off, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->string_ids_size, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->string_ids_off, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->type_ids_size, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->type_ids_off, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->proto_ids_size, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->proto_ids_off, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->field_ids_size, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->field_ids_off, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->method_ids_size, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->method_ids_off, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->class_defs_size, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->class_defs_off, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->data_size, content, pos, length, SRE_LITTLE);
+ result &= read_u32(&header->data_off, content, pos, length, SRE_LITTLE);
+
+ return result;
+
+}
+
+
+
+
+
diff --git a/src/format/dex/dex-int.h b/src/format/dex/dex-int.h
new file mode 100755
index 0000000..e34dbd3
--- /dev/null
+++ b/src/format/dex/dex-int.h
@@ -0,0 +1,117 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * dex-int.h - prototypes pour les structures internes du format DEX
+ *
+ * Copyright (C) 2008 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 _FORMAT_DEX_DEX_INT_H
+#define _FORMAT_DEX_DEX_INT_H
+
+
+#include "class.h"
+#include "dex.h"
+#include "dex_def.h"
+#include "../executable-int.h"
+
+
+
+
+
+/* Format d'exécutable DEX (instance) */
+struct _GDexFormat
+{
+ GExeFormat parent; /* A laisser en premier */
+
+ dex_header header; /* En-tête du programme */
+
+
+
+ GDexClass **classes; /* Classes retrouvées */
+ size_t classes_count; /* Nombre de ces classes */
+
+
+
+};
+
+/* Format d'exécutable DEX (classe) */
+struct _GDexFormatClass
+{
+ GExeFormatClass parent; /* A laisser en premier */
+
+};
+
+
+
+/* ------------------------ ELEMENTS DE TABLE DES CONSTANTES ------------------------ */
+
+
+/* Procède à la lecture d'un identifiant de chaîne DEX. */
+bool read_dex_string_id_item(const GDexFormat *, off_t *, string_id_item *);
+
+/* Procède à la lecture de proriétés de chaîne DEX. */
+bool read_dex_string_data_item(const GDexFormat *, off_t *, string_data_item *);
+
+/* Procède à la lecture d'un identifiant de type DEX. */
+bool read_dex_type_id_item(const GDexFormat *, off_t *, type_id_item *);
+
+
+
+/* Procède à la lecture d'une description de méthode. */
+bool read_dex_method_id_item(const GDexFormat *, off_t *, method_id_item *);
+
+/* Procède à la lecture des propriétés d'une classe DEX. */
+bool read_dex_class_def_item(const GDexFormat *, off_t *, class_def_item *);
+
+
+
+/* --------------------------- DESCRIPTION DE CLASSES DEX --------------------------- */
+
+
+/* Procède à la lecture d'un champ quelconque DEX. */
+bool read_dex_encoded_field(const GDexFormat *, off_t *, encoded_field *);
+
+/* Procède à la lecture d'une méthode quelconque DEX. */
+bool read_dex_encoded_method(const GDexFormat *, off_t *, encoded_method *);
+
+/* Procède à la lecture d'un contenu de classe DEX. */
+bool read_dex_class_data_item(const GDexFormat *, off_t *, class_data_item *);
+
+/* Supprime tous les éléments chargés en mémoire à la lecture. */
+void reset_dex_class_data_item(class_data_item *);
+
+
+
+/* Procède à la lecture d'une portion de code DEX. */
+bool read_dex_code_item(const GDexFormat *, off_t *, code_item *);
+
+
+
+
+/* Procède à la lecture d'une en-tête de programme DEX. */
+bool read_dex_header(const GDexFormat *, off_t *, dex_header *);
+
+
+
+
+
+
+
+
+#endif /* _FORMAT_DEX_DEX_INT_H */
diff --git a/src/format/dex/dex.c b/src/format/dex/dex.c
new file mode 100755
index 0000000..5b68d5f
--- /dev/null
+++ b/src/format/dex/dex.c
@@ -0,0 +1,307 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * dex.c - support du format DEX
+ *
+ * Copyright (C) 2010 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/>.
+ */
+
+
+#include "dex.h"
+
+
+#include <string.h>
+
+
+#include "dex-int.h"
+
+
+
+
+
+
+
+
+
+
+
+/* Initialise la classe des formats d'exécutables DEX. */
+static void g_dex_format_class_init(GDexFormatClass *);
+
+/* Initialise une instance de format d'exécutable DEX. */
+static void g_dex_format_init(GDexFormat *);
+
+/* Indique le type d'architecture visée par le format. */
+static FormatTargetMachine g_dex_format_get_target_machine(const GDexFormat *);
+
+/* Fournit l'adresse mémoire du point d'entrée du programme. */
+static vmpa_t g_dex_format_get_entry_point(const GDexFormat *);
+
+/* Fournit les références aux zones binaires à analyser. */
+static GBinPart **g_dex_format_get_parts(const GDexFormat *, size_t *);
+
+/* Fournit la position correspondant à une adresse virtuelle. */
+static bool g_dex_format_translate_address_into_offset(const GDexFormat *, vmpa_t, off_t *);
+
+/* Fournit l'adresse virtuelle correspondant à une position. */
+static bool g_dex_format_translate_offset_into_address(const GDexFormat *, off_t, vmpa_t *);
+
+
+
+/******************************************************************************
+* *
+* Paramètres : type = type de format recherché. *
+* content = contenu binaire à parcourir. *
+* length = taille du contenu en question. *
+* *
+* Description : Indique si le format peut être pris en charge ici. *
+* *
+* Retour : true si la réponse est positive, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool dex_is_matching(FormatType type, const uint8_t *content, off_t length)
+{
+ bool result; /* Bilan à faire connaître */
+
+ result = false;
+
+ if (length >= DEX_FILE_MAGIC_LEN)
+ result = (memcmp(content, DEX_FILE_MAGIC, DEX_FILE_MAGIC_LEN) == 0);
+
+ return result;
+
+}
+
+
+/* Indique le type défini pour un format d'exécutable DEX. */
+G_DEFINE_TYPE(GDexFormat, g_dex_format, G_TYPE_EXE_FORMAT);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des formats d'exécutables DEX. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_dex_format_class_init(GDexFormatClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = instance à initialiser. *
+* *
+* Description : Initialise une instance de format d'exécutable DEX. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_dex_format_init(GDexFormat *format)
+{
+ GExeFormat *exe_format; /* Format parent à constituer */
+
+ exe_format = G_EXE_FORMAT(format);
+
+ exe_format->get_machine = (get_target_machine_fc)g_dex_format_get_target_machine;
+ exe_format->get_entry_point = (get_entry_point_fc)g_dex_format_get_entry_point;
+ exe_format->get_parts = (get_parts_fc)g_dex_format_get_parts;
+
+ exe_format->translate_addr = (translate_addr_fc)g_dex_format_translate_address_into_offset;
+ exe_format->translate_off = (translate_off_fc)g_dex_format_translate_offset_into_address;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à parcourir. *
+* length = taille du contenu en question. *
+* *
+* Description : Prend en charge un nouveau format DEX. *
+* *
+* Retour : Adresse de la structure mise en place ou NULL en cas d'échec.*
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBinFormat *g_dex_format_new(const bin_t *content, off_t length)
+{
+ GDexFormat *result; /* Structure à retourner */
+ off_t offset; /* Tête de lecture */
+
+ result = g_object_new(G_TYPE_DEX_FORMAT, NULL);
+
+ g_binary_format_set_content(G_BIN_FORMAT(result), content, length);
+
+
+ offset = 0;
+
+ if (!read_dex_header(result, &offset, &result->header))
+ {
+ /* TODO */
+ return NULL;
+ }
+
+ /* TODO : vérifier l'en-tête ! */
+
+
+
+ if (!load_all_dex_classes(result))
+ {
+ g_object_unref(G_OBJECT(result));
+ return NULL;
+ }
+
+
+
+
+
+ return G_BIN_FORMAT(result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* *
+* Description : Indique le type d'architecture visée par le format. *
+* *
+* Retour : Identifiant de l'architecture ciblée par le format. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static FormatTargetMachine g_dex_format_get_target_machine(const GDexFormat *format)
+{
+ return FTM_DALVIK;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* *
+* Description : Fournit l'adresse mémoire du point d'entrée du programme. *
+* *
+* Retour : Adresse de mémoire. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static vmpa_t g_dex_format_get_entry_point(const GDexFormat *format)
+{
+ return 0;//(format->is_32b ? format->header.e_entry.addr32 : format->header.e_entry.addr64);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = informations chargées à consulter. *
+* count = quantité de zones listées. [OUT] *
+* *
+* Description : Fournit les références aux zones binaires à analyser. *
+* *
+* Retour : Zones binaires à analyser. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static GBinPart **g_dex_format_get_parts(const GDexFormat *format, size_t *count)
+{
+ GBinPart **result; /* Tableau à retourner */
+ size_t i; /* Boucle de parcours */
+
+ result = NULL;
+ *count = 0;
+
+ for (i = 0; i < format->classes_count; i++)
+ result = g_dex_class_get_parts(format->classes[i], result, count);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = description de l'exécutable à consulter. *
+* addr = adresse virtuelle à retrouver. *
+* pos = position correspondante. [OUT] *
+* *
+* Description : Fournit la position correspondant à une adresse virtuelle. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_dex_format_translate_address_into_offset(const GDexFormat *format, vmpa_t addr, off_t *pos)
+{
+ bool result; /* Bilan à retourner */
+
+ result = false;
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = description de l'exécutable à consulter. *
+* pos = position dans le flux binaire à retrouver. *
+* addr = adresse virtuelle correspondante. [OUT] *
+* *
+* Description : Fournit l'adresse virtuelle correspondant à une position. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_dex_format_translate_offset_into_address(const GDexFormat *format, off_t pos, vmpa_t *addr)
+{
+ bool result; /* Bilan à retourner */
+
+ result = false;
+
+ return result;
+
+}
diff --git a/src/format/dex/dex.h b/src/format/dex/dex.h
new file mode 100755
index 0000000..cfa72c1
--- /dev/null
+++ b/src/format/dex/dex.h
@@ -0,0 +1,62 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * dex.h - prototypes pour le support du format DEX
+ *
+ * Copyright (C) 2010 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 _FORMAT_DEX_DEX_H
+#define _FORMAT_DEX_DEX_H
+
+
+#include <glib-object.h>
+#include <stdbool.h>
+#include <sys/types.h>
+
+
+#include "../format.h"
+
+
+
+#define G_TYPE_DEX_FORMAT g_dex_format_get_type()
+#define G_DEX_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_dex_format_get_type(), GDexFormat))
+#define G_IS_DEX_FORMAT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_dex_format_get_type()))
+#define G_DEX_FORMAT_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_dex_format_get_type(), GDexFormatIface))
+#define G_DEX_FORMAT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DEX_FORMAT, GDexFormatClass))
+
+
+/* Format d'exécutable DEX (instance) */
+typedef struct _GDexFormat GDexFormat;
+
+/* Format d'exécutable DEX (classe) */
+typedef struct _GDexFormatClass GDexFormatClass;
+
+
+/* Indique si le format peut être pris en charge ici. */
+bool dex_is_matching(FormatType, const bin_t *, off_t);
+
+/* Indique le type défini pour un format d'exécutable DEX. */
+GType g_dex_format_get_type(void);
+
+/* Prend en charge un nouveau format DEX. */
+GBinFormat *g_dex_format_new(const bin_t *, off_t);
+
+
+
+#endif /* _FORMAT_DEX_DEX_H */
diff --git a/src/format/dex/dex_def.h b/src/format/dex/dex_def.h
new file mode 100755
index 0000000..9387a90
--- /dev/null
+++ b/src/format/dex/dex_def.h
@@ -0,0 +1,189 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * dex_def.h - liste des structures et constantes utilisées par le format DEX
+ *
+ * Copyright (C) 2010 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 _FORMAT_DEX_DEX_DEF_H
+#define _FORMAT_DEX_DEX_DEF_H
+
+
+#include "../../common/leb128.h"
+
+
+
+/* ------------------------ ELEMENTS DE TABLE DES CONSTANTES ------------------------ */
+
+
+/* Chaîne de caractères */
+
+typedef struct _string_id_item
+{
+ uint32_t string_data_off; /* Propriétés de la chaîne */
+
+} string_id_item;
+
+typedef struct _string_data_item
+{
+ uleb128_t utf16_size; /* Taille du décodage */
+ const uint8_t *data; /* Caractères terminés par '\0'*/
+
+} string_data_item;
+
+/* Description d'un type */
+typedef struct _type_id_item
+{
+ uint32_t descriptor_idx; /* Description du type */
+
+} type_id_item;
+
+
+
+
+/* Description d'une méthode */
+typedef struct _method_id_item
+{
+ uint16_t class_idx; /* Classe d'appartenance */
+ uint16_t proto_idx; /* Prototype de la méthode */
+ uint32_t name_idx; /* Nom de la méthode */
+
+} method_id_item;
+
+/* Description d'une classe */
+typedef struct _class_def_item
+{
+ uint32_t class_idx; /* Type de la classe */
+ uint32_t access_flags; /* Drapeaux d'accès déclarés */
+ uint32_t superclass_idx; /* Type de la classe parente */
+ uint32_t interfaces_off; /* Liste des interfaces */
+ uint32_t source_file_idx; /* Fichier source d'origine */
+ uint32_t annotations_off; /* Eventuelles annotations */
+ uint32_t class_data_off; /* Données de la classe */
+ uint32_t static_values_off; /* Initialisations statiques */
+
+} class_def_item;
+
+
+
+/* --------------------------- DESCRIPTION DE CLASSES DEX --------------------------- */
+
+
+/* Propriétés d'une champ */
+typedef struct _encoded_field
+{
+ uleb128_t field_idx_diff; /* Description du champ */
+ uleb128_t access_flags; /* Conditions d'accès */
+
+} encoded_field;
+
+/* Propriétés d'une méthode */
+typedef struct _encoded_method
+{
+ uleb128_t method_idx_diff; /* Description de la méthode */
+ uleb128_t access_flags; /* Conditions d'accès */
+ uleb128_t code_off; /* Position du code associé */
+
+} encoded_method;
+
+/* Données de fonctionnement pour classe */
+typedef struct _class_data_item
+{
+ uleb128_t static_fields_size; /* Quantité de champs statiques*/
+ uleb128_t instance_fields_size; /* Qté de champs instanciables */
+ uleb128_t direct_methods_size; /* Qté de méthodes propres */
+ uleb128_t virtual_methods_size; /* Qté de méthodes virtuelles */
+
+ encoded_field *static_fields; /* Champs statiques */
+ encoded_field *instance_fields; /* Champs instanciables */
+ encoded_method *direct_methods; /* Méthodes propres */
+ encoded_method *virtual_methods; /* Méthodes virtuelles */
+
+} class_data_item;
+
+
+
+/* --------------------------- PORTION DE CODE EXECUTABLE --------------------------- */
+
+
+/* Description de la zone */
+typedef struct _code_item
+{
+ uint16_t registers_size; /* Qté de registres utilisés */
+ uint16_t ins_size; /* Nbre d'arguments en entrée */
+ uint16_t outs_size; /* Nbre d'arguments en sortie */
+ uint16_t tries_size; /* Qté de try/catch */
+ uint32_t debug_info_off; /* Information de débogage */
+ uint32_t insns_size; /* Nbre de blocs de 2 octets */
+
+ uint16_t *insns; /* Code exécutable */
+
+
+} code_item;
+
+
+
+
+/* -------------------------- DESCRIPTION DU FORMAT DALVIK -------------------------- */
+
+
+/* Identifiant magique "dex\n035\0" */
+#define DEX_FILE_MAGIC "\x64\x65\x78\x0a\x30\x33\x35\x00"
+#define DEX_FILE_MAGIC_LEN 8
+
+/* Types de boutisme */
+#define ENDIAN_CONSTANT 0x12345678
+#define REVERSE_ENDIAN_CONSTANT 0x78563412
+
+
+/* En-tête de tout programe Dex */
+typedef struct _dex_header
+{
+ uint8_t magic[DEX_FILE_MAGIC_LEN]; /* Valeur magique du format */
+
+ uint32_t checksum; /* Somme de contrôle adler32 */
+ uint8_t signature[20]; /* Emprunte SHA-1 du reste */
+ uint32_t file_size; /* Taille du fichier */
+ uint32_t header_size; /* Taille de cette en-tête */
+
+ uint32_t endian_tag; /* Boutisme du fichier */
+
+ uint32_t link_size; /* Taille de section 'liaisons'*/
+ uint32_t link_off; /* Position de ladite section */
+ uint32_t map_off; /* Position de la cartographie */
+ uint32_t string_ids_size; /* Nombre de chaînes de carac. */
+ uint32_t string_ids_off; /* Position de cette liste */
+ uint32_t type_ids_size; /* Nom d'identifiant de type */
+ uint32_t type_ids_off; /* Position de la liste */
+ uint32_t proto_ids_size; /* Nombre de prototypes */
+ uint32_t proto_ids_off; /* Position de la liste */
+ uint32_t field_ids_size; /* Nombre de champs */
+ uint32_t field_ids_off; /* Position de la liste */
+ uint32_t method_ids_size; /* Nombre de méthodes */
+ uint32_t method_ids_off; /* Position de la liste */
+ uint32_t class_defs_size; /* Nombre de classes déclarées */
+ uint32_t class_defs_off; /* Position de la liste */
+ uint32_t data_size; /* Taille des données */
+ uint32_t data_off; /* Début des données */
+
+} dex_header;
+
+
+
+#endif /* _FORMAT_DEX_DEX_DEF_H */
diff --git a/src/format/dex/method.c b/src/format/dex/method.c
new file mode 100644
index 0000000..3a604d0
--- /dev/null
+++ b/src/format/dex/method.c
@@ -0,0 +1,193 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * method.c - manipulation des methodes du format DEX
+ *
+ * Copyright (C) 2010 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/>.
+ */
+
+
+#include "method.h"
+
+
+#include "dex-int.h"
+#include "pool.h"
+
+
+
+
+
+/* Methode issue du code source (instance) */
+struct _GDexMethod
+{
+ GObject parent; /* A laisser en premier */
+
+ GBinRoutine *routine; /* Représentation interne */
+
+ code_item body; /* Corps de la méthode */
+ off_t offset; /* Position du code */
+
+};
+
+/* Methode issue du code source (classe) */
+struct _GDexMethodClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Procède à l'initialisation d'une methode issue du code. */
+static void g_dex_method_class_init(GDexMethodClass *);
+
+/* Procède à l'initialisation d'une methode issue du code. */
+static void g_dex_method_init(GDexMethod *);
+
+
+
+
+
+
+
+
+
+
+/* Détermine le type d'une methode issue du code source. */
+G_DEFINE_TYPE(GDexMethod, g_dex_method, G_TYPE_OBJECT);
+
+
+
+/******************************************************************************
+* *
+* Paramètres : class = classe de composant GLib à initialiser. *
+* *
+* Description : Procède à l'initialisation d'une methode issue du code. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_dex_method_class_init(GDexMethodClass *class)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : method = composant GLib à initialiser. *
+* *
+* Description : Procède à l'initialisation d'une methode issue du code. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_dex_method_init(GDexMethod *method)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : format = représentation interne du format DEX à consulter. *
+* seed = graine des informations à extraire. *
+* *
+* Description : Crée une nouvelle représentation de methode issue de code. *
+* *
+* Retour : Composant GLib créé. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GDexMethod *g_dex_method_new(const GDexFormat *format, const encoded_method *seed)
+{
+ GDexMethod *result; /* Composant à retourner */
+ off_t offset; /* Tête de lecture */
+ code_item item; /* Corps de la méthode */
+
+
+ GBinRoutine *routine;
+
+ offset = seed->code_off;
+
+ if (!read_dex_code_item(format, &offset, &item))
+ return NULL;
+
+ result = g_object_new(G_TYPE_DEX_METHOD, NULL);
+
+ result->body = item;
+
+ //printf(" method idx :: %d\n", seed->method_idx_diff);
+ //printf(" code size :: %d\n", item.insns_size);
+
+
+ routine = get_routine_from_dex_pool(format, seed->method_idx_diff);
+
+
+
+ result->offset = seed->code_off + 4 * sizeof(uint16_t) + 2 *sizeof(uint32_t);/* TODO : faire plus propre ! */
+
+
+
+ g_binary_routine_set_address(routine, result->offset);
+
+
+ g_binary_format_add_routine(G_BIN_FORMAT(format), routine);
+
+
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : method = représentation interne du format DEX à consulter. *
+* *
+* Description : Fournit la zone binaire correspondant à la méthode. *
+* *
+* Retour : Zone binaire à analyser. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBinPart *g_dex_method_as_part(const GDexMethod *method)
+{
+ GBinPart *result; /* Instance à retourner */
+
+ result = g_binary_part_new();
+
+ g_binary_part_set_name(result, "name");
+
+ g_binary_part_set_values(result,
+ method->offset, method->body.insns_size * sizeof(uint16_t), method->offset);
+
+ return result;
+
+}
+
+
+
diff --git a/src/format/dex/method.h b/src/format/dex/method.h
new file mode 100644
index 0000000..dd6f4b1
--- /dev/null
+++ b/src/format/dex/method.h
@@ -0,0 +1,68 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * method.h - prototypes pour la manipulation des methodes du format DEX
+ *
+ * Copyright (C) 2010 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 _FORMAT_DEX_METHOD_H
+#define _FORMAT_DEX_METHOD_H
+
+
+#include <glib-object.h>
+
+
+#include "dex.h"
+#include "dex_def.h"
+
+
+
+#define G_TYPE_DEX_METHOD (g_dex_method_get_type())
+#define G_DEX_METHOD(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_DEX_METHOD, GDexMethod))
+#define G_DEX_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DEX_METHOD, GDexMethodClass))
+#define G_IS_DEX_METHOD(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_DEX_METHOD))
+#define G_IS_DEX_METHOD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DEX_METHOD))
+#define G_DEX_METHOD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DEX_METHOD, GDexMethodClass))
+
+
+
+/* Methode issue du code source (instance) */
+typedef struct _GDexMethod GDexMethod;
+
+/* Methode issue du code source (classe) */
+typedef struct _GDexMethodClass GDexMethodClass;
+
+
+
+/* Détermine le type d'une methode issue du code source. */
+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 *);
+
+/* Fournit la zone binaire correspondant à la méthode. */
+GBinPart *g_dex_method_as_part(const GDexMethod *);
+
+
+
+
+
+
+
+#endif /* _FORMAT_DEX_METHOD_H */
diff --git a/src/format/dex/pool.c b/src/format/dex/pool.c
new file mode 100644
index 0000000..0a8bed3
--- /dev/null
+++ b/src/format/dex/pool.c
@@ -0,0 +1,197 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * pool.c - extraction des informations issues des tables globales
+ *
+ * Copyright (C) 2010 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/>.
+ */
+
+
+#include "pool.h"
+
+
+#include "dex-int.h"
+#include "../mangling/demangler.h"
+
+
+
+/******************************************************************************
+* *
+* 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 : - *
+* *
+******************************************************************************/
+
+GOpenidaType *get_type_from_dex_pool(const GDexFormat *format, uint16_t index)
+{
+ off_t pos; /* Tête de lecture */
+ 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 */
+
+
+ //printf("Index :: 0x%04hx\n", index);
+
+
+ pos = format->header.type_ids_off + index * sizeof(type_id_item);
+
+ if (!read_dex_type_id_item(format, &pos, &type_id))
+ return NULL;
+
+
+
+
+ pos = format->header.string_ids_off + type_id.descriptor_idx * sizeof(string_id_item);
+
+ if (!read_dex_string_id_item(format, &pos, &str_id))
+ return NULL;
+
+ pos = str_id.string_data_off;
+
+ if (!read_dex_string_data_item(format, &pos, &str_data))
+ return NULL;
+
+
+ //printf(">> String :: '%s'\n", str_data.data);
+
+
+ return demangle_type(DGT_JAVA, (char *)str_data.data);
+
+}
+
+
+
+
+
+/******************************************************************************
+* *
+* 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 : - *
+* *
+******************************************************************************/
+
+GOpenidaType *get_class_from_dex_pool(const GDexFormat *format, uint16_t index)
+{
+ GOpenidaType *result; /* Instance à retourner */
+ off_t pos; /* Tête de lecture */
+ class_def_item class_def; /* Définition de la classe */
+
+ pos = format->header.class_defs_off + index * sizeof(class_def_item);
+
+ if (!read_dex_class_def_item(format, &pos, &class_def))
+ return NULL;
+
+
+
+ result = NULL;
+
+
+ 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_routine_from_dex_pool(const GDexFormat *format, uleb128_t index)
+{
+ GBinRoutine *result; /* Instance à retourner */
+ off_t pos; /* Tête de lecture */
+ method_id_item meth_id; /* Description de la méthode */
+
+
+ GOpenidaType *type;
+
+ string_id_item str_id; /* Identifiant de chaîne */
+ string_data_item str_data; /* Description de chaîne */
+
+ pos = format->header.method_ids_off + index * sizeof(method_id_item);
+
+ if (!read_dex_method_id_item(format, &pos, &meth_id))
+ return NULL;
+
+
+
+
+
+
+ type = get_type_from_dex_pool(format, meth_id.class_idx);
+
+ /*
+ if (type == NULL)
+ printf("class is nil\n");
+
+ else
+ printf("class = '%s'\n", g_openida_type_to_string(type));
+ */
+
+ /* Nom de la méthode */
+
+ pos = format->header.string_ids_off + meth_id.name_idx * sizeof(string_id_item);
+
+ if (!read_dex_string_id_item(format, &pos, &str_id))
+ return NULL;
+
+ pos = str_id.string_data_off;
+
+ if (!read_dex_string_data_item(format, &pos, &str_data))
+ return NULL;
+
+
+ //printf("String :: '%s'\n", str_data.data);
+
+
+ result = g_binary_routine_new();
+
+ g_binary_routine_set_name(result, (char *)str_data.data);
+
+ if (type != NULL)
+ g_binary_routine_set_namespace(result, type);
+
+
+ //printf("==>>> routine :: '%s'\n", g_binary_routine_to_string(result));
+
+ return result;
+
+}
diff --git a/src/format/dex/pool.h b/src/format/dex/pool.h
new file mode 100644
index 0000000..a41a1da
--- /dev/null
+++ b/src/format/dex/pool.h
@@ -0,0 +1,48 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * pool.h - prototypes pour l'extraction des informations issues des tables globales
+ *
+ * Copyright (C) 2010 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 _FORMAT_DEX_POOL_H
+#define _FORMAT_DEX_POOL_H
+
+
+#include "dex.h"
+#include "../../analysis/routine.h"
+#include "../../common/leb128.h"
+
+
+
+/* Extrait une représentation de type d'une table DEX. */
+GOpenidaType *get_type_from_dex_pool(const GDexFormat *, uint16_t);
+
+
+/* Extrait une représentation de classe d'une table DEX. */
+GOpenidaType *get_class_from_dex_pool(const GDexFormat *, uint16_t);
+
+
+
+/* Extrait une représentation de routine d'une table DEX. */
+GBinRoutine *get_routine_from_dex_pool(const GDexFormat *, uleb128_t);
+
+
+
+#endif /* _FORMAT_DEX_POOL_H */
diff --git a/src/format/executable.h b/src/format/executable.h
index 2042df4..c90ccfe 100644
--- a/src/format/executable.h
+++ b/src/format/executable.h
@@ -37,6 +37,7 @@ typedef enum _FormatTargetMachine
{
FTM_NONE, /* Aucune archi. (reconnue) */
+ FTM_DALVIK, /* Dalvik Virtual Machine */
FTM_JVM, /* Java Virtual Machine */
FTM_MIPS, /* Mips 32 ou 64 bits */
FTM_386, /* Intel 80386 */
diff --git a/src/format/format-int.h b/src/format/format-int.h
index 13eb50a..319f5cd 100644
--- a/src/format/format-int.h
+++ b/src/format/format-int.h
@@ -57,7 +57,7 @@ struct _GBinFormatClass
/* Définit le contenu binaire à analyser. */
-void g_binary_format_set_content(GBinFormat *, bin_t *, off_t);
+void g_binary_format_set_content(GBinFormat *, const bin_t *, off_t);
diff --git a/src/format/format.c b/src/format/format.c
index df375fb..c53e7aa 100644
--- a/src/format/format.c
+++ b/src/format/format.c
@@ -28,6 +28,7 @@
#include "format-int.h"
+#include "dex/dex.h"
#include "dwarf/dwarf.h"
#include "elf/elf.h"
#include "java/java.h"
@@ -145,7 +146,7 @@ static void g_binary_format_init(GBinFormat *format)
* *
******************************************************************************/
-void g_binary_format_set_content(GBinFormat *format, bin_t *content, off_t length)
+void g_binary_format_set_content(GBinFormat *format, const bin_t *content, off_t length)
{
format->content = content;
format->length = length;
@@ -334,8 +335,9 @@ bool g_binary_format_resolve_symbol(const GBinFormat *format, const char **label
bool init_all_formats(void)
{
+ register_format(FID_DEX, _("Dalvik Executable"), FMT_EXEC, dex_is_matching, g_dex_format_new);
+ //register_format(FID_DWARF, _("Dwarf"), FMT_DEBUG, dwarf_is_matching, g_dwarf_format_new);
register_format(FID_ELF, _("ELF"), FMT_EXEC, elf_is_matching, g_elf_format_new);
- register_format(FID_DWARF, _("Dwarf"), FMT_DEBUG, dwarf_is_matching, g_dwarf_format_new);
register_format(FID_JAVA, _("Java"), FMT_EXEC, java_is_matching, g_java_format_new);
register_format(FID_PE, _("PE"), FMT_EXEC, pe_is_matching, g_pe_format_new);
diff --git a/src/format/format.h b/src/format/format.h
index 05a2af9..0223525 100644
--- a/src/format/format.h
+++ b/src/format/format.h
@@ -81,8 +81,9 @@ bool g_binary_format_resolve_symbol(const GBinFormat *, const char **, SymbolTyp
/* Identifiants pour les différents formats */
typedef enum _FormatIdentifier
{
+ FID_DEX, /* Format DEX */
+ //FID_DWARF, /* Format Dwarf */
FID_ELF, /* Format ELF */
- FID_DWARF, /* Format Dwarf */
FID_JAVA, /* Format Java */
FID_PE, /* Format PE */
diff --git a/src/format/java/java-int.h b/src/format/java/java-int.h
index 20ddf3c..40ed675 100755
--- a/src/format/java/java-int.h
+++ b/src/format/java/java-int.h
@@ -63,4 +63,4 @@ bool read_java_header(const GJavaFormat *, off_t *, java_header *);
-#endif /* _FORMAT_JAVA_E_JAVA_INT_H */
+#endif /* _FORMAT_JAVA_JAVA_INT_H */
diff --git a/src/format/mangling/Makefile.am b/src/format/mangling/Makefile.am
index 994919d..6298743 100644
--- a/src/format/mangling/Makefile.am
+++ b/src/format/mangling/Makefile.am
@@ -1,11 +1,13 @@
-BUILT_SOURCES = itanium_gram.h
+BUILT_SOURCES = itanium_gram.h libjavamangling_la-java_gram.h
AM_YFLAGS = -d
-noinst_LTLIBRARIES = libformatmangling.la
+noinst_LTLIBRARIES = libjavamangling.la libformatmangling.la
libformatmangling_la_SOURCES = \
+ context-int.h \
+ context.h context.c \
demangler.h demangler.c \
itanium.h \
itanium_gram.y \
@@ -13,6 +15,23 @@ libformatmangling_la_SOURCES = \
libformatmangling_la_LDFLAGS =
+libformatmangling_la_LIBADD = \
+ libjavamangling.la
+
+
+# Partie Java
+
+libjavamangling_la_SOURCES = \
+ java.h \
+ java_gram.y \
+ java_tok.l
+
+libjavamangling_la_YFLAGS = -d -p java_ -o y.tab.c
+
+libjavamangling_la_LFLAGS = -P java_ -o lex.yy.c
+
+
+
INCLUDES = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS)
@@ -22,4 +41,5 @@ AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS)
# Automake fait les choses à moitié
-CLEANFILES = itanium_gram.h itanium_gram.c itanium_tok.c
+CLEANFILES = itanium_gram.h itanium_gram.c itanium_tok.c \
+ java_gram.h java_gram.c libjavamangling_la-java_tok.c
diff --git a/src/format/mangling/context-int.h b/src/format/mangling/context-int.h
new file mode 100644
index 0000000..e8e6ec0
--- /dev/null
+++ b/src/format/mangling/context-int.h
@@ -0,0 +1,53 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * context.h - prototypes internes liés aux contextes de décodage
+ *
+ * Copyright (C) 2010 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 _FORMAT_MANGLING_CONTEXT_INT_H
+#define _FORMAT_MANGLING_CONTEXT_INT_H
+
+
+#include "context.h"
+
+
+
+/* Contexte de décodage (instance) */
+struct _GDemanglingContext
+{
+ GObject parent; /* A laisser en premier */
+
+ union
+ {
+ GOpenidaType *type; /* Type décodé */
+ };
+
+};
+
+/* Contexte de décodage (classe) */
+struct _GDemanglingContextClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+
+#endif /* _FORMAT_MANGLING_CONTEXT_INT_H */
diff --git a/src/format/mangling/context.c b/src/format/mangling/context.c
new file mode 100644
index 0000000..0d57937
--- /dev/null
+++ b/src/format/mangling/context.c
@@ -0,0 +1,95 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * context.c - fourniture de contexte aux phases de décodage
+ *
+ * Copyright (C) 2010 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/>.
+ */
+
+
+#include "context.h"
+
+
+#include "context-int.h"
+
+
+
+/* Initialise la classe des contextes de décodage. */
+static void g_demangling_context_class_init(GDemanglingContextClass *);
+
+/* Initialise une instance de contexte pour décodage. */
+static void g_demangling_context_init(GDemanglingContext *);
+
+
+
+/* Indique le type défini pour un contexte de décodage. */
+G_DEFINE_TYPE(GDemanglingContext, g_demangling_context, G_TYPE_OBJECT);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des contextes de décodage. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_demangling_context_class_init(GDemanglingContextClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : context = instance à initialiser. *
+* *
+* Description : Initialise une instance de contexte pour décodage. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_demangling_context_init(GDemanglingContext *context)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : context = instance à consulter. *
+* *
+* Description : Fournit le type créé à l'issue du codage. *
+* *
+* Retour : Instance en place ou NULL en cas d'erreur fatale. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GOpenidaType *g_demangling_context_get_decoded_type(const GDemanglingContext *context)
+{
+ return context->type;
+
+}
diff --git a/src/format/mangling/context.h b/src/format/mangling/context.h
new file mode 100644
index 0000000..3ede4da
--- /dev/null
+++ b/src/format/mangling/context.h
@@ -0,0 +1,57 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * context.h - prototypes pour la fourniture de contexte aux phases de décodage
+ *
+ * Copyright (C) 2010 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 _FORMAT_MANGLING_CONTEXT_H
+#define _FORMAT_MANGLING_CONTEXT_H
+
+
+#include <glib-object.h>
+
+
+#include "../../analysis/routine.h"
+
+
+
+#define G_TYPE_DEMANGLING_CONTEXT g_demangling_context_get_type()
+#define G_DEMANGLING_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_demangling_context_get_type(), GDemanglingContext))
+#define G_IS_DEMANGLING_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_demangling_context_get_type()))
+#define G_DEMANGLING_CONTEXT_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_demangling_context_get_type(), GDemanglingContextIface))
+#define G_DEMANGLING_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DEMANGLING_CONTEXT, GDemanglingContextClass))
+
+
+/* Contexte de décodage (instance) */
+typedef struct _GDemanglingContext GDemanglingContext;
+
+/* Contexte de décodage (classe) */
+typedef struct _GDemanglingContextClass GDemanglingContextClass;
+
+
+/* Indique le type défini pour un contexte de décodage. */
+GType g_demangling_context_get_type(void);
+
+/* Fournit le type créé à l'issue du codage. */
+GOpenidaType *g_demangling_context_get_decoded_type(const GDemanglingContext *);
+
+
+
+#endif /* _FORMAT_MANGLING_CONTEXT_H */
diff --git a/src/format/mangling/demangler.c b/src/format/mangling/demangler.c
index e8b6b0f..47ffd36 100644
--- a/src/format/mangling/demangler.c
+++ b/src/format/mangling/demangler.c
@@ -29,79 +29,90 @@
#include "demangler-int.h"
#include "itanium.h"
+#include "java.h"
-static name_demangler **demanglers = NULL;
-static size_t demanglers_count = 0;
+/* Prépare de quoi effectuer un décodage. */
+typedef GDemanglingContext * (* create_context_fc) (void);
+/* Procède au décodage d'une chaîne de caractères. */
+typedef bool (* demangle_type_fc) (GDemanglingContext *, const char *);
-/* Enregistre un nouveau décodeur de noms. */
-void register_new_demangler(name_demangler *);
+/* Appels liés à un décodeur */
+typedef struct _demangling_properties
+{
+ create_context_fc create_context; /* Création de contextes */
+ demangle_type_fc demangle_type; /* Décodage d'un type */
+} demangling_properties;
-/******************************************************************************
-* *
-* Paramètres : - *
-* *
-* Description : Procède au chargement des différents décodeurs de noms. *
-* *
-* Retour : true pour indiquer un chargement réussi, false sinon. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-bool init_all_demanglers(void)
-{
- register_new_demangler(create_itanium_demangler());
+/* Liste des décodeurs */
+static demangling_properties demanglers[DGT_COUNT] = {
- return true;
+ [DGT_ITANIUM] = {
+ .create_context = (create_context_fc)NULL,
+ .demangle_type = (demangle_type_fc)NULL
+ },
+
+ [DGT_JAVA] = {
+ .create_context = (create_context_fc)g_java_dcontext_new,
+ .demangle_type = (demangle_type_fc)demangle_java_type
+ }
+
+};
-}
/******************************************************************************
* *
-* Paramètres : demangler = décodeur opérationnel. *
+* Paramètres : type = identifiant du décodeur visé. *
* *
-* Description : Enregistre un nouveau décodeur de noms. *
+* Description : Fournit la référence correspondant à un décodeur donné. *
* *
-* Retour : - *
+* Retour : Adresse du décodeur trouvé ou NULL. *
* *
* Remarques : - *
* *
******************************************************************************/
-void register_new_demangler(name_demangler *demangler)
+name_demangler *get_demangler_by_type(DemanglerType type)
{
- demanglers = (name_demangler **)realloc(demanglers, ++demanglers_count * sizeof(name_demangler *));
- demanglers[demanglers_count - 1] = demangler;
+ name_demangler *result; /* Adresse à retourner */
+
+ result = NULL;//demanglers[0];
+
+ return result;
}
/******************************************************************************
* *
-* Paramètres : type = identifiant du décodeur visé. *
+* Paramètres : demangler = décodeur à utiliser. *
+* name = chaîne de caractères à décoder. *
* *
-* Description : Fournit la référence correspondant à un décodeur donné. *
+* Description : Tente de décoder une chaîne de caractères donnée. *
* *
-* Retour : Adresse du décodeur trouvé ou NULL. *
+* Retour : Bilan de l'opération. *
* *
* Remarques : - *
* *
******************************************************************************/
-name_demangler *get_demangler_by_type(DemanglerType type)
+GBinRoutine *try_to_demangle_routine(name_demangler *demangler, const char *name)
{
- name_demangler *result; /* Adresse à retourner */
-
- result = demanglers[0];
+ GBinRoutine *result; /* Construction à remonter */
+ result = NULL;
+ /*
+ if (demangler->can_be_demangled(demangler, name))
+ result = demangler->demangle_routine(demangler, name);
+ */
return result;
}
@@ -109,8 +120,8 @@ name_demangler *get_demangler_by_type(DemanglerType type)
/******************************************************************************
* *
-* Paramètres : demangler = décodeur à utiliser. *
-* name = chaîne de caractères à décoder. *
+* Paramètres : type = type de décodeur à utiliser. *
+* desc = chaîne de caractères à décoder. *
* *
* Description : Tente de décoder une chaîne de caractères donnée. *
* *
@@ -120,14 +131,26 @@ name_demangler *get_demangler_by_type(DemanglerType type)
* *
******************************************************************************/
-GBinRoutine *try_to_demangle_routine(name_demangler *demangler, const char *name)
+GOpenidaType *demangle_type(DemanglerType type, const char *desc)
{
- GBinRoutine *result; /* Construction à remonter */
+ GOpenidaType *result; /* Construction à remonter */
+ GDemanglingContext *context; /* Contexte pour le décodage */
result = NULL;
-
+ /*
if (demangler->can_be_demangled(demangler, name))
result = demangler->demangle_routine(demangler, name);
+ */
+
+ context = demanglers[type].create_context();
+
+ if (demanglers[type].demangle_type(context, desc))
+ {
+ result = g_demangling_context_get_decoded_type(context);
+ g_object_ref(result);
+ }
+
+ g_object_unref(context);
return result;
diff --git a/src/format/mangling/demangler.h b/src/format/mangling/demangler.h
index fb23f16..0cdadb5 100644
--- a/src/format/mangling/demangler.h
+++ b/src/format/mangling/demangler.h
@@ -35,7 +35,10 @@
/* Identifiant des décodeurs existants */
typedef enum _DemanglerType
{
- DGT_ITANIUM /* Gnu V3 */
+ DGT_ITANIUM, /* Gnu V3 */
+ DGT_JAVA, /* Java / DEX */
+
+ DGT_COUNT
} DemanglerType;
@@ -45,9 +48,6 @@ typedef struct _name_demangler name_demangler;
-/* Procède au chargement des différents décodeurs de noms. */
-bool init_all_demanglers(void);
-
/* Fournit la référence correspondant à un décodeur donné. */
name_demangler *get_demangler_by_type(DemanglerType);
@@ -55,5 +55,9 @@ name_demangler *get_demangler_by_type(DemanglerType);
GBinRoutine *try_to_demangle_routine(name_demangler *, const char *);
+/* Tente de décoder une chaîne de caractères donnée. */
+GOpenidaType *demangle_type(DemanglerType, const char *);
+
+
#endif /* _FORMAT_MANGLING_DEMANGLER_H */
diff --git a/src/format/mangling/java.h b/src/format/mangling/java.h
new file mode 100644
index 0000000..08dafe3
--- /dev/null
+++ b/src/format/mangling/java.h
@@ -0,0 +1,59 @@
+
+/* OpenIDA - Outil d'analyse de fichiers binaires
+ * java.h - prototypes pour le décodage des noms d'éléments selon Java
+ *
+ * Copyright (C) 2010 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 _FORMAT_MANGLING_JAVA_H
+#define _FORMAT_MANGLING_JAVA_H
+
+
+#include <stdbool.h>
+
+
+#include "context.h"
+#include "demangler.h"
+
+
+
+/* ------------------------- CONTEXTE POUR LE DECODAGE JAVA ------------------------- */
+
+
+/* Contexte de décodage Java (instance) */
+typedef struct _GJavaDContext GJavaDContext;
+
+/* Contexte de décodage Java (classe) */
+typedef struct _GJavaDContextClass GJavaDContextClass;
+
+
+/* Prépare de quoi effectuer un décodage Java. */
+GDemanglingContext *g_java_dcontext_new(void);
+
+
+
+
+
+
+/* Procède au décodage d'une chaîne de caractères. */
+bool demangle_java_type(GJavaDContext *, const char *);
+
+
+
+#endif /* _FORMAT_MANGLING_JAVA_H */
diff --git a/src/format/mangling/java_gram.y b/src/format/mangling/java_gram.y
new file mode 100644
index 0000000..3522b01
--- /dev/null
+++ b/src/format/mangling/java_gram.y
@@ -0,0 +1,271 @@
+
+%{
+
+
+
+#include "context-int.h"
+#include "demangler-int.h"
+#include "java.h"
+
+
+
+/* ------------------------- CONTEXTE POUR LE DECODAGE JAVA ------------------------- */
+
+
+#define G_TYPE_JAVA_DCONTEXT g_java_dcontext_get_type()
+#define G_JAVA_DCONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_java_dcontext_get_type(), GJavaDContext))
+#define G_IS_JAVA_DCONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_java_dcontext_get_type()))
+#define G_JAVA_DCONTEXT_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE((inst), g_java_dcontext_get_type(), GJavaDContextIface))
+#define G_JAVA_DCONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_JAVA_DCONTEXT, GJavaDContextClass))
+
+
+/* Contexte de décodage Java (instance) */
+struct _GJavaDContext
+{
+ GDemanglingContext parent; /* A laisser en premier */
+
+};
+
+/* Contexte de décodage Java (classe) */
+struct _GJavaDContextClass
+{
+ GDemanglingContextClass parent; /* A laisser en premier */
+
+};
+
+
+/* Indique le type défini pour un contexte de décodage. */
+static GType g_java_dcontext_get_type(void);
+
+/* Initialise la classe des contextes de décodage. */
+static void g_java_dcontext_class_init(GJavaDContextClass *);
+
+/* Initialise une instance de contexte pour décodage. */
+static void g_java_dcontext_init(GJavaDContext *);
+
+
+
+
+
+
+
+%}
+
+
+%union {
+
+ void /*GOpenidaType*/ *type;
+
+ char *text; /* Chaîne de caractères */
+
+}
+
+%parse-param { GJavaDContext *context }
+
+%token V Z B S C I J F D
+%token L SEMICOLON
+%token SLASH DOLLAR
+%token TEXT
+
+%type <type> type_descriptor field_type_descriptor non_array_field_type_descriptor full_class_name
+
+%type <text> TEXT
+
+
+%{
+
+/* De lexi.c... */
+/*int yylex(YYSTYPE *, YYLTYPE *);*/
+void java_restart(FILE *);
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+extern YY_BUFFER_STATE java__scan_string(const char *);
+extern void java__delete_buffer(YY_BUFFER_STATE);
+
+ extern int java_lex (void);
+
+
+/* Affiche un message d'erreur concernant l'analyse. */
+/*int yyerror(const YYLTYPE *, bool, char **, unsigned char *, char *);*/
+
+%}
+
+
+%%
+
+
+input:
+ type_descriptor { G_DEMANGLING_CONTEXT(context)->type = $1; }
+ ;
+
+type_descriptor:
+ 'V' { $$ = g_basic_type_new(BTP_VOID); }
+ | field_type_descriptor { $$ = $1; }
+ ;
+
+field_type_descriptor:
+ non_array_field_type_descriptor { $$ = $1; }
+ ;
+
+non_array_field_type_descriptor:
+ Z { $$ = g_basic_type_new(BTP_BOOL); }
+ | B { $$ = g_basic_type_new(BTP_UCHAR); }
+ | S { $$ = g_basic_type_new(BTP_SHORT); }
+ | C { $$ = g_basic_type_new(BTP_CHAR); }
+ | I { $$ = g_basic_type_new(BTP_INT); }
+ | J { $$ = g_basic_type_new(BTP_LONG); }
+ | F { $$ = g_basic_type_new(BTP_FLOAT); }
+ | D { $$ = g_basic_type_new(BTP_DOUBLE); }
+ | L full_class_name SEMICOLON { $$ = $2; }
+ ;
+
+full_class_name:
+ TEXT { $$ = g_class_enum_type_new(CET_CLASS, $1); }
+ | full_class_name SLASH TEXT {
+ $$ = g_class_enum_type_new(CET_CLASS, $3);
+ g_openida_type_set_namespace($$, $1);
+ g_object_unref($1);
+ }
+ | full_class_name DOLLAR TEXT {
+ $$ = g_class_enum_type_new(CET_CLASS, $3);
+ g_openida_type_set_namespace($$, $1);
+ g_object_unref($1);
+ }
+ ;
+
+
+%%
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* CONTEXTE POUR LE DECODAGE JAVA */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un contexte de décodage. */
+G_DEFINE_TYPE(GJavaDContext, g_java_dcontext, G_TYPE_DEMANGLING_CONTEXT);
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des contextes de décodage. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_java_dcontext_class_init(GJavaDContextClass *klass)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : context = instance à initialiser. *
+* *
+* Description : Initialise une instance de contexte pour décodage. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_java_dcontext_init(GJavaDContext *context)
+{
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : - *
+* *
+* Description : Prépare de quoi effectuer un décodage Java. *
+* *
+* Retour : Instance du contexte mis en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GDemanglingContext *g_java_dcontext_new(void)
+{
+ GDemanglingContext *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_JAVA_DCONTEXT, NULL);
+
+ return result;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Affiche un message d'erreur concernant l'analyse.
+ * @param yyloc informations concernant les coordonnées du soucis.
+ * @param hunt indique le type de passe réalisée.
+ * @param ucode code résultant compilé.
+ * @param index indice de commande à mettre à jour.
+ * @param msg indications humaines sur l'événement.
+ * @return 0.
+ */
+int java_error(/*const YYLTYPE *yyloc, bool hunt, char **ucode, unsigned char *index, */char *msg)
+{
+
+
+
+ fprintf(stderr, "ERREUR !\n");
+ fprintf(stderr, "%s\n", msg);
+
+ return -1;
+
+}
+
+
+
+
+
+
+/******************************************************************************
+* *
+* Paramètres : context = contexte de décodage à utiliser. *
+* desc = chaîne de caractères à décoder. *
+* *
+* Description : Procède au décodage d'une chaîne de caractères. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+bool demangle_java_type(GJavaDContext *context, const char *desc)
+{
+ YY_BUFFER_STATE buffer; /* Tampon pour bison */
+ int ret; /* Bilan de l'appel */
+
+ buffer = java__scan_string(desc);
+ ret = yyparse(context);
+ java__delete_buffer(buffer);
+
+ return (ret == 0);
+
+}
diff --git a/src/format/mangling/java_tok.l b/src/format/mangling/java_tok.l
new file mode 100644
index 0000000..06777f9
--- /dev/null
+++ b/src/format/mangling/java_tok.l
@@ -0,0 +1,33 @@
+
+%{
+
+#include "libjavamangling_la-java_gram.h"
+
+%}
+
+
+%option noyywrap
+%option yylineno
+
+%x string
+
+
+%%
+
+V { return V; }
+Z { return Z; }
+B { return B; }
+S { return S; }
+C { return C; }
+I { return I; }
+J { return J; }
+F { return F; }
+D { return D; }
+L { printf("Got 'L'\n"); BEGIN(string); return L; }
+<string>[/] { printf("Got '/'\n"); return SLASH; }
+<string>[$] { printf("Got '$'\n"); return DOLLAR; }
+<string>[;] { BEGIN(INITIAL); return SEMICOLON; }
+
+<string>[A-Za-z0-9]* { java_lval.text = yytext; printf("Got text:'%s'\n", yytext); return TEXT; }
+
+%%