Handled Dalvik exception handlers in the graphic view.

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

9 files changed, 496 insertions, 7 deletions

diff --git a/src/format/dex/class.c b/src/format/dex/class.c
index 52389c4..52141ae 100644
--- a/src/format/dex/class.c
+++ b/src/format/dex/class.c
@@ -254,6 +254,61 @@ static void g_dex_class_register_method(const GDexClass *class, GBinFormat *form
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : class   = informations chargées à consulter.                 *
+*                virtual = précise la nature des méthodes ciblées.            *
+*                                                                             *
+*  Description : Dénombre les méthodes chargées d'un type donné.              *
+*                                                                             *
+*  Retour      : Quantité de méthodes trouvées.                               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_dex_class_count_methods(const GDexClass *class, bool virtual)
+{
+    size_t result;                          /* Compte à retourner          */
+
+    if (virtual)
+        result = class->vmethods_count;
+    else
+        result = class->dmethods_count;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : class   = informations chargées à consulter.                 *
+*                virtual = précise la nature des méthodes ciblées.            *
+*                index   = indique l'indice de la méthode désirée.            *
+*                                                                             *
+*  Description : Fournit une méthode chargée correspondant à un type donné.   *
+*                                                                             *
+*  Retour      : Quantité de méthodes trouvées.                               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDexMethod *g_dex_class_get_method(const GDexClass *class, bool virtual, size_t index)
+{
+    GDexMethod *result;                     /* Instance à renvoyer         */
+
+    if (virtual)
+        result = class->virtual_methods[index];
+    else
+        result = class->direct_methods[index];
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : class = informations chargées à consulter.                   *
 *                parts = liste à venir compléter.                             *
 *                count = quantité de zones listées. [OUT]                     *
@@ -294,6 +349,10 @@ GBinPart **g_dex_class_get_parts(const GDexClass *class, GBinPart **parts, size_
 }
 
 
+
+
+
+
 /******************************************************************************
 *                                                                             *
 *  Paramètres  : class = informations chargées à consulter.                   *
diff --git a/src/format/dex/class.h b/src/format/dex/class.h
index 998c1b7..e7094ff 100644
--- a/src/format/dex/class.h
+++ b/src/format/dex/class.h
@@ -54,6 +54,12 @@ typedef struct _GDexClassClass GDexClassClass;
 /* Détermine le type d'une classe issue du code source. */
 GType g_dex_class_get_type(void);
 
+/* Dénombre les méthodes chargées d'un type donné. */
+size_t g_dex_class_count_methods(const GDexClass *, bool);
+
+/* Fournit une méthode chargée correspondant à un type donné. */
+GDexMethod *g_dex_class_get_method(const GDexClass *, bool, size_t);
+
 /*  Fournit les références aux zones binaires à analyser. */
 GBinPart **g_dex_class_get_parts(const GDexClass *, GBinPart **, size_t *);
 
diff --git a/src/format/dex/dex-int.c b/src/format/dex/dex-int.c
index 5628e6b..200b01f 100644
--- a/src/format/dex/dex-int.c
+++ b/src/format/dex/dex-int.c
@@ -529,10 +529,226 @@ void reset_dex_class_data_item(class_data_item *item)
 
 
 
+/* ---------------------------------------------------------------------------------- */
+/*                             PORTION DE CODE EXECUTABLE                             */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                pos    = position de début de lecture. [OUT]                 *
+*                pair   = structure lue à retourner. [OUT]                    *
+*                                                                             *
+*  Description : Procède à la lecture d'une association exception <-> code.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dex_encoded_type_addr_pair(const GDexFormat *format, off_t *pos, encoded_type_addr_pair *pair)
+{
+    bool result;                            /* Bilan à retourner           */
+    const bin_t *content;                   /* Contenu binaire à lire      */
+    off_t length;                           /* Taille totale du contenu    */
+
+    result = true;
+
+    content = G_BIN_FORMAT(format)->content;
+    length = G_BIN_FORMAT(format)->length;
+
+    result &= read_uleb128(&pair->type_idx, content, pos, length);
+    result &= read_uleb128(&pair->addr, content, pos, length);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format  = informations chargées à consulter.                 *
+*                pos     = position de début de lecture. [OUT]                *
+*                handler = structure lue à retourner. [OUT]                   *
+*                                                                             *
+*  Description : Procède à la lecture d'une association exception <-> code.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dex_encoded_catch_handler(const GDexFormat *format, off_t *pos, encoded_catch_handler *handler)
+{
+    bool result;                            /* Bilan à retourner           */
+    const bin_t *content;                   /* Contenu binaire à lire      */
+    off_t length;                           /* Taille totale du contenu    */
+    leb128_t count;                         /* Nombre de gestionnaires     */
+    leb128_t i;                             /* Boucle de parcours          */
+
+    result = true;
+
+    content = G_BIN_FORMAT(format)->content;
+    length = G_BIN_FORMAT(format)->length;
+
+    handler->offset = *pos;
+
+    result &= read_leb128(&handler->size, content, pos, length);
+
+    count = leb128_abs(handler->size);
+
+    if (count > 0 && result)
+    {
+        handler->handlers = (encoded_type_addr_pair *)calloc(count, sizeof(encoded_type_addr_pair));
+
+        for (i = 0; i < count && result; i++)
+            result &= read_dex_encoded_type_addr_pair(format, pos, &handler->handlers[i]);
+
+    }
+    else handler->handlers = NULL;
+
+    if (handler->size < 0)
+        result &= read_uleb128(&handler->catch_all_addr, content, pos, length);
+    else
+        handler->catch_all_addr = ULEB128_MAX;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : handler = structure à nettoyer.                              *
+*                                                                             *
+*  Description : Supprime tous les éléments chargés en mémoire à la lecture.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void reset_dex_encoded_catch_handler(encoded_catch_handler *handler)
+{
+    if (handler->handlers != NULL)
+        free(handler->handlers);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                pos    = position de début de lecture. [OUT]                 *
+*                list   = structure lue à retourner. [OUT]                    *
+*                                                                             *
+*  Description : Procède à la lecture d'une association exception <-> code.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dex_encoded_catch_handler_list(const GDexFormat *format, off_t *pos, encoded_catch_handler_list *list)
+{
+    bool result;                            /* Bilan à retourner           */
+    const bin_t *content;                   /* Contenu binaire à lire      */
+    off_t length;                           /* Taille totale du contenu    */
+    off_t saved_off;                        /* Sauvegarde de position      */
+    uleb128_t i;                            /* Boucle de parcours          */
 
+    result = true;
 
+    content = G_BIN_FORMAT(format)->content;
+    length = G_BIN_FORMAT(format)->length;
+
+    saved_off = *pos;
+
+    result &= read_uleb128(&list->size, content, pos, length);
 
+    if (list->size > 0 && result)
+    {
+        list->list = (encoded_catch_handler *)calloc(list->size, sizeof(encoded_catch_handler));
 
+        for (i = 0; i < list->size && result; i++)
+        {
+            result &= read_dex_encoded_catch_handler(format, pos, &list->list[i]);
+            if (result) list->list[i].offset -= saved_off;
+        }
+
+    }
+    else list->list = NULL;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : list = structure à nettoyer.                                 *
+*                                                                             *
+*  Description : Supprime tous les éléments chargés en mémoire à la lecture.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void reset_dex_encoded_catch_handler_list(encoded_catch_handler_list *list)
+{
+    uleb128_t i;                            /* Boucle de parcours          */
+
+    if (list->list != NULL)
+    {
+        for (i = 0; i < list->size; i++)
+            reset_dex_encoded_catch_handler(&list->list[i]);
+
+        free(list->list);
+
+    }
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = informations chargées à consulter.                  *
+*                pos    = position de début de lecture. [OUT]                 *
+*                item   = structure lue à retourner. [OUT]                    *
+*                                                                             *
+*  Description : Procède à la lecture d'une association exception <-> code.   *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool read_dex_try_item(const GDexFormat *format, off_t *pos, try_item *item)
+{
+    bool result;                            /* Bilan à retourner           */
+    const bin_t *content;                   /* Contenu binaire à lire      */
+    off_t length;                           /* Taille totale du contenu    */
+
+    result = true;
+
+    content = G_BIN_FORMAT(format)->content;
+    length = G_BIN_FORMAT(format)->length;
+
+    result &= read_u32(&item->start_addr, content, pos, length, SRE_LITTLE);
+    result &= read_u16(&item->insn_count, content, pos, length, SRE_LITTLE);
+    result &= read_u16(&item->handler_off, content, pos, length, SRE_LITTLE);
+
+    return result;
+
+}
 
 
 /******************************************************************************
@@ -554,6 +770,8 @@ bool read_dex_code_item(const GDexFormat *format, off_t *pos, code_item *item)
     bool result;                            /* Bilan à retourner           */
     const bin_t *content;                   /* Contenu binaire à lire      */
     off_t length;                           /* Taille totale du contenu    */
+    uint16_t padding;                       /* Eventuel alignement         */
+    uint16_t i;                             /* Boucle de parcours          */
 
     result = true;
 
@@ -569,11 +787,59 @@ bool read_dex_code_item(const GDexFormat *format, off_t *pos, code_item *item)
 
     item->insns = (uint16_t *)pos;
 
+    *pos += item->insns_size * sizeof(uint16_t);
+
+    /* Padding ? */
+    if (item->tries_size > 0 && item->insns_size % 2 == 1)
+        result &= read_u16(&padding, content, pos, length, SRE_LITTLE);
+
+    if (item->tries_size > 0 && result)
+    {
+        item->tries = (try_item *)calloc(item->tries_size, sizeof(try_item));
+
+        for (i = 0; i < item->tries_size && result; i++)
+            result &= read_dex_try_item(format, pos, &item->tries[i]);
+
+        if (result)
+        {
+            item->handlers = (encoded_catch_handler_list *)calloc(1, sizeof(encoded_catch_handler_list));
+            result &= read_dex_encoded_catch_handler_list(format, pos, item->handlers);
+        }
+
+    }
+
     return result;
 
 }
 
 
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : item = structure à nettoyer.                                 *
+*                                                                             *
+*  Description : Supprime tous les éléments chargés en mémoire à la lecture.  *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void reset_dex_code_item(code_item *item)
+{
+    if (item->tries != NULL)
+        free(item->tries);
+
+    if (item->handlers != NULL)
+    {
+        reset_dex_encoded_catch_handler_list(item->handlers);
+        free(item->handlers);
+    }
+
+}
+
+
+
 
 
 
diff --git a/src/format/dex/dex-int.h b/src/format/dex/dex-int.h
index 5feb427..6a153c1 100755
--- a/src/format/dex/dex-int.h
+++ b/src/format/dex/dex-int.h
@@ -61,6 +61,12 @@ struct _GDexFormatClass
 /* Retrouve si possible la méthode associée à une adresse. */
 GDexMethod *g_dex_format_find_method_by_address(const GDexFormat *, vmpa_t);
 
+/* Dénombre le nombre de classes trouvées. */
+size_t g_dex_format_count_classes(const GDexFormat *);
+
+/* Fournit une classe du format chargée en mémoire. */
+GDexClass *g_dex_format_get_class(const GDexFormat *, size_t);
+
 
 
 /* ------------------------ ELEMENTS DE TABLE DES CONSTANTES ------------------------ */
@@ -112,9 +118,33 @@ void reset_dex_class_data_item(class_data_item *);
 
 
 
+/* --------------------------- PORTION DE CODE EXECUTABLE --------------------------- */
+
+
+/* Procède à la lecture d'une association exception <-> code. */
+bool read_dex_encoded_type_addr_pair(const GDexFormat *, off_t *, encoded_type_addr_pair *);
+
+/* Procède à la lecture d'une association exception <-> code. */
+bool read_dex_encoded_catch_handler(const GDexFormat *, off_t *, encoded_catch_handler *);
+
+/* Supprime tous les éléments chargés en mémoire à la lecture. */
+void reset_dex_encoded_catch_handler(encoded_catch_handler *);
+
+/* Procède à la lecture d'une association exception <-> code. */
+bool read_dex_encoded_catch_handler_list(const GDexFormat *, off_t *, encoded_catch_handler_list *);
+
+/* Supprime tous les éléments chargés en mémoire à la lecture. */
+void reset_dex_encoded_catch_handler_list(encoded_catch_handler_list *);
+
+/* Procède à la lecture d'une association exception <-> code. */
+bool read_dex_try_item(const GDexFormat *, off_t *, try_item *);
+
 /* Procède à la lecture d'une portion de code DEX. */
 bool read_dex_code_item(const GDexFormat *, off_t *, code_item *);
 
+/* Supprime tous les éléments chargés en mémoire à la lecture. */
+void reset_dex_code_item(code_item *);
+
 
 
 
diff --git a/src/format/dex/dex.c b/src/format/dex/dex.c
index f0fb421..841f72f 100755
--- a/src/format/dex/dex.c
+++ b/src/format/dex/dex.c
@@ -2,7 +2,7 @@
 /* OpenIDA - Outil d'analyse de fichiers binaires
  * dex.c - support du format DEX
  *
- * Copyright (C) 2010-2011 Cyrille Bagard
+ * Copyright (C) 2010-2012 Cyrille Bagard
  *
  *  This file is part of OpenIDA.
  *
@@ -450,3 +450,42 @@ static bool g_dex_format_translate_offset_into_address(const GDexFormat *format,
     return result;
 
 }
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = description de l'exécutable à consulter.            *
+*                                                                             *
+*  Description : Dénombre le nombre de classes trouvées.                      *
+*                                                                             *
+*  Retour      : Quantité de classes présentes.                               *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_dex_format_count_classes(const GDexFormat *format)
+{
+    return format->classes_count;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : format = description de l'exécutable à consulter.            *
+*                index  = indice de la classe visée.                          *
+*                                                                             *
+*  Description : Fournit une classe du format chargée en mémoire.             *
+*                                                                             *
+*  Retour      : Instance représentant une classe chargée.                    *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GDexClass *g_dex_format_get_class(const GDexFormat *format, size_t index)
+{
+    return format->classes[index];
+
+}
diff --git a/src/format/dex/dex.h b/src/format/dex/dex.h
index cfa72c1..9b769c2 100755
--- a/src/format/dex/dex.h
+++ b/src/format/dex/dex.h
@@ -2,7 +2,7 @@
 /* OpenIDA - Outil d'analyse de fichiers binaires
  * dex.h - prototypes pour le support du format DEX
  *
- * Copyright (C) 2010 Cyrille Bagard
+ * Copyright (C) 2010-2012 Cyrille Bagard
  *
  *  This file is part of OpenIDA.
  *
diff --git a/src/format/dex/dex_def.h b/src/format/dex/dex_def.h
index ba88d69..d21ac15 100755
--- a/src/format/dex/dex_def.h
+++ b/src/format/dex/dex_def.h
@@ -179,6 +179,49 @@ typedef struct _class_data_item
 /* --------------------------- PORTION DE CODE EXECUTABLE --------------------------- */
 
 
+/* Exception gérée */
+typedef struct _encoded_type_addr_pair
+{
+    uleb128_t type_idx;                     /* Type d'exception couverte   */
+    uleb128_t addr;                         /* Adresse du début du code    */
+
+} encoded_type_addr_pair;
+
+/* Ensemble d'exceptions prises en compte */
+typedef struct _encoded_catch_handler
+{
+    leb128_t size;                          /* Quantité d'exceptions       */
+    encoded_type_addr_pair *handlers;       /* Gestionnaires explicites    */
+    uleb128_t catch_all_addr;               /* Adresse par défaut          */
+
+    /**
+     * Note : les spécifications indiquent que le champ handler_off de
+     * try_item renvoie vers le gestionnaire à partir de la base de la structure
+     * encoded_catch_handler_list. Comme la représentation interne de cette
+     * structure efface la représentation physique, on conserve en mémoire
+     * le décalage rencontré à la lecture dans un champ artificiel.
+     */
+    off_t offset;                           /* Position dans le binaire    */
+
+} encoded_catch_handler;
+
+/* Liste des différents gestionnaires d'exceptions */
+typedef struct _encoded_catch_handler_list
+{
+    uleb128_t size;                         /* Taille de la liste          */
+    encoded_catch_handler *list;            /* Gestionnaires en place      */
+
+} encoded_catch_handler_list;
+
+/* Zone couverte en cas de pépin */
+typedef struct _try_item
+{
+    uint32_t start_addr;                    /* Adresse du début couvert    */
+    uint16_t insn_count;                    /* Nbre de doubles-octets gérés*/
+    uint16_t handler_off;                   /* Indice du gestionnaire      */
+
+} try_item;
+
 /* Description de la zone */
 typedef struct _code_item
 {
@@ -190,13 +233,13 @@ typedef struct _code_item
     uint32_t insns_size;                    /* Nbre de blocs de 2 octets   */
 
     uint16_t *insns;                        /* Code exécutable             */
-
+    try_item *tries;                        /* Zone d'exceptions           */
+    encoded_catch_handler_list *handlers;   /* Gestionnaires associés      */
 
 } code_item;
 
 
 
-
 /* -------------------------- DESCRIPTION DU FORMAT DALVIK -------------------------- */
 
 
diff --git a/src/format/dex/method.c b/src/format/dex/method.c
index 25145f5..6ea9697 100644
--- a/src/format/dex/method.c
+++ b/src/format/dex/method.c
@@ -147,7 +147,9 @@ GDexMethod *g_dex_method_new(const GDexFormat *format, const encoded_method *see
     result->info = *seed;
     result->body = item;
 
-    //printf(" ==== %s ====\n", g_binary_routine_get_name(routine));
+    //printf(" ==== (%p) %s ====\n", routine, g_binary_routine_to_string(routine));
+
+    //printf(" try ? %d\n", item.tries_size);
 
     //printf(" method idx :: %d\n", seed->method_idx_diff);
     //printf(" code size  :: %d\n", item.insns_size);
@@ -180,6 +182,44 @@ GDexMethod *g_dex_method_new(const GDexFormat *format, const encoded_method *see
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : method = représentation interne de la méthode à consulter.   *
+*                                                                             *
+*  Description : Fournit les indications Dex concernant la méthode.           *
+*                                                                             *
+*  Retour      : Données brutes du binaire.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const encoded_method *g_dex_method_get_dex_info(const GDexMethod *method)
+{
+    return &method->info;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : method = représentation interne de la méthode à consulter.   *
+*                                                                             *
+*  Description : Fournit les indications Dex relatives au corps de la méthode.*
+*                                                                             *
+*  Retour      : Données brutes du binaire.                                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+const code_item *g_dex_method_get_dex_body(const GDexMethod *method)
+{
+    return &method->body;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : method = représentation interne du format DEX à consulter.   *
 *                                                                             *
 *  Description : Fournit la routine OpenIDA correspondant à la méthode.       *
@@ -272,7 +312,7 @@ DexVariableIndex g_dex_method_get_variable(const GDexMethod *method, uint32_t in
 
     pivot = body->registers_size - body->ins_size;
 
-    if (!(method->info.access_flags & ACC_STATIC))
+    if (!(info->access_flags & ACC_STATIC))
         pivot++;
 
     if (index >= pivot)
@@ -280,7 +320,7 @@ DexVariableIndex g_dex_method_get_variable(const GDexMethod *method, uint32_t in
 
     /* S'agit-il de "this" ? */
 
-    if (!(method->info.access_flags & ACC_STATIC)
+    if (!(info->access_flags & ACC_STATIC)
         && index == (body->registers_size - body->ins_size))
         return DVI_THIS;
 
diff --git a/src/format/dex/method.h b/src/format/dex/method.h
index c06df73..33f23b1 100644
--- a/src/format/dex/method.h
+++ b/src/format/dex/method.h
@@ -69,6 +69,12 @@ GType g_dex_method_get_type(void);
 /* Crée une nouvelle représentation de methode issue de code. */
 GDexMethod *g_dex_method_new(const GDexFormat *, const encoded_method *, uleb128_t *);
 
+/* Fournit les indications Dex concernant la méthode. */
+const encoded_method *g_dex_method_get_dex_info(const GDexMethod *);
+
+/* Fournit les indications Dex relatives au corps de la méthode. */
+const code_item *g_dex_method_get_dex_body(const GDexMethod *);
+
 /* Fournit la routine OpenIDA correspondant à la méthode. */
 GBinRoutine *g_dex_method_get_routine(const GDexMethod *);