Supported Dalvik VM / DEX (partially).

git-svn-id: svn://svn.gna.org/svn/chrysalide/trunk@155 abbe820e-26c8-41b2-8c08-b7b2b41f8b0a

1 files changed, 298 insertions, 0 deletions

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;
+
+}