summaryrefslogtreecommitdiff
path: root/plugins/dalvik/operands/pool.c
diff options
context:
space:
mode:
Diffstat (limited to 'plugins/dalvik/operands/pool.c')
-rw-r--r--plugins/dalvik/operands/pool.c404
1 files changed, 252 insertions, 152 deletions
diff --git a/plugins/dalvik/operands/pool.c b/plugins/dalvik/operands/pool.c
index acec518..4570c86 100644
--- a/plugins/dalvik/operands/pool.c
+++ b/plugins/dalvik/operands/pool.c
@@ -39,13 +39,25 @@
+/* -------------------------- DEFINITION D'UN NOUVEAU TYPE -------------------------- */
+
+
+/* Informations glissées dans la structure GObject de GArchOperand */
+typedef struct _dpoolop_extra_data_t
+{
+ operand_extra_data_t parent; /* A laisser en premier */
+
+ DalvikPoolType type; /* Type de table visée */
+
+} dpoolop_extra_data_t;
+
+
/* Définition d'un opérande visant un élément de table de constantes Dalvik (instance) */
struct _GDalvikPoolOperand
{
GArchOperand parent; /* Instance parente */
GDexFormat *format; /* Lien vers le contenu réel */
- DalvikPoolType type; /* Type de table visée */
uint32_t index; /* Indice de l'élément visé */
};
@@ -59,6 +71,21 @@ struct _GDalvikPoolOperandClass
};
+/**
+ * Accès aux informations éventuellement déportées.
+ */
+
+#if __SIZEOF_INT__ == __SIZEOF_LONG__
+
+# define GET_DALVIK_POOL_OP_EXTRA(op) (dpoolop_extra_data_t *)&op->extra
+
+#else
+
+# define GET_DALVIK_POOL_OP_EXTRA(op) GET_GOBJECT_EXTRA(G_OBJECT(op), dpoolop_extra_data_t)
+
+#endif
+
+
/* Initialise la classe des opérandes de constante Dalvik. */
static void g_dalvik_pool_operand_class_init(GDalvikPoolOperandClass *);
@@ -74,30 +101,28 @@ static void g_dalvik_pool_operand_dispose(GDalvikPoolOperand *);
/* Procède à la libération totale de la mémoire. */
static void g_dalvik_pool_operand_finalize(GDalvikPoolOperand *);
-/* Compare un opérande avec un autre. */
-static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *, const GDalvikPoolOperand *, bool);
+/* Indique la nature de la table de constantes visée ici. */
+static DalvikPoolType _g_dalvik_pool_operand_get_pool_type(const GDalvikPoolOperand *, bool);
-/* Traduit un opérande en version humainement lisible. */
-static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *, GBufferLine *);
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
-/* ------------------------ CONTROLE DU VOLUME DES INSTANCES ------------------------ */
+/* Compare un opérande avec un autre. */
+static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *, const GDalvikPoolOperand *, bool);
+
+/* Traduit un opérande en version humainement lisible. */
+static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *, GBufferLine *);
/* Fournit l'empreinte d'un candidat à une centralisation. */
static guint g_dalvik_pool_operand_hash(const GDalvikPoolOperand *, bool);
+/* Charge un contenu depuis une mémoire tampon. */
+static bool g_dalvik_pool_operand_load(GDalvikPoolOperand *, GObjectStorage *, packed_buffer_t *);
-
-/* --------------------- TRANSPOSITIONS VIA CACHE DES OPERANDES --------------------- */
-
-
-/* Charge un opérande depuis une mémoire tampon. */
-static bool g_dalvik_pool_operand_unserialize(GDalvikPoolOperand *, GAsmStorage *, GBinFormat *, packed_buffer_t *);
-
-/* Sauvegarde un opérande dans une mémoire tampon. */
-static bool g_dalvik_pool_operand_serialize(const GDalvikPoolOperand *, GAsmStorage *, packed_buffer_t *);
+/* Sauvegarde un contenu dans une mémoire tampon. */
+static bool g_dalvik_pool_operand_store(GDalvikPoolOperand *, GObjectStorage *, packed_buffer_t *);
@@ -109,6 +134,11 @@ static bool g_dalvik_pool_operand_get_addr(const GDalvikPoolOperand *, const vmp
+/* ---------------------------------------------------------------------------------- */
+/* DEFINITION D'UN NOUVEAU TYPE */
+/* ---------------------------------------------------------------------------------- */
+
+
/* Indique le type défini par la GLib pour un un élément de table de constantes Dalvik. */
G_DEFINE_TYPE_WITH_CODE(GDalvikPoolOperand, g_dalvik_pool_operand, G_TYPE_ARCH_OPERAND,
G_IMPLEMENT_INTERFACE(G_TYPE_TARGETABLE_OPERAND, g_dalvik_pool_operand_targetable_interface_init));
@@ -143,8 +173,8 @@ static void g_dalvik_pool_operand_class_init(GDalvikPoolOperandClass *klass)
operand->hash = (operand_hash_fc)g_dalvik_pool_operand_hash;
- operand->unserialize = (unserialize_operand_fc)g_dalvik_pool_operand_unserialize;
- operand->serialize = (serialize_operand_fc)g_dalvik_pool_operand_serialize;
+ operand->load = (load_operand_fc)g_dalvik_pool_operand_load;
+ operand->store = (store_operand_fc)g_dalvik_pool_operand_store;
}
@@ -201,8 +231,7 @@ static void g_dalvik_pool_operand_targetable_interface_init(GTargetableOperandIn
static void g_dalvik_pool_operand_dispose(GDalvikPoolOperand *operand)
{
- if (operand->format != NULL)
- g_object_unref(G_OBJECT(operand->format));
+ g_clear_object(&operand->format);
G_OBJECT_CLASS(g_dalvik_pool_operand_parent_class)->dispose(G_OBJECT(operand));
@@ -230,6 +259,152 @@ static void g_dalvik_pool_operand_finalize(GDalvikPoolOperand *operand)
/******************************************************************************
* *
+* Paramètres : format = format du fichier contenant le code. *
+* type = type de table visée avec la référence. *
+* content = flux de données à analyser. *
+* pos = position courante dans ce flux. [OUT] *
+* size = taille de l'opérande, et donc du registre. *
+* endian = ordre des bits dans la source. *
+* *
+* Description : Crée un opérande visant un élément constant Dalvik. *
+* *
+* Retour : Opérande mis en place. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GArchOperand *g_dalvik_pool_operand_new(GDexFormat *format, DalvikPoolType type, const GBinContent *content, vmpa2t *pos, MemoryDataSize size, SourceEndian endian)
+{
+ GDalvikPoolOperand *result; /* Structure à retourner */
+ uint16_t index16; /* Indice sur 16 bits */
+ uint32_t index32; /* Indice sur 32 bits */
+ bool test; /* Bilan de lecture */
+ dpoolop_extra_data_t *extra; /* Données insérées à modifier */
+
+ switch (size)
+ {
+ case MDS_16_BITS:
+ test = g_binary_content_read_u16(content, pos, endian, &index16);
+ break;
+ case MDS_32_BITS:
+ test = g_binary_content_read_u32(content, pos, endian, &index32);
+ break;
+ default:
+ test = false;
+ break;
+ }
+
+ if (!test)
+ goto gdpon_exit;
+
+ result = g_object_new(G_TYPE_DALVIK_POOL_OPERAND, NULL);
+
+ extra = GET_DALVIK_POOL_OP_EXTRA(result);
+
+ extra->type = type;
+
+ result->format = format;
+ g_object_ref(G_OBJECT(format));
+
+ result->index = (size == MDS_16_BITS ? index16 : index32);
+
+ return G_ARCH_OPERAND(result);
+
+ gdpon_exit:
+
+ return NULL;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = opérande à consulter. *
+* lock = précise le besoin en verrouillage. *
+* *
+* Description : Indique la nature de la table de constantes visée ici. *
+* *
+* Retour : Type de table constantes visée. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static DalvikPoolType _g_dalvik_pool_operand_get_pool_type(const GDalvikPoolOperand *operand, bool lock)
+{
+ DalvikPoolType result; /* Type à retourner */
+ dpoolop_extra_data_t *extra; /* Données insérées à consulter*/
+
+ extra = GET_DALVIK_POOL_OP_EXTRA(operand);
+
+ if (lock)
+ LOCK_GOBJECT_EXTRA(extra);
+
+ result = extra->type;
+
+ if (lock)
+ UNLOCK_GOBJECT_EXTRA(extra);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = opérande à consulter. *
+* *
+* Description : Indique la nature de la table de constantes visée ici. *
+* *
+* Retour : Type de table constantes visée. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+DalvikPoolType g_dalvik_pool_operand_get_pool_type(const GDalvikPoolOperand *operand)
+{
+ DalvikPoolType result; /* Type à retourner */
+
+ result = _g_dalvik_pool_operand_get_pool_type(operand, true);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : operand = opérande à consulter. *
+* *
+* Description : Indique l'indice de l'élément dans la table de constantes. *
+* *
+* Retour : Indice de l'élément visé dans la table de constantes. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+uint32_t g_dalvik_pool_operand_get_index(const GDalvikPoolOperand *operand)
+{
+ uint32_t result; /* Indice à retourner */
+
+ result = operand->index;
+
+ return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/* IMPLEMENTATION DES FONCTIONS DE CLASSE */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+* *
* Paramètres : a = premier opérande à consulter. *
* b = second opérande à consulter. *
* lock = précise le besoin en verrouillage. *
@@ -245,12 +420,12 @@ static void g_dalvik_pool_operand_finalize(GDalvikPoolOperand *operand)
static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *a, const GDalvikPoolOperand *b, bool lock)
{
int result; /* Bilan à renvoyer */
- lockable_obj_extra_t *ea; /* Données insérées à consulter*/
- lockable_obj_extra_t *eb; /* Données insérées à consulter*/
+ dpoolop_extra_data_t *ea; /* Données insérées à consulter*/
+ dpoolop_extra_data_t *eb; /* Données insérées à consulter*/
GArchOperandClass *class; /* Classe parente normalisée */
- ea = GET_GOBJECT_EXTRA(G_OBJECT(a), lockable_obj_extra_t);
- eb = GET_GOBJECT_EXTRA(G_OBJECT(b), lockable_obj_extra_t);
+ ea = GET_DALVIK_POOL_OP_EXTRA(a);
+ eb = GET_DALVIK_POOL_OP_EXTRA(b);
if (lock)
{
@@ -261,7 +436,7 @@ static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *a, const GDal
result = sort_unsigned_long((unsigned long)a->format, (unsigned long)b->format);
if (result == 0)
- result = sort_unsigned_long(a->type, b->type);
+ result = sort_unsigned_long(ea->type, eb->type);
if (result == 0)
result = sort_unsigned_long(a->index, b->index);
@@ -299,6 +474,7 @@ static int g_dalvik_pool_operand_compare(const GDalvikPoolOperand *a, const GDal
static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *operand, GBufferLine *line)
{
GDexPool *pool; /* Table de ressources */
+ DalvikPoolType pool_type; /* Type de table visé */
const char *string; /* Chaîne de caractères #1 */
GDataType *type; /* Type à représenter */
size_t len; /* Taille du texte à créer */
@@ -309,7 +485,9 @@ static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *operand, GBuff
pool = g_dex_format_get_pool(operand->format);
- switch (operand->type)
+ pool_type = g_dalvik_pool_operand_get_pool_type(operand);
+
+ switch (pool_type)
{
case DPT_NONE:
g_buffer_line_append_text(line, DLC_ASSEMBLY, "????", 4, RTT_ERROR, NULL);
@@ -470,107 +648,6 @@ static void g_dalvik_pool_operand_print(const GDalvikPoolOperand *operand, GBuff
/******************************************************************************
* *
-* Paramètres : format = format du fichier contenant le code. *
-* type = type de table visée avec la référence. *
-* content = flux de données à analyser. *
-* pos = position courante dans ce flux. [OUT] *
-* size = taille de l'opérande, et donc du registre. *
-* endian = ordre des bits dans la source. *
-* *
-* Description : Crée un opérande visant un élément constant Dalvik. *
-* *
-* Retour : Opérande mis en place. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-GArchOperand *g_dalvik_pool_operand_new(GDexFormat *format, DalvikPoolType type, const GBinContent *content, vmpa2t *pos, MemoryDataSize size, SourceEndian endian)
-{
- GDalvikPoolOperand *result; /* Structure à retourner */
- uint16_t index16; /* Indice sur 16 bits */
- uint32_t index32; /* Indice sur 32 bits */
- bool test; /* Bilan de lecture */
-
- switch (size)
- {
- case MDS_16_BITS:
- test = g_binary_content_read_u16(content, pos, endian, &index16);
- break;
- case MDS_32_BITS:
- test = g_binary_content_read_u32(content, pos, endian, &index32);
- break;
- default:
- test = false;
- break;
- }
-
- if (!test)
- goto gdpon_exit;
-
- result = g_object_new(G_TYPE_DALVIK_POOL_OPERAND, NULL);
-
- g_object_ref(G_OBJECT(format));
-
- result->format = format;
- result->type = type;
- result->index = (size == MDS_16_BITS ? index16 : index32);
-
- return G_ARCH_OPERAND(result);
-
- gdpon_exit:
-
- return NULL;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : operand = opérande à consulter. *
-* *
-* Description : Indique la nature de la table de constantes visée ici. *
-* *
-* Retour : Type de table constantes visée. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-DalvikPoolType g_dalvik_pool_operand_get_pool_type(const GDalvikPoolOperand *operand)
-{
- return operand->type;
-
-}
-
-
-/******************************************************************************
-* *
-* Paramètres : operand = opérande à consulter. *
-* *
-* Description : Indique l'indice de l'élément dans la table de constantes. *
-* *
-* Retour : Indice de l'élément visé dans la table de constantes. *
-* *
-* Remarques : - *
-* *
-******************************************************************************/
-
-uint32_t g_dalvik_pool_operand_get_index(const GDalvikPoolOperand *operand)
-{
- return operand->index;
-
-}
-
-
-
-/* ---------------------------------------------------------------------------------- */
-/* CONTROLE DU VOLUME DES INSTANCES */
-/* ---------------------------------------------------------------------------------- */
-
-
-/******************************************************************************
-* *
* Paramètres : operand = objet dont l'instance se veut unique. *
* lock = précise le besoin en verrouillage. *
* *
@@ -600,7 +677,7 @@ static guint g_dalvik_pool_operand_hash(const GDalvikPoolOperand *operand, bool
result ^= g_direct_hash(operand->format);
- type = g_dalvik_pool_operand_get_pool_type(operand);
+ type = _g_dalvik_pool_operand_get_pool_type(operand, !lock);
result ^= type;
@@ -616,20 +693,13 @@ static guint g_dalvik_pool_operand_hash(const GDalvikPoolOperand *operand, bool
}
-
-/* ---------------------------------------------------------------------------------- */
-/* TRANSPOSITIONS VIA CACHE DES OPERANDES */
-/* ---------------------------------------------------------------------------------- */
-
-
/******************************************************************************
* *
-* Paramètres : operand = opérande d'assemblage à constituer. *
-* storage = mécanisme de sauvegarde à manipuler. *
-* format = format binaire chargé associé à l'architecture. *
-* pbuf = zone tampon à remplir. *
+* Paramètres : operand = élément GLib à constuire. *
+* storage = conservateur de données à manipuler ou NULL. *
+* pbuf = zone tampon à lire. *
* *
-* Description : Charge un opérande depuis une mémoire tampon. *
+* Description : Charge un contenu depuis une mémoire tampon. *
* *
* Retour : Bilan de l'opération. *
* *
@@ -637,26 +707,43 @@ static guint g_dalvik_pool_operand_hash(const GDalvikPoolOperand *operand, bool
* *
******************************************************************************/
-static bool g_dalvik_pool_operand_unserialize(GDalvikPoolOperand *operand, GAsmStorage *storage, GBinFormat *format, packed_buffer_t *pbuf)
+static bool g_dalvik_pool_operand_load(GDalvikPoolOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
{
bool result; /* Bilan à retourner */
GArchOperandClass *parent; /* Classe parente à consulter */
+ dpoolop_extra_data_t *extra; /* Données insérées à modifier */
+ uleb128_t value; /* Valeur ULEB128 à charger */
parent = G_ARCH_OPERAND_CLASS(g_dalvik_pool_operand_parent_class);
- result = parent->unserialize(G_ARCH_OPERAND(operand), storage, format, pbuf);
+ result = parent->load(G_ARCH_OPERAND(operand), storage, pbuf);
+
+ if (result)
+ {
+ extra = GET_DALVIK_POOL_OP_EXTRA(operand);
+
+ LOCK_GOBJECT_EXTRA(extra);
+
+ result = unpack_uleb128(&value, pbuf);
+
+ if (result)
+ extra->type = value;
+
+ UNLOCK_GOBJECT_EXTRA(extra);
+
+ }
if (result)
{
- operand->format = G_DEX_FORMAT(format);
- g_object_ref(G_OBJECT(format));
+ operand->format = get_storage_linked_format(storage);
+ result = G_IS_DEX_FORMAT(operand->format);
}
if (result)
- result = extract_packed_buffer(pbuf, &operand->type, sizeof(DalvikPoolType), true);
+ result = unpack_uleb128(&value, pbuf);
if (result)
- result = extract_packed_buffer(pbuf, &operand->index, sizeof(uint32_t), true);
+ operand->index = value;
return result;
@@ -665,11 +752,11 @@ static bool g_dalvik_pool_operand_unserialize(GDalvikPoolOperand *operand, GAsmS
/******************************************************************************
* *
-* Paramètres : operand = opérande d'assemblage à consulter. *
-* storage = mécanisme de sauvegarde à manipuler. *
+* Paramètres : operand = élément GLib à consulter. *
+* storage = conservateur de données à manipuler ou NULL. *
* pbuf = zone tampon à remplir. *
* *
-* Description : Sauvegarde un opérande dans une mémoire tampon. *
+* Description : Sauvegarde un contenu dans une mémoire tampon. *
* *
* Retour : Bilan de l'opération. *
* *
@@ -677,20 +764,30 @@ static bool g_dalvik_pool_operand_unserialize(GDalvikPoolOperand *operand, GAsmS
* *
******************************************************************************/
-static bool g_dalvik_pool_operand_serialize(const GDalvikPoolOperand *operand, GAsmStorage *storage, packed_buffer_t *pbuf)
+static bool g_dalvik_pool_operand_store(GDalvikPoolOperand *operand, GObjectStorage *storage, packed_buffer_t *pbuf)
{
bool result; /* Bilan à retourner */
GArchOperandClass *parent; /* Classe parente à consulter */
+ dpoolop_extra_data_t *extra; /* Données insérées à modifier */
parent = G_ARCH_OPERAND_CLASS(g_dalvik_pool_operand_parent_class);
- result = parent->serialize(G_ARCH_OPERAND(operand), storage, pbuf);
+ result = parent->store(G_ARCH_OPERAND(operand), storage, pbuf);
if (result)
- result = extend_packed_buffer(pbuf, &operand->type, sizeof(DalvikPoolType), true);
+ {
+ extra = GET_DALVIK_POOL_OP_EXTRA(operand);
+
+ LOCK_GOBJECT_EXTRA(extra);
+
+ result = pack_uleb128((uleb128_t []){ extra->type }, pbuf);
+
+ UNLOCK_GOBJECT_EXTRA(extra);
+
+ }
if (result)
- result = extend_packed_buffer(pbuf, &operand->index, sizeof(uint32_t), true);
+ result = pack_uleb128((uleb128_t []){ operand->index }, pbuf);
return result;
@@ -722,6 +819,7 @@ static bool g_dalvik_pool_operand_serialize(const GDalvikPoolOperand *operand, G
static bool g_dalvik_pool_operand_get_addr(const GDalvikPoolOperand *operand, const vmpa2t *src, GBinFormat *format, GArchProcessor *proc, vmpa2t *addr)
{
bool result; /* Bilan à retourner */
+ DalvikPoolType type; /* Type de table visé */
GDexPool *pool; /* Table de ressources */
GDexMethod *method; /* Méthode ciblée ici */
GBinRoutine *routine; /* Routine liée à la méthode */
@@ -729,7 +827,9 @@ static bool g_dalvik_pool_operand_get_addr(const GDalvikPoolOperand *operand, co
result = false;
- if (operand->type == DPT_METHOD)
+ type = g_dalvik_pool_operand_get_pool_type(operand);
+
+ if (type == DPT_METHOD)
{
pool = g_dex_format_get_pool(G_DEX_FORMAT(format));
generated by cgit v0.11.2-87-g4458 at 2024-04-19 20:33:06 (GMT)