summaryrefslogtreecommitdiff
path: root/src/analysis/contents
diff options
context:
space:
mode:
Diffstat (limited to 'src/analysis/contents')
-rwxr-xr-xsrc/analysis/contents/Makefile.am2
-rw-r--r--src/analysis/contents/encapsulated.c747
-rw-r--r--src/analysis/contents/encapsulated.h61
-rw-r--r--src/analysis/contents/file.c43
-rw-r--r--src/analysis/contents/file.h12
-rw-r--r--src/analysis/contents/memory.c758
-rw-r--r--src/analysis/contents/memory.h61
7 files changed, 1664 insertions, 20 deletions
diff --git a/src/analysis/contents/Makefile.am b/src/analysis/contents/Makefile.am
index 2580357..a7de73f 100755
--- a/src/analysis/contents/Makefile.am
+++ b/src/analysis/contents/Makefile.am
@@ -2,7 +2,9 @@
noinst_LTLIBRARIES = libanalysiscontents.la
libanalysiscontents_la_SOURCES = \
+ encapsulated.h encapsulated.c \
file.h file.c \
+ memory.h memory.c \
restricted.h restricted.c
libanalysiscontents_la_LIBADD =
diff --git a/src/analysis/contents/encapsulated.c b/src/analysis/contents/encapsulated.c
new file mode 100644
index 0000000..1fd4203
--- /dev/null
+++ b/src/analysis/contents/encapsulated.c
@@ -0,0 +1,747 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * encapsulated.c - chargement de données binaires à partir d'un fichier
+ *
+ * Copyright (C) 2018 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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 Chrysalide. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "encapsulated.h"
+
+
+#include <malloc.h>
+#include <string.h>
+
+
+#include "../content-int.h"
+#include "../../common/extstr.h"
+
+
+
+/* Contenu de issu d'un contenu plus global (instance) */
+struct _GEncapsContent
+{
+ GObject parent; /* A laisser en premier */
+
+ GBinContent *base; /* Base offrant une extraction */
+ char *path; /* Chemin vers le contenu ciblé*/
+ GBinContent *endpoint; /* Contenu ciblé */
+
+ char *full_desc; /* Description de l'ensemble */
+ char *desc; /* Description de l'ensemble */
+
+};
+
+/* Contenu de issu d'un contenu plus global (classe) */
+struct _GEncapsContentClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des contenus de données encapsulés. */
+static void g_encaps_content_class_init(GEncapsContentClass *);
+
+/* Initialise une instance de contenu de données encapsulé. */
+static void g_encaps_content_init(GEncapsContent *);
+
+/* Procède à l'initialisation de l'interface de lecture. */
+static void g_encaps_content_interface_init(GBinContentInterface *);
+
+/* Supprime toutes les références externes. */
+static void g_encaps_content_dispose(GEncapsContent *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_encaps_content_finalize(GEncapsContent *);
+
+/* Fournit le nom associé au contenu binaire. */
+static const char *g_encaps_content_describe(const GEncapsContent *, bool);
+
+/* Ecrit une sauvegarde de contenu binaire dans un fichier XML. */
+static bool g_encaps_content_save(const GEncapsContent *, xmlDocPtr, xmlXPathContextPtr, const char *, const char *);
+
+/* Fournit une empreinte unique (SHA256) pour les données. */
+static void g_encaps_content_compute_checksum(GEncapsContent *, GChecksum *);
+
+/* Détermine le nombre d'octets lisibles. */
+static phys_t g_encaps_content_compute_size(const GEncapsContent *);
+
+/* Avance la tête de lecture d'une certaine quantité de données. */
+static bool g_encaps_content_seek(const GEncapsContent *, vmpa2t *, phys_t);
+
+/* Donne accès à une portion des données représentées. */
+static const bin_t *g_encaps_content_get_raw_access(const GEncapsContent *, vmpa2t *, phys_t);
+
+/* Fournit une portion des données représentées. */
+static bool g_encaps_content_read_raw(const GEncapsContent *, vmpa2t *, phys_t, bin_t *);
+
+/* Lit un nombre non signé sur quatre bits. */
+static bool g_encaps_content_read_u4(const GEncapsContent *, vmpa2t *, bool *, uint8_t *);
+
+/* Lit un nombre non signé sur un octet. */
+static bool g_encaps_content_read_u8(const GEncapsContent *, vmpa2t *, uint8_t *);
+
+/* Lit un nombre non signé sur deux octets. */
+static bool g_encaps_content_read_u16(const GEncapsContent *, vmpa2t *, SourceEndian, uint16_t *);
+
+/* Lit un nombre non signé sur quatre octets. */
+static bool g_encaps_content_read_u32(const GEncapsContent *, vmpa2t *, SourceEndian, uint32_t *);
+
+/* Lit un nombre non signé sur huit octets. */
+static bool g_encaps_content_read_u64(const GEncapsContent *, vmpa2t *, SourceEndian, uint64_t *);
+
+/* Lit un nombre non signé encodé au format LEB128. */
+static bool g_encaps_content_read_uleb128(const GEncapsContent *, vmpa2t *, uleb128_t *);
+
+/* Lit un nombre signé encodé au format LEB128. */
+static bool g_encaps_content_read_leb128(const GEncapsContent *, vmpa2t *, leb128_t *);
+
+
+
+/* Indique le type défini par la GLib pour les contenus encapsulés. */
+G_DEFINE_TYPE_WITH_CODE(GEncapsContent, g_encaps_content, G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE(G_TYPE_BIN_CONTENT, g_encaps_content_interface_init));
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des contenus de données encapsulés. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_encaps_content_class_init(GEncapsContentClass *klass)
+{
+ GObjectClass *object; /* Autre version de la classe */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_encaps_content_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_encaps_content_finalize;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = instance à initialiser. *
+* *
+* Description : Initialise une instance de contenu de données encapsulé. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_encaps_content_init(GEncapsContent *content)
+{
+ content->base = NULL;
+ content->path = NULL;
+ content->endpoint = NULL;
+
+ content->full_desc = NULL;
+ content->desc = NULL;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : iface = interface GLib à initialiser. *
+* *
+* Description : Procède à l'initialisation de l'interface de lecture. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_encaps_content_interface_init(GBinContentInterface *iface)
+{
+ iface->describe = (describe_content_fc)g_encaps_content_describe;
+
+ iface->save = (save_content_fc)g_encaps_content_save;
+
+ iface->compute_checksum = (compute_checksum_fc)g_encaps_content_compute_checksum;
+
+ iface->compute_size = (compute_size_fc)g_encaps_content_compute_size;
+
+ iface->seek = (seek_fc)g_encaps_content_seek;
+
+ iface->get_raw_access = (get_raw_access_fc)g_encaps_content_get_raw_access;
+
+ iface->read_raw = (read_raw_fc)g_encaps_content_read_raw;
+ iface->read_u4 = (read_u4_fc)g_encaps_content_read_u4;
+ iface->read_u8 = (read_u8_fc)g_encaps_content_read_u8;
+ iface->read_u16 = (read_u16_fc)g_encaps_content_read_u16;
+ iface->read_u32 = (read_u32_fc)g_encaps_content_read_u32;
+ iface->read_u64 = (read_u64_fc)g_encaps_content_read_u64;
+
+ iface->read_uleb128 = (read_uleb128_fc)g_encaps_content_read_uleb128;
+ iface->read_leb128 = (read_leb128_fc)g_encaps_content_read_leb128;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_encaps_content_dispose(GEncapsContent *content)
+{
+ if (content->base != NULL)
+ g_object_unref(content->base);
+
+ if (content->endpoint != NULL)
+ g_object_unref(content->endpoint);
+
+ G_OBJECT_CLASS(g_encaps_content_parent_class)->dispose(G_OBJECT(content));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_encaps_content_finalize(GEncapsContent *content)
+{
+ if (content->desc != NULL)
+ free(content->desc);
+
+ if (content->full_desc != NULL)
+ free(content->full_desc);
+
+ G_OBJECT_CLASS(g_encaps_content_parent_class)->finalize(G_OBJECT(content));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : base = contenu binaire d'où réaliser une extraction. *
+* path = chemin vers le contenu finalement ciblé. *
+* endpoint = contenu final rendu accessible. *
+* *
+* Description : Charge en mémoire un contenu binaire encapsulé. *
+* *
+* Retour : Représentation de contenu à manipuler ou NULL en cas d'échec.*
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBinContent *g_encaps_content_new(GBinContent *base, const char *path, GBinContent *endpoint)
+{
+ GEncapsContent *result; /* Structure à retourner */
+
+ result = g_object_new(G_TYPE_ENCAPS_CONTENT, NULL);
+
+ result->base = base;
+ result->path = strdup(path);
+ result->endpoint = endpoint;
+
+ /* Description complète */
+
+ result->full_desc = stradd(result->full_desc, g_binary_content_describe(result->base, true));
+
+ result->full_desc = stradd(result->full_desc, G_DIR_SEPARATOR_S);
+
+ result->full_desc = stradd(result->full_desc, path);
+
+ /* Description partielle */
+
+ result->desc = strdup(path);
+
+ return G_BIN_CONTENT(result);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : context = contexte pour les recherches XPath. *
+* path = chemin d'accès au noeud XML à lire. *
+* base = référence au lieu d'enregistrement du projet. *
+* *
+* Description : Charge en mémoire un contenu encapsulé à partir d'XML. *
+* *
+* Retour : Adresse de la représentation ou NULL en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBinContent *g_encaps_content_new_from_xml(xmlXPathContextPtr context, const char *path, const char *base)
+{
+ GBinContent *result; /* Adresse à retourner */
+ char *access; /* Chemin d'accès à un élément */
+ GBinContent *original; /* Base offrant une extraction */
+ char *target; /* Chemin vers le contenu ciblé*/
+ GBinContent *endpoint; /* Contenu ciblé */
+
+ result = NULL;
+
+ /* Base de l'extraction */
+
+ access = strdup(path);
+ access = stradd(access, "/Base");
+
+ original = g_binary_content_new_from_xml(context, access, base);
+
+ free(access);
+
+ /* Référence au contenu encapsulé */
+
+ if (original != NULL)
+ {
+ access = strdup(path);
+ access = stradd(access, "/Path");
+
+ target = get_node_text_value(context, access);
+
+ if (target != NULL)
+ {
+ endpoint = NULL;/// TODO
+
+ if (endpoint != NULL)
+ result = g_encaps_content_new(original, target, endpoint);
+
+ else
+ g_object_unref(G_OBJECT(original));
+
+ }
+ else
+ g_object_unref(G_OBJECT(original));
+
+
+ free(target);
+ free(access);
+
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à consulter. *
+* full = précise s'il s'agit d'une version longue ou non. *
+* *
+* Description : Fournit le nom associé au contenu binaire. *
+* *
+* Retour : Nom de fichier avec chemin absolu au besoin. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static const char *g_encaps_content_describe(const GEncapsContent *content, bool full)
+{
+ const char *result; /* Description à retourner */
+
+ if (full)
+ result = content->full_desc;
+ else
+ result = content->desc;
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à traiter. *
+* xdoc = structure XML en cours d'édition. *
+* context = contexte à utiliser pour les recherches. *
+* path = chemin d'accès réservé au binaire. *
+* base = référence au lieu d'enregistrement du projet. *
+* *
+* Description : Ecrit une sauvegarde de contenu binaire dans un fichier XML. *
+* *
+* Retour : true si l'opération a bien tourné, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_encaps_content_save(const GEncapsContent *content, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path, const char *base)
+{
+ bool result; /* Bilan à faire remonter */
+ char *access; /* Chemin d'accès à un élément */
+
+ /* Type */
+
+ result = add_string_attribute_to_node(xdoc, context, path, "type", "encaps");
+ if (!result) goto gecs_exit;
+
+ /* Base de l'extraction */
+
+ access = strdup(path);
+ access = stradd(access, "/Base");
+
+ result = g_binary_content_save(content->base, xdoc, context, access, base);
+
+ free(access);
+
+ if (!result) goto gecs_exit;
+
+ /* Référence au contenu encapsulé */
+
+ access = strdup(path);
+ access = stradd(access, "/Path");
+
+ result = add_content_to_node(xdoc, context, access, content->path);
+
+ free(access);
+
+ gecs_exit:
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* checksum = empreinte de zone mémoire à compléter. *
+* *
+* Description : Calcule une empreinte unique (SHA256) pour les données. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_encaps_content_compute_checksum(GEncapsContent *content, GChecksum *checksum)
+{
+ GBinContentIface *iface; /* Interface utilisée */
+
+ iface = G_BIN_CONTENT_GET_IFACE(content->endpoint);
+
+ iface->compute_checksum(content->endpoint, checksum);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* *
+* Description : Détermine le nombre d'octets lisibles. *
+* *
+* Retour : Quantité représentée. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static phys_t g_encaps_content_compute_size(const GEncapsContent *content)
+{
+ phys_t result; /* Quantité trouvée à retourner*/
+
+ result = g_binary_content_compute_size(content->endpoint);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* length = quantité d'octets à provisionner. *
+* *
+* Description : Avance la tête de lecture d'une certaine quantité de données.*
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_encaps_content_seek(const GEncapsContent *content, vmpa2t *addr, phys_t length)
+{
+ bool result; /* Bilan d'opération à renvoyer*/
+
+ result = g_binary_content_seek(content->endpoint, addr, length);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* length = quantité d'octets à lire. *
+* *
+* Description : Donne accès à une portion des données représentées. *
+* *
+* Retour : Pointeur vers les données à lire ou NULL en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static const bin_t *g_encaps_content_get_raw_access(const GEncapsContent *content, vmpa2t *addr, phys_t length)
+{
+ const bin_t *result; /* Accès brut à retourner */
+
+ result = g_binary_content_get_raw_access(content->endpoint, addr, length);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* length = quantité d'octets à lire. *
+* out = réceptacle disponible pour ces données. [OUT] *
+* *
+* Description : Fournit une portion des données représentées. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_encaps_content_read_raw(const GEncapsContent *content, vmpa2t *addr, phys_t length, bin_t *out)
+{
+ bool result; /* Bilan à remonter */
+
+ result = g_binary_content_read_raw(content->endpoint, addr, length, out);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* low = position éventuelle des 4 bits visés. [OUT] *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre non signé sur quatre bits. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_encaps_content_read_u4(const GEncapsContent *content, vmpa2t *addr, bool *low, uint8_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_u4(content->endpoint, addr, low, val);
+
+ return result;
+
+}
+
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre non signé sur un octet. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_encaps_content_read_u8(const GEncapsContent *content, vmpa2t *addr, uint8_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_u8(content->endpoint, addr, val);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* endian = ordre des bits dans la source. *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre non signé sur deux octets. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_encaps_content_read_u16(const GEncapsContent *content, vmpa2t *addr, SourceEndian endian, uint16_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_u16(content->endpoint, addr, endian, val);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* endian = ordre des bits dans la source. *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre non signé sur quatre octets. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_encaps_content_read_u32(const GEncapsContent *content, vmpa2t *addr, SourceEndian endian, uint32_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_u32(content->endpoint, addr, endian, val);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* endian = ordre des bits dans la source. *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre non signé sur huit octets. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_encaps_content_read_u64(const GEncapsContent *content, vmpa2t *addr, SourceEndian endian, uint64_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_u64(content->endpoint, addr, endian, val);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre non signé encodé au format LEB128. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_encaps_content_read_uleb128(const GEncapsContent *content, vmpa2t *addr, uleb128_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_uleb128(content->endpoint, addr, val);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre signé encodé au format LEB128. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_encaps_content_read_leb128(const GEncapsContent *content, vmpa2t *addr, leb128_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_leb128(content->endpoint, addr, val);
+
+ return result;
+
+}
diff --git a/src/analysis/contents/encapsulated.h b/src/analysis/contents/encapsulated.h
new file mode 100644
index 0000000..5d21a18
--- /dev/null
+++ b/src/analysis/contents/encapsulated.h
@@ -0,0 +1,61 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * encapsulated.h - prototypes pour le chargement de données binaires à partir d'un fichier
+ *
+ * Copyright (C) 2018 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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 Chrysalide. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_CONTENTS_ENCAPSULATED_H
+#define _ANALYSIS_CONTENTS_ENCAPSULATED_H
+
+
+#include <glib-object.h>
+
+
+#include "../content.h"
+
+
+
+#define G_TYPE_ENCAPS_CONTENT (g_encaps_content_get_type())
+#define G_ENCAPS_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_ENCAPS_CONTENT, GEncapsContent))
+#define G_IS_ENCAPS_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_ENCAPS_CONTENT))
+#define G_ENCAPS_CONTENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_ENCAPS_CONTENT, GEncapsContentClass))
+#define G_IS_ENCAPS_CONTENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_ENCAPS_CONTENT))
+#define G_ENCAPS_CONTENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_ENCAPS_CONTENT, GEncapsContentClass))
+
+
+/* Contenu de issu d'un contenu plus global (instance) */
+typedef struct _GEncapsContent GEncapsContent;
+
+/* Contenu de issu d'un contenu plus global (classe) */
+typedef struct _GEncapsContentClass GEncapsContentClass;
+
+
+/* Indique le type défini par la GLib pour les contenus encapsulés. */
+GType g_encaps_content_get_type(void);
+
+/* Charge en mémoire un contenu binaire encapsulé. */
+GBinContent *g_encaps_content_new(GBinContent *, const char *, GBinContent *);
+
+/* Charge en mémoire un contenu encapsulé à partir d'XML. */
+GBinContent *g_encaps_content_new_from_xml(xmlXPathContextPtr, const char *, const char *);
+
+
+
+#endif /* _ANALYSIS_CONTENTS_ENCAPSULATED_H */
diff --git a/src/analysis/contents/file.c b/src/analysis/contents/file.c
index 3519be3..31acb6f 100644
--- a/src/analysis/contents/file.c
+++ b/src/analysis/contents/file.c
@@ -354,14 +354,18 @@ GBinContent *g_file_content_new_from_xml(xmlXPathContextPtr context, const char
/* Chargement */
- absolute = build_absolute_filename(base, filename);
+ if (filename != NULL)
+ {
+ absolute = build_absolute_filename(base, filename);
- if (filename != NULL) free(filename);
+ free(filename);
+
+ if (absolute != NULL)
+ {
+ result = g_file_content_new(absolute);
+ free(absolute);
+ }
- if (absolute != NULL)
- {
- result = g_file_content_new(absolute);
- free(absolute);
}
return result;
@@ -428,11 +432,10 @@ static bool g_file_content_save(const GFileContent *content, xmlDocPtr xdoc, xml
char *access; /* Chemin d'accès à un élément */
char *relative; /* Chemin d'accès relatif */
- result = true;
-
/* Type */
- result &= add_string_attribute_to_node(xdoc, context, path, "type", "file");
+ result = add_string_attribute_to_node(xdoc, context, path, "type", "file");
+ if (!result) goto gfcs_exit;
/* Nom du fichier associé */
@@ -441,11 +444,13 @@ static bool g_file_content_save(const GFileContent *content, xmlDocPtr xdoc, xml
relative = build_relative_filename(base, content->filename);
- result &= add_content_to_node(xdoc, context, access, relative);
+ result = add_content_to_node(xdoc, context, access, relative);
free(relative);
free(access);
+ gfcs_exit:
+
return result;
}
@@ -530,19 +535,26 @@ static void g_file_content_compute_end_pos(const GFileContent *content, vmpa2t *
static bool g_file_content_seek(const GFileContent *content, vmpa2t *addr, phys_t length)
{
+ bool result; /* Bilan à retourner */
phys_t offset; /* Emplacement de départ */
+ result = false;
+
offset = get_phy_addr(addr);
if (length > get_mrange_length(&content->range))
- return false;
+ goto gfcs_done;
if (offset > (get_mrange_length(&content->range) - length))
- return false;
+ goto gfcs_done;
advance_vmpa(addr, length);
- return true;
+ result = true;
+
+ gfcs_done:
+
+ return result;
}
@@ -563,6 +575,7 @@ static bool g_file_content_seek(const GFileContent *content, vmpa2t *addr, phys_
static const bin_t *g_file_content_get_raw_access(const GFileContent *content, vmpa2t *addr, phys_t length)
{
+ const bin_t *result; /* Données utiles à renvoyer */
phys_t offset; /* Emplacement de départ */
bool allowed; /* Capacité d'avancer ? */
@@ -570,7 +583,9 @@ static const bin_t *g_file_content_get_raw_access(const GFileContent *content, v
allowed = g_file_content_seek(content, addr, length);
- return (allowed ? &content->data[offset] : NULL);
+ result = (allowed ? &content->data[offset] : NULL);
+
+ return result;
}
diff --git a/src/analysis/contents/file.h b/src/analysis/contents/file.h
index e1fc7a9..b68d466 100644
--- a/src/analysis/contents/file.h
+++ b/src/analysis/contents/file.h
@@ -32,12 +32,12 @@
-#define G_TYPE_FILE_CONTENT (g_file_content_get_type())
-#define G_FILE_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_FILE_CONTENT, GFileContent))
-#define G_IS_FILE_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_FILE_CONTENT))
-#define G_FILE_CONTENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_FILE_CONTENT, GFileContentClass))
-#define G_IS_FILE_CONTENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_FILE_CONTENT))
-#define G_FILE_CONTENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_FILE_CONTENT, GFileContentClass))
+#define G_TYPE_FILE_CONTENT (g_file_content_get_type())
+#define G_FILE_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_FILE_CONTENT, GFileContent))
+#define G_IS_FILE_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_FILE_CONTENT))
+#define G_FILE_CONTENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_FILE_CONTENT, GFileContentClass))
+#define G_IS_FILE_CONTENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_FILE_CONTENT))
+#define G_FILE_CONTENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_FILE_CONTENT, GFileContentClass))
/* Contenu de données binaires issues d'un fichier (instance) */
diff --git a/src/analysis/contents/memory.c b/src/analysis/contents/memory.c
new file mode 100644
index 0000000..a7bdbea
--- /dev/null
+++ b/src/analysis/contents/memory.c
@@ -0,0 +1,758 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * memory.c - chargement de données binaires à partir de la mémoire
+ *
+ * Copyright (C) 2018 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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 Chrysalide. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "memory.h"
+
+
+#include <assert.h>
+#include <malloc.h>
+#include <string.h>
+#include <unistd.h>
+
+
+#include <i18n.h>
+
+
+#include "file.h"
+#include "../content-int.h"
+#include "../../common/extstr.h"
+#include "../../common/io.h"
+
+
+
+/* Contenu de données binaires résidant en mémoire (instance) */
+struct _GMemoryContent
+{
+ GObject parent; /* A laisser en premier */
+
+ char *storage; /* Conservation des données */
+ GBinContent *backend; /* Exploitation des données */
+
+};
+
+/* Contenu de données binaires résidant en mémoire (classe) */
+struct _GMemoryContentClass
+{
+ GObjectClass parent; /* A laisser en premier */
+
+};
+
+
+/* Initialise la classe des contenus de données en mémoire. */
+static void g_memory_content_class_init(GMemoryContentClass *);
+
+/* Initialise une instance de contenu de données en mémoire. */
+static void g_memory_content_init(GMemoryContent *);
+
+/* Procède à l'initialisation de l'interface de lecture. */
+static void g_memory_content_interface_init(GBinContentInterface *);
+
+/* Supprime toutes les références externes. */
+static void g_memory_content_dispose(GMemoryContent *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_memory_content_finalize(GMemoryContent *);
+
+/* Fournit le nom associé au contenu binaire. */
+static const char *g_memory_content_describe(const GMemoryContent *, bool);
+
+/* Ecrit une sauvegarde de contenu binaire dans un fichier XML. */
+static bool g_memory_content_save(const GMemoryContent *, xmlDocPtr, xmlXPathContextPtr, const char *, const char *);
+
+/* Fournit une empreinte unique (SHA256) pour les données. */
+static void g_memory_content_compute_checksum(GMemoryContent *, GChecksum *);
+
+/* Détermine le nombre d'octets lisibles. */
+static phys_t g_memory_content_compute_size(const GMemoryContent *);
+
+/* Détermine la position finale d'un contenu. */
+static void g_memory_content_compute_end_pos(const GMemoryContent *, vmpa2t *);
+
+/* Avance la tête de lecture d'une certaine quantité de données. */
+static bool g_memory_content_seek(const GMemoryContent *, vmpa2t *, phys_t);
+
+/* Donne accès à une portion des données représentées. */
+static const bin_t *g_memory_content_get_raw_access(const GMemoryContent *, vmpa2t *, phys_t);
+
+/* Fournit une portion des données représentées. */
+static bool g_memory_content_read_raw(const GMemoryContent *, vmpa2t *, phys_t, bin_t *);
+
+/* Lit un nombre non signé sur quatre bits. */
+static bool g_memory_content_read_u4(const GMemoryContent *, vmpa2t *, bool *, uint8_t *);
+
+/* Lit un nombre non signé sur un octet. */
+static bool g_memory_content_read_u8(const GMemoryContent *, vmpa2t *, uint8_t *);
+
+/* Lit un nombre non signé sur deux octets. */
+static bool g_memory_content_read_u16(const GMemoryContent *, vmpa2t *, SourceEndian, uint16_t *);
+
+/* Lit un nombre non signé sur quatre octets. */
+static bool g_memory_content_read_u32(const GMemoryContent *, vmpa2t *, SourceEndian, uint32_t *);
+
+/* Lit un nombre non signé sur huit octets. */
+static bool g_memory_content_read_u64(const GMemoryContent *, vmpa2t *, SourceEndian, uint64_t *);
+
+/* Lit un nombre non signé encodé au format LEB128. */
+static bool g_memory_content_read_uleb128(const GMemoryContent *, vmpa2t *, uleb128_t *);
+
+/* Lit un nombre signé encodé au format LEB128. */
+static bool g_memory_content_read_leb128(const GMemoryContent *, vmpa2t *, leb128_t *);
+
+
+
+/* Indique le type défini par la GLib pour les contenus de données en mémoire. */
+G_DEFINE_TYPE_WITH_CODE(GMemoryContent, g_memory_content, G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE(G_TYPE_BIN_CONTENT, g_memory_content_interface_init));
+
+
+/******************************************************************************
+* *
+* Paramètres : klass = classe à initialiser. *
+* *
+* Description : Initialise la classe des contenus de données en mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_memory_content_class_init(GMemoryContentClass *klass)
+{
+ GObjectClass *object; /* Autre version de la classe */
+
+ object = G_OBJECT_CLASS(klass);
+
+ object->dispose = (GObjectFinalizeFunc/* ! */)g_memory_content_dispose;
+ object->finalize = (GObjectFinalizeFunc)g_memory_content_finalize;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = instance à initialiser. *
+* *
+* Description : Initialise une instance de contenu de données en mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_memory_content_init(GMemoryContent *content)
+{
+ content->storage = NULL;
+ content->backend = NULL;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : iface = interface GLib à initialiser. *
+* *
+* Description : Procède à l'initialisation de l'interface de lecture. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_memory_content_interface_init(GBinContentInterface *iface)
+{
+ iface->describe = (describe_content_fc)g_memory_content_describe;
+
+ iface->save = (save_content_fc)g_memory_content_save;
+
+ iface->compute_checksum = (compute_checksum_fc)g_memory_content_compute_checksum;
+
+ iface->compute_size = (compute_size_fc)g_memory_content_compute_size;
+ iface->compute_end_pos = (compute_end_pos_fc)g_memory_content_compute_end_pos;
+
+ iface->seek = (seek_fc)g_memory_content_seek;
+
+ iface->get_raw_access = (get_raw_access_fc)g_memory_content_get_raw_access;
+
+ iface->read_raw = (read_raw_fc)g_memory_content_read_raw;
+ iface->read_u4 = (read_u4_fc)g_memory_content_read_u4;
+ iface->read_u8 = (read_u8_fc)g_memory_content_read_u8;
+ iface->read_u16 = (read_u16_fc)g_memory_content_read_u16;
+ iface->read_u32 = (read_u32_fc)g_memory_content_read_u32;
+ iface->read_u64 = (read_u64_fc)g_memory_content_read_u64;
+
+ iface->read_uleb128 = (read_uleb128_fc)g_memory_content_read_uleb128;
+ iface->read_leb128 = (read_leb128_fc)g_memory_content_read_leb128;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = instance d'objet GLib à traiter. *
+* *
+* Description : Supprime toutes les références externes. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_memory_content_dispose(GMemoryContent *content)
+{
+ if (content->backend)
+ g_object_unref(G_OBJECT(content->backend));
+
+ G_OBJECT_CLASS(g_memory_content_parent_class)->dispose(G_OBJECT(content));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = instance d'objet GLib à traiter. *
+* *
+* Description : Procède à la libération totale de la mémoire. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_memory_content_finalize(GMemoryContent *content)
+{
+ if (content->storage != NULL)
+ {
+ unlink(content->storage);
+ free(content->storage);
+ }
+
+ G_OBJECT_CLASS(g_memory_content_parent_class)->finalize(G_OBJECT(content));
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : data = données du contenu volatile. *
+* size = quantité de ces données. *
+* *
+* Description : Charge en mémoire le contenu de données brutes. *
+* *
+* Retour : Représentation de contenu à manipuler ou NULL en cas d'échec.*
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBinContent *g_memory_content_new(bin_t *data, phys_t size)
+{
+ GMemoryContent *result; /* Structure à retourner */
+ int fd; /* Descripteur du fichier */
+ bool status; /* Bilan des écritures */
+
+ result = g_object_new(G_TYPE_MEMORY_CONTENT, NULL);
+
+ fd = make_tmp_file("memcnt", &result->storage);
+ if (fd == -1) goto gmcn_error;
+
+ status = safe_write(fd, data, size);
+
+ close(fd);
+
+ if (!status) goto gmcn_error;
+
+ result->backend = g_file_content_new(result->storage);
+ if (result->backend == NULL) goto gmcn_error;
+
+ return G_BIN_CONTENT(result);
+
+ gmcn_error:
+
+ g_object_unref(G_OBJECT(result));
+
+ return NULL;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : context = contexte pour les recherches XPath. *
+* path = chemin d'accès au noeud XML à lire. *
+* base = référence au lieu d'enregistrement du projet. *
+* *
+* Description : Charge des données à laisser en mémoire à partir d'XML. *
+* *
+* Retour : Adresse de la représentation ou NULL en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+GBinContent *g_memory_content_new_from_xml(xmlXPathContextPtr context, const char *path, const char *base)
+{
+ GBinContent *result; /* Adresse à retourner */
+ char *access; /* Chemin pour une sous-config.*/
+ char *encoded; /* Données encodées à charger */
+ guchar *data; /* Données brutes à charger */
+ gsize size; /* Quantité de ces données */
+
+ result = NULL;
+
+ /* Chemin du fichier à retrouver */
+
+ access = strdup(path);
+ access = stradd(access, "/Data");
+
+ encoded = get_node_text_value(context, access);
+
+ free(access);
+
+ /* Chargement */
+
+ if (encoded != NULL)
+ {
+ data = g_base64_decode(encoded, &size);
+
+ free(encoded);
+
+ if (data != NULL)
+ {
+ result = g_memory_content_new(data, size);
+ g_free(data);
+ }
+
+ }
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à consulter. *
+* full = précise s'il s'agit d'une version longue ou non. *
+* *
+* Description : Fournit le nom associé au contenu binaire. *
+* *
+* Retour : Nom de fichier avec chemin absolu au besoin. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static const char *g_memory_content_describe(const GMemoryContent *content, bool full)
+{
+ const char *result; /* Description à retourner */
+
+ result = "In-memory content";
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à traiter. *
+* xdoc = structure XML en cours d'édition. *
+* context = contexte à utiliser pour les recherches. *
+* path = chemin d'accès réservé au binaire. *
+* base = référence au lieu d'enregistrement du projet. *
+* *
+* Description : Ecrit une sauvegarde de contenu binaire dans un fichier XML. *
+* *
+* Retour : true si l'opération a bien tourné, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_memory_content_save(const GMemoryContent *content, xmlDocPtr xdoc, xmlXPathContextPtr context, const char *path, const char *base)
+{
+ bool result; /* Bilan à faire remonter */
+ char *access; /* Chemin d'accès à un élément */
+ vmpa2t start; /* Tête de lecture initiale */
+ phys_t length; /* Nombre d'octets disponibles */
+ const bin_t *data; /* Données brutes à sauvegarder*/
+ gchar *encoded; /* Données encodées à écrire */
+
+ /* Type */
+
+ result = add_string_attribute_to_node(xdoc, context, path, "type", "memory");
+ if (!result) goto gmcs_exit;
+
+ /* Données en mémoire associées */
+
+ access = strdup(path);
+ access = stradd(access, "/Data");
+
+ init_vmpa(&start, 0, VMPA_NO_VIRTUAL);
+
+ length = g_binary_content_compute_size(content->backend);
+
+ data = g_binary_content_get_raw_access(content->backend, &start, length);
+ assert(data != NULL);
+
+ encoded = g_base64_encode((const guchar *)data, length);
+ assert(encoded != NULL);
+
+ result = add_content_to_node(xdoc, context, access, encoded);
+
+ g_free(encoded);
+ free(access);
+
+ gmcs_exit:
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* checksum = empreinte de zone mémoire à compléter. *
+* *
+* Description : Calcule une empreinte unique (SHA256) pour les données. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_memory_content_compute_checksum(GMemoryContent *content, GChecksum *checksum)
+{
+ GBinContentIface *iface; /* Interface utilisée */
+
+ iface = G_BIN_CONTENT_GET_IFACE(content->backend);
+
+ iface->compute_checksum(content->backend, checksum);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* *
+* Description : Détermine le nombre d'octets lisibles. *
+* *
+* Retour : Quantité représentée. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static phys_t g_memory_content_compute_size(const GMemoryContent *content)
+{
+ phys_t result; /* Quantité trouvée à retourner*/
+
+ result = g_binary_content_compute_size(content->backend);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* pos = position finale (exclusive). [OUT] *
+* *
+* Description : Détermine la position finale d'un contenu. *
+* *
+* Retour : - *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static void g_memory_content_compute_end_pos(const GMemoryContent *content, vmpa2t *pos)
+{
+ g_binary_content_compute_end_pos(content->backend, pos);
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* length = quantité d'octets à provisionner. *
+* *
+* Description : Avance la tête de lecture d'une certaine quantité de données.*
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_memory_content_seek(const GMemoryContent *content, vmpa2t *addr, phys_t length)
+{
+ bool result; /* Bilan à retourner */
+
+ result = g_binary_content_seek(content->backend, addr, length);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* length = quantité d'octets à lire. *
+* *
+* Description : Donne accès à une portion des données représentées. *
+* *
+* Retour : Pointeur vers les données à lire ou NULL en cas d'échec. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static const bin_t *g_memory_content_get_raw_access(const GMemoryContent *content, vmpa2t *addr, phys_t length)
+{
+ const bin_t *result; /* Données utiles à renvoyer */
+
+ result = g_binary_content_get_raw_access(content->backend, addr, length);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* length = quantité d'octets à lire. *
+* out = réceptacle disponible pour ces données. [OUT] *
+* *
+* Description : Fournit une portion des données représentées. *
+* *
+* Retour : Bilan de l'opération. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_memory_content_read_raw(const GMemoryContent *content, vmpa2t *addr, phys_t length, bin_t *out)
+{
+ bool result; /* Bilan à remonter */
+
+ result = g_binary_content_read_raw(content->backend, addr, length, out);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* low = position éventuelle des 4 bits visés. [OUT] *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre non signé sur quatre bits. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_memory_content_read_u4(const GMemoryContent *content, vmpa2t *addr, bool *low, uint8_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_u4(content->backend, addr, low, val);
+
+ return result;
+
+}
+
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre non signé sur un octet. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_memory_content_read_u8(const GMemoryContent *content, vmpa2t *addr, uint8_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_u8(content->backend, addr, val);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* endian = ordre des bits dans la source. *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre non signé sur deux octets. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_memory_content_read_u16(const GMemoryContent *content, vmpa2t *addr, SourceEndian endian, uint16_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_u16(content->backend, addr, endian, val);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* endian = ordre des bits dans la source. *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre non signé sur quatre octets. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_memory_content_read_u32(const GMemoryContent *content, vmpa2t *addr, SourceEndian endian, uint32_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_u32(content->backend, addr, endian, val);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* endian = ordre des bits dans la source. *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre non signé sur huit octets. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_memory_content_read_u64(const GMemoryContent *content, vmpa2t *addr, SourceEndian endian, uint64_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_u64(content->backend, addr, endian, val);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre non signé encodé au format LEB128. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_memory_content_read_uleb128(const GMemoryContent *content, vmpa2t *addr, uleb128_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_uleb128(content->backend, addr, val);
+
+ return result;
+
+}
+
+
+/******************************************************************************
+* *
+* Paramètres : content = contenu binaire à venir lire. *
+* addr = position de la tête de lecture. *
+* val = lieu d'enregistrement de la lecture. [OUT] *
+* *
+* Description : Lit un nombre signé encodé au format LEB128. *
+* *
+* Retour : Bilan de l'opération : true en cas de succès, false sinon. *
+* *
+* Remarques : - *
+* *
+******************************************************************************/
+
+static bool g_memory_content_read_leb128(const GMemoryContent *content, vmpa2t *addr, leb128_t *val)
+{
+ bool result; /* Bilan de lecture à renvoyer */
+
+ result = g_binary_content_read_leb128(content->backend, addr, val);
+
+ return result;
+
+}
diff --git a/src/analysis/contents/memory.h b/src/analysis/contents/memory.h
new file mode 100644
index 0000000..769282c
--- /dev/null
+++ b/src/analysis/contents/memory.h
@@ -0,0 +1,61 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * memory.h - prototypes pour le chargement de données binaires à partir de la mémoire
+ *
+ * Copyright (C) 2018 Cyrille Bagard
+ *
+ * This file is part of Chrysalide.
+ *
+ * Chrysalide 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.
+ *
+ * Chrysalide 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 Chrysalide. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef _ANALYSIS_CONTENTS_MEMORY_H
+#define _ANALYSIS_CONTENTS_MEMORY_H
+
+
+#include <glib-object.h>
+
+
+#include "../content.h"
+
+
+
+#define G_TYPE_MEMORY_CONTENT (g_memory_content_get_type())
+#define G_MEMORY_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_MEMORY_CONTENT, GMemoryContent))
+#define G_IS_MEMORY_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_MEMORY_CONTENT))
+#define G_MEMORY_CONTENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_MEMORY_CONTENT, GMemoryContentClass))
+#define G_IS_MEMORY_CONTENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_MEMORY_CONTENT))
+#define G_MEMORY_CONTENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_MEMORY_CONTENT, GMemoryContentClass))
+
+
+/* Contenu de données binaires résidant en mémoire (instance) */
+typedef struct _GMemoryContent GMemoryContent;
+
+/* Contenu de données binaires résidant en mémoire (classe) */
+typedef struct _GMemoryContentClass GMemoryContentClass;
+
+
+/* Indique le type défini par la GLib pour les contenus de données en mémoire. */
+GType g_memory_content_get_type(void);
+
+/* Charge en mémoire le contenu de données brutes. */
+GBinContent *g_memory_content_new(bin_t *, phys_t);
+
+/* Charge des données à laisser en mémoire à partir d'XML. */
+GBinContent *g_memory_content_new_from_xml(xmlXPathContextPtr, const char *, const char *);
+
+
+
+#endif /* _ANALYSIS_CONTENTS_MEMORY_H */