diff options
Diffstat (limited to 'src/analysis/contents')
-rw-r--r-- | src/analysis/contents/Makefile.am | 14 | ||||
-rw-r--r-- | src/analysis/contents/encapsulated-int.h | 62 | ||||
-rw-r--r-- | src/analysis/contents/encapsulated.c | 479 | ||||
-rw-r--r-- | src/analysis/contents/file-int.h | 58 | ||||
-rw-r--r-- | src/analysis/contents/file.c | 220 | ||||
-rw-r--r-- | src/analysis/contents/memory-int.h | 12 | ||||
-rw-r--r-- | src/analysis/contents/memory.c | 395 | ||||
-rw-r--r-- | src/analysis/contents/restricted-int.h | 59 | ||||
-rw-r--r-- | src/analysis/contents/restricted.c | 337 | ||||
-rw-r--r-- | src/analysis/contents/restricted.h | 3 |
10 files changed, 1008 insertions, 631 deletions
diff --git a/src/analysis/contents/Makefile.am b/src/analysis/contents/Makefile.am index 66e3cac..e1cf04f 100644 --- a/src/analysis/contents/Makefile.am +++ b/src/analysis/contents/Makefile.am @@ -2,24 +2,18 @@ noinst_LTLIBRARIES = libanalysiscontents.la libanalysiscontents_la_SOURCES = \ + encapsulated-int.h \ encapsulated.h encapsulated.c \ + file-int.h \ file.h file.c \ memory-int.h \ memory.h memory.c \ + restricted-int.h \ restricted.h restricted.c -libanalysiscontents_la_LIBADD = - -libanalysiscontents_la_LDFLAGS = +libanalysiscontents_la_CFLAGS = $(TOOLKIT_CFLAGS) devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%) dev_HEADERS = $(libanalysiscontents_la_SOURCES:%c=) - - -AM_CPPFLAGS = $(LIBGTK_CFLAGS) $(LIBXML_CFLAGS) - -AM_CFLAGS = $(DEBUG_CFLAGS) $(WARNING_FLAGS) $(COMPLIANCE_FLAGS) - -SUBDIRS = diff --git a/src/analysis/contents/encapsulated-int.h b/src/analysis/contents/encapsulated-int.h new file mode 100644 index 0000000..5ccd318 --- /dev/null +++ b/src/analysis/contents/encapsulated-int.h @@ -0,0 +1,62 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * encapsulated-int.h - prototypes internes pour le chargement de données binaires à partir d'un contenu restreint + * + * Copyright (C) 2023 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_INT_H +#define _ANALYSIS_CONTENTS_ENCAPSULATED_INT_H + + +#include "encapsulated.h" + + +#include "../content-int.h" + + + +/* Contenu de données binaires issues d'un contenu restreint (instance) */ +struct _GEncapsContent +{ + GBinContent 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 données binaires issues d'un contenu restreint (classe) */ +struct _GEncapsContentClass +{ + GBinContentClass parent; /* A laisser en premier */ + +}; + + +/* Met en place un contenu de données brutes encapsulées. */ +bool g_encaps_content_create(GEncapsContent *, GBinContent *, const char *, GBinContent *); + + + +#endif /* _ANALYSIS_CONTENTS_ENCAPSULATED_INT_H */ diff --git a/src/analysis/contents/encapsulated.c b/src/analysis/contents/encapsulated.c index 7fb7e0c..e0e6ed1 100644 --- a/src/analysis/contents/encapsulated.c +++ b/src/analysis/contents/encapsulated.c @@ -28,33 +28,14 @@ #include <string.h> -#include "../content-int.h" +#include "encapsulated-int.h" #include "../db/misc/rlestr.h" #include "../storage/serialize-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 */ - -}; +/* -------------------------- ENSEMBLE DE DONNEES BINAIRES -------------------------- */ /* Initialise la classe des contenus de données encapsulés. */ @@ -63,23 +44,22 @@ 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 sérialisation. */ -static void g_encaps_content_serializable_init(GSerializableObjectInterface *); - -/* 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 *); -/* Charge un contenu depuis une mémoire tampon. */ -static bool g_encaps_content_load(GEncapsContent *, GObjectStorage *, packed_buffer_t *); -/* Sauvegarde un contenu dans une mémoire tampon. */ -static bool g_encaps_content_store(const GEncapsContent *, GObjectStorage *, packed_buffer_t *); + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Associe un ensemble d'attributs au contenu binaire. */ +static void g_encaps_content_set_attributes(GEncapsContent *, GContentAttributes *); + +/* Fournit l'ensemble des attributs associés à un contenu. */ +static GContentAttributes *g_encaps_content_get_attributes(const GEncapsContent *); /* Donne l'origine d'un contenu binaire. */ static GBinContent *g_encaps_content_get_root(GEncapsContent *); @@ -129,12 +109,21 @@ static bool g_encaps_content_read_uleb128(const GEncapsContent *, vmpa2t *, uleb /* Lit un nombre signé encodé au format LEB128. */ static bool g_encaps_content_read_leb128(const GEncapsContent *, vmpa2t *, leb128_t *); +/* Charge un contenu depuis une mémoire tampon. */ +static bool g_encaps_content_load(GEncapsContent *, GObjectStorage *, packed_buffer_t *); + +/* Sauvegarde un contenu dans une mémoire tampon. */ +static bool g_encaps_content_store(const GEncapsContent *, GObjectStorage *, packed_buffer_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* ENSEMBLE DE DONNEES BINAIRES */ +/* ---------------------------------------------------------------------------------- */ /* 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_SERIALIZABLE_OBJECT, g_encaps_content_serializable_init) - G_IMPLEMENT_INTERFACE(G_TYPE_BIN_CONTENT, g_encaps_content_interface_init)); +G_DEFINE_TYPE(GEncapsContent, g_encaps_content, G_TYPE_BIN_CONTENT); /****************************************************************************** @@ -152,64 +141,53 @@ G_DEFINE_TYPE_WITH_CODE(GEncapsContent, g_encaps_content, G_TYPE_OBJECT, static void g_encaps_content_class_init(GEncapsContentClass *klass) { GObjectClass *object; /* Autre version de la classe */ + GBinContentClass *content; /* Version parente de la classe*/ object = G_OBJECT_CLASS(klass); object->dispose = (GObjectFinalizeFunc/* ! */)g_encaps_content_dispose; object->finalize = (GObjectFinalizeFunc)g_encaps_content_finalize; -} + content = G_BIN_CONTENT_CLASS(klass); + content->set_attribs = (set_content_attributes)g_encaps_content_set_attributes; + content->get_attribs = (get_content_attributes)g_encaps_content_get_attributes; -/****************************************************************************** -* * -* Paramètres : content = instance à initialiser. * -* * -* Description : Initialise une instance de contenu de données encapsulé. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ + content->get_root = (get_content_root_fc)g_encaps_content_get_root; -static void g_encaps_content_init(GEncapsContent *content) -{ - content->base = NULL; - content->path = NULL; - content->endpoint = NULL; + content->describe = (describe_content_fc)g_encaps_content_describe; - content->full_desc = NULL; - content->desc = NULL; + content->compute_checksum = (compute_checksum_fc)g_encaps_content_compute_checksum; -} + content->compute_size = (compute_size_fc)g_encaps_content_compute_size; + content->compute_start_pos = (compute_start_pos_fc)g_encaps_content_compute_start_pos; + content->compute_end_pos = (compute_end_pos_fc)g_encaps_content_compute_end_pos; + content->seek = (seek_fc)g_encaps_content_seek; -/****************************************************************************** -* * -* Paramètres : iface = interface GLib à initialiser. * -* * -* Description : Procède à l'initialisation de l'interface de sérialisation. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ + content->get_raw_access = (get_raw_access_fc)g_encaps_content_get_raw_access; -static void g_encaps_content_serializable_init(GSerializableObjectInterface *iface) -{ - iface->load = (load_serializable_object_cb)g_encaps_content_load; - iface->store = (store_serializable_object_cb)g_encaps_content_store; + content->read_raw = (read_raw_fc)g_encaps_content_read_raw; + content->read_u4 = (read_u4_fc)g_encaps_content_read_u4; + content->read_u8 = (read_u8_fc)g_encaps_content_read_u8; + content->read_u16 = (read_u16_fc)g_encaps_content_read_u16; + content->read_u32 = (read_u32_fc)g_encaps_content_read_u32; + content->read_u64 = (read_u64_fc)g_encaps_content_read_u64; + + content->read_uleb128 = (read_uleb128_fc)g_encaps_content_read_uleb128; + content->read_leb128 = (read_leb128_fc)g_encaps_content_read_leb128; + + content->load = (load_content_cb)g_encaps_content_load; + content->store = (store_content_cb)g_encaps_content_store; } /****************************************************************************** * * -* Paramètres : iface = interface GLib à initialiser. * +* Paramètres : content = instance à initialiser. * * * -* Description : Procède à l'initialisation de l'interface de lecture. * +* Description : Initialise une instance de contenu de données encapsulé. * * * * Retour : - * * * @@ -217,31 +195,14 @@ static void g_encaps_content_serializable_init(GSerializableObjectInterface *ifa * * ******************************************************************************/ -static void g_encaps_content_interface_init(GBinContentInterface *iface) +static void g_encaps_content_init(GEncapsContent *content) { - iface->get_root = (get_content_root_fc)g_encaps_content_get_root; - - iface->describe = (describe_content_fc)g_encaps_content_describe; - - iface->compute_checksum = (compute_checksum_fc)g_encaps_content_compute_checksum; - - iface->compute_size = (compute_size_fc)g_encaps_content_compute_size; - iface->compute_start_pos = (compute_start_pos_fc)g_encaps_content_compute_start_pos; - iface->compute_end_pos = (compute_end_pos_fc)g_encaps_content_compute_end_pos; - - 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; + content->base = NULL; + content->path = NULL; + content->endpoint = NULL; - iface->read_uleb128 = (read_uleb128_fc)g_encaps_content_read_uleb128; - iface->read_leb128 = (read_leb128_fc)g_encaps_content_read_leb128; + content->full_desc = NULL; + content->desc = NULL; } @@ -310,41 +271,26 @@ static void g_encaps_content_finalize(GEncapsContent *content) GBinContent *g_encaps_content_new(GBinContent *base, const char *path, GBinContent *endpoint) { - GEncapsContent *result; /* Structure à retourner */ + GBinContent *result; /* Structure à retourner */ result = g_object_new(G_TYPE_ENCAPS_CONTENT, NULL); - g_object_ref(base); - g_object_ref(endpoint); - - result->base = base; - result->path = strdup(path); - result->endpoint = endpoint; - - /* Description complète */ - - 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); + if (!g_encaps_content_create(G_ENCAPS_CONTENT(result), base, path, endpoint)) + g_clear_object(&result); - /* Description partielle */ - - result->desc = strdup(path); - - return G_BIN_CONTENT(result); + return result; } /****************************************************************************** * * -* Paramètres : content = élément GLib à constuire. * -* storage = conservateur de données à manipuler ou NULL. * -* pbuf = zone tampon à lire. * +* Paramètres : content = instance à initialiser pleinement. * +* base = contenu binaire d'où réaliser une extraction. * +* path = chemin vers le contenu finalement ciblé. * +* endpoint = contenu final rendu accessible. * * * -* Description : Charge un contenu depuis une mémoire tampon. * +* Description : Met en place un contenu de données brutes encapsulées. * * * * Retour : Bilan de l'opération. * * * @@ -352,63 +298,79 @@ GBinContent *g_encaps_content_new(GBinContent *base, const char *path, GBinConte * * ******************************************************************************/ -static bool g_encaps_content_load(GEncapsContent *content, GObjectStorage *storage, packed_buffer_t *pbuf) +bool g_encaps_content_create(GEncapsContent *content, GBinContent *base, const char *path, GBinContent *endpoint) { bool result; /* Bilan à retourner */ - rle_string str; /* Chaîne à charger */ - content->base = G_BIN_CONTENT(g_object_storage_unpack_object(storage, "contents", pbuf)); - result = (content->base != NULL); + g_object_ref(base); + g_object_ref(endpoint); - setup_empty_rle_string(&str); + content->base = base; + content->path = strdup(path); + content->endpoint = endpoint; - if (result) - result = unpack_rle_string(&str, pbuf); + /* Description complète */ - if (result) - { - result = (get_rle_string(&str) != NULL); + content->full_desc = g_binary_content_describe(content->base, true); - if (result) - content->path = strdup(get_rle_string(&str)); + content->full_desc = stradd(content->full_desc, G_DIR_SEPARATOR_S); - exit_rle_string(&str); + content->full_desc = stradd(content->full_desc, path); - } + /* Description partielle */ - if (result) - { - content->endpoint = G_BIN_CONTENT(g_object_storage_unpack_object(storage, "contents", pbuf)); - result = (content->endpoint != NULL); - } + content->desc = strdup(path); - if (result) - result = unpack_rle_string(&str, pbuf); + result = true; - if (result) - { - result = (get_rle_string(&str) != NULL); + return result; - if (result) - content->full_desc = strdup(get_rle_string(&str)); +} - exit_rle_string(&str); - } +/****************************************************************************** +* * +* Paramètres : content = contenu binaire à venir consulter. * +* * +* Description : Indique la base d'un contenu binaire encapsulé. * +* * +* Retour : Instance de contenu binaire ou NULL si aucune. * +* * +* Remarques : - * +* * +******************************************************************************/ - if (result) - result = unpack_rle_string(&str, pbuf); +GBinContent *g_encaps_content_get_base(const GEncapsContent *content) +{ + GBinContent *result; /* Contenu binaire à renvoyer */ - if (result) - { - result = (get_rle_string(&str) != NULL); + result = content->base; - if (result) - content->desc = strdup(get_rle_string(&str)); + if (result != NULL) + g_object_ref(G_OBJECT(result)); - exit_rle_string(&str); + return result; - } +} + + +/****************************************************************************** +* * +* Paramètres : content = contenu binaire à venir consulter. * +* * +* Description : Fournit le chemin vers le contenu interne représenté. * +* * +* Retour : Chemin d'accès au contenu binaire. * +* * +* Remarques : - * +* * +******************************************************************************/ + +const char *g_encaps_content_get_path(const GEncapsContent *content) +{ + char *result; /* Chemin d'accès à retourner */ + + result = content->path; return result; @@ -417,57 +379,73 @@ static bool g_encaps_content_load(GEncapsContent *content, GObjectStorage *stora /****************************************************************************** * * -* Paramètres : content = élément GLib à consulter. * -* storage = conservateur de données à manipuler ou NULL. * -* pbuf = zone tampon à remplir. * +* Paramètres : content = contenu binaire à venir consulter. * * * -* Description : Sauvegarde un contenu dans une mémoire tampon. * +* Description : Indique le contenu binaire embarqué dans une encapsulation. * * * -* Retour : Bilan de l'opération. * +* Retour : Instance de contenu binaire ou NULL si aucune. * * * * Remarques : - * * * ******************************************************************************/ -static bool g_encaps_content_store(const GEncapsContent *content, GObjectStorage *storage, packed_buffer_t *pbuf) +GBinContent *g_encaps_content_get_endpoint(const GEncapsContent *content) { - bool result; /* Bilan à retourner */ - rle_string str; /* Chaîne à conserver */ + GBinContent *result; /* Contenu binaire à renvoyer */ - result = g_object_storage_pack_object(storage, "contents", G_SERIALIZABLE_OBJECT(content->base), pbuf); + result = content->endpoint; - if (result) - { - init_static_rle_string(&str, content->path); + if (result != NULL) + g_object_ref(G_OBJECT(result)); - result = pack_rle_string(&str, pbuf); + return result; - exit_rle_string(&str); +} - } - if (result) - result = g_object_storage_pack_object(storage, "contents", G_SERIALIZABLE_OBJECT(content->endpoint), pbuf); - if (result) - { - init_static_rle_string(&str, content->full_desc); +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ - result = pack_rle_string(&str, pbuf); - exit_rle_string(&str); +/****************************************************************************** +* * +* Paramètres : content = contenu binaire à actualiser. * +* attribs = jeu d'attributs à lier au contenu courant. * +* * +* Description : Associe un ensemble d'attributs au contenu binaire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ - } +static void g_encaps_content_set_attributes(GEncapsContent *content, GContentAttributes *attribs) +{ + g_binary_content_set_attributes(content->endpoint, attribs); - if (result) - { - init_static_rle_string(&str, content->desc); +} - result = pack_rle_string(&str, pbuf); - exit_rle_string(&str); +/****************************************************************************** +* * +* Paramètres : content = contenu binaire à consulter. * +* * +* Description : Fournit l'ensemble des attributs associés à un contenu. * +* * +* Retour : Jeu d'attributs liés au contenu courant. * +* * +* Remarques : - * +* * +******************************************************************************/ - } +static GContentAttributes *g_encaps_content_get_attributes(const GEncapsContent *content) +{ + GContentAttributes *result; /* Instance à retourner */ + + result = g_binary_content_get_attributes(content->endpoint); return result; @@ -539,11 +517,11 @@ static char *g_encaps_content_describe(const GEncapsContent *content, bool full) static void g_encaps_content_compute_checksum(GEncapsContent *content, GChecksum *checksum) { - GBinContentIface *iface; /* Interface utilisée */ + GBinContentClass *class; /* Classe de l'instance */ - iface = G_BIN_CONTENT_GET_IFACE(content->endpoint); + class = G_BIN_CONTENT_GET_CLASS(content); - iface->compute_checksum(content->endpoint, checksum); + class->compute_checksum(content->endpoint, checksum); } @@ -869,47 +847,75 @@ static bool g_encaps_content_read_leb128(const GEncapsContent *content, vmpa2t * /****************************************************************************** * * -* Paramètres : content = contenu binaire à venir consulter. * +* Paramètres : content = élément GLib à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à lire. * * * -* Description : Indique la base d'un contenu binaire encapsulé. * +* Description : Charge un contenu depuis une mémoire tampon. * * * -* Retour : Instance de contenu binaire ou NULL si aucune. * +* Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ -GBinContent *g_encaps_content_get_base(const GEncapsContent *content) +static bool g_encaps_content_load(GEncapsContent *content, GObjectStorage *storage, packed_buffer_t *pbuf) { - GBinContent *result; /* Contenu binaire à renvoyer */ + bool result; /* Bilan à retourner */ + rle_string str; /* Chaîne à charger */ - result = content->base; + content->base = G_BIN_CONTENT(g_object_storage_unpack_object(storage, "contents", pbuf)); + result = (content->base != NULL); - if (result != NULL) - g_object_ref(G_OBJECT(result)); + setup_empty_rle_string(&str); - return result; + if (result) + result = unpack_rle_string(&str, pbuf); -} + if (result) + { + result = (get_rle_string(&str) != NULL); + if (result) + content->path = strdup(get_rle_string(&str)); -/****************************************************************************** -* * -* Paramètres : content = contenu binaire à venir consulter. * -* * -* Description : Fournit le chemin vers le contenu interne représenté. * -* * -* Retour : Chemin d'accès au contenu binaire. * -* * -* Remarques : - * -* * -******************************************************************************/ + exit_rle_string(&str); -const char *g_encaps_content_get_path(const GEncapsContent *content) -{ - char *result; /* Chemin d'accès à retourner */ + } - result = content->path; + if (result) + { + content->endpoint = G_BIN_CONTENT(g_object_storage_unpack_object(storage, "contents", pbuf)); + result = (content->endpoint != NULL); + } + + if (result) + result = unpack_rle_string(&str, pbuf); + + if (result) + { + result = (get_rle_string(&str) != NULL); + + if (result) + content->full_desc = strdup(get_rle_string(&str)); + + exit_rle_string(&str); + + } + + if (result) + result = unpack_rle_string(&str, pbuf); + + if (result) + { + result = (get_rle_string(&str) != NULL); + + if (result) + content->desc = strdup(get_rle_string(&str)); + + exit_rle_string(&str); + + } return result; @@ -918,24 +924,57 @@ const char *g_encaps_content_get_path(const GEncapsContent *content) /****************************************************************************** * * -* Paramètres : content = contenu binaire à venir consulter. * +* Paramètres : content = élément GLib à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * * * -* Description : Indique le contenu binaire embarqué dans une encapsulation. * +* Description : Sauvegarde un contenu dans une mémoire tampon. * * * -* Retour : Instance de contenu binaire ou NULL si aucune. * +* Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ -GBinContent *g_encaps_content_get_endpoint(const GEncapsContent *content) +static bool g_encaps_content_store(const GEncapsContent *content, GObjectStorage *storage, packed_buffer_t *pbuf) { - GBinContent *result; /* Contenu binaire à renvoyer */ + bool result; /* Bilan à retourner */ + rle_string str; /* Chaîne à conserver */ - result = content->endpoint; + result = g_object_storage_pack_object(storage, "contents", G_SERIALIZABLE_OBJECT(content->base), pbuf); - if (result != NULL) - g_object_ref(G_OBJECT(result)); + if (result) + { + init_static_rle_string(&str, content->path); + + result = pack_rle_string(&str, pbuf); + + exit_rle_string(&str); + + } + + if (result) + result = g_object_storage_pack_object(storage, "contents", G_SERIALIZABLE_OBJECT(content->endpoint), pbuf); + + if (result) + { + init_static_rle_string(&str, content->full_desc); + + result = pack_rle_string(&str, pbuf); + + exit_rle_string(&str); + + } + + if (result) + { + init_static_rle_string(&str, content->desc); + + result = pack_rle_string(&str, pbuf); + + exit_rle_string(&str); + + } return result; diff --git a/src/analysis/contents/file-int.h b/src/analysis/contents/file-int.h new file mode 100644 index 0000000..dc61bdc --- /dev/null +++ b/src/analysis/contents/file-int.h @@ -0,0 +1,58 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * file-int.h - prototypes internes pour le chargement de données binaires à partir d'un fichier + * + * Copyright (C) 2023 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_FILE_INT_H +#define _ANALYSIS_CONTENTS_FILE_INT_H + + +#include "file.h" + + +#include "memory-int.h" + + + +/* Contenu de données binaires issues d'un fichier (instance) */ +struct _GFileContent +{ + GMemoryContent parent; /* A laisser en premier */ + + char *filename; /* Fichier chargé en mémoire */ + int fd; /* Flux ouvert en lectureu */ + +}; + +/* Contenu de données binaires issues d'un fichier (classe) */ +struct _GFileContentClass +{ + GMemoryContentClass parent; /* A laisser en premier */ + +}; + + +/* Met en place un contenu d'un fichier donné. */ +bool g_file_content_create(GFileContent *, const char *); + + + +#endif /* _ANALYSIS_CONTENTS_FILE_INT_H */ diff --git a/src/analysis/contents/file.c b/src/analysis/contents/file.c index 78bd981..545d869 100644 --- a/src/analysis/contents/file.c +++ b/src/analysis/contents/file.c @@ -25,6 +25,7 @@ #include <fcntl.h> +#include <libgen.h> #include <malloc.h> #include <string.h> #include <unistd.h> @@ -32,29 +33,14 @@ #include <sys/stat.h> -#include "memory-int.h" -#include "../content-int.h" +#include "file-int.h" #include "../db/misc/rlestr.h" #include "../storage/serialize-int.h" #include "../../core/logs.h" -/* Contenu de données binaires issues d'un fichier (instance) */ -struct _GFileContent -{ - GMemoryContent parent; /* A laisser en premier */ - - char *filename; /* Fichier chargé en mémoire */ - -}; - -/* Contenu de données binaires issues d'un fichier (classe) */ -struct _GFileContentClass -{ - GMemoryContentClass parent; /* A laisser en premier */ - -}; +/* -------------------------- ENSEMBLE DE DONNEES BINAIRES -------------------------- */ /* Initialise la classe des contenus de données binaires. */ @@ -63,15 +49,20 @@ static void g_file_content_class_init(GFileContentClass *); /* Initialise une instance de contenu de données binaires. */ static void g_file_content_init(GFileContent *); -/* Procède à l'initialisation de l'interface de sérialisation. */ -static void g_file_content_serializable_init(GSerializableObjectInterface *); - /* Supprime toutes les références externes. */ static void g_file_content_dispose(GFileContent *); /* Procède à la libération totale de la mémoire. */ static void g_file_content_finalize(GFileContent *); + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Fournit le nom associé au contenu binaire. */ +static char *g_file_content_describe(const GFileContent *, bool); + /* Charge un contenu depuis une mémoire tampon. */ static bool g_file_content_load(GFileContent *, GObjectStorage *, packed_buffer_t *); @@ -80,9 +71,13 @@ static bool g_file_content_store(const GFileContent *, GObjectStorage *, packed_ +/* ---------------------------------------------------------------------------------- */ +/* ENSEMBLE DE DONNEES BINAIRES */ +/* ---------------------------------------------------------------------------------- */ + + /* Indique le type défini par la GLib pour les contenus de données. */ -G_DEFINE_TYPE_WITH_CODE(GFileContent, g_file_content, G_TYPE_MEMORY_CONTENT, - G_IMPLEMENT_INTERFACE(G_TYPE_SERIALIZABLE_OBJECT, g_file_content_serializable_init)); +G_DEFINE_TYPE(GFileContent, g_file_content, G_TYPE_MEMORY_CONTENT); /****************************************************************************** @@ -100,12 +95,20 @@ G_DEFINE_TYPE_WITH_CODE(GFileContent, g_file_content, G_TYPE_MEMORY_CONTENT, static void g_file_content_class_init(GFileContentClass *klass) { GObjectClass *object; /* Autre version de la classe */ + GBinContentClass *content; /* Version parente de la classe*/ object = G_OBJECT_CLASS(klass); object->dispose = (GObjectFinalizeFunc/* ! */)g_file_content_dispose; object->finalize = (GObjectFinalizeFunc)g_file_content_finalize; + content = G_BIN_CONTENT_CLASS(klass); + + content->describe = (describe_content_fc)g_file_content_describe; + + content->load = (load_content_cb)g_file_content_load; + content->store = (store_content_cb)g_file_content_store; + } @@ -124,15 +127,16 @@ static void g_file_content_class_init(GFileContentClass *klass) static void g_file_content_init(GFileContent *content) { content->filename = NULL; + content->fd = -1; } /****************************************************************************** * * -* Paramètres : iface = interface GLib à initialiser. * +* Paramètres : content = instance d'objet GLib à traiter. * * * -* Description : Procède à l'initialisation de l'interface de sérialisation. * +* Description : Supprime toutes les références externes. * * * * Retour : - * * * @@ -140,10 +144,9 @@ static void g_file_content_init(GFileContent *content) * * ******************************************************************************/ -static void g_file_content_serializable_init(GSerializableObjectInterface *iface) +static void g_file_content_dispose(GFileContent *content) { - iface->load = (load_serializable_object_cb)g_file_content_load; - iface->store = (store_serializable_object_cb)g_file_content_store; + G_OBJECT_CLASS(g_file_content_parent_class)->dispose(G_OBJECT(content)); } @@ -152,7 +155,7 @@ static void g_file_content_serializable_init(GSerializableObjectInterface *iface * * * Paramètres : content = instance d'objet GLib à traiter. * * * -* Description : Supprime toutes les références externes. * +* Description : Procède à la libération totale de la mémoire. * * * * Retour : - * * * @@ -160,55 +163,78 @@ static void g_file_content_serializable_init(GSerializableObjectInterface *iface * * ******************************************************************************/ -static void g_file_content_dispose(GFileContent *content) +static void g_file_content_finalize(GFileContent *content) { - G_OBJECT_CLASS(g_file_content_parent_class)->dispose(G_OBJECT(content)); + GMemoryContent *base; /* Structure parente */ + + free(content->filename); + + if (content->fd != -1) + { + base = G_MEMORY_CONTENT(content); + munmap(base->data, base->length); + + close(content->fd); + + } + + G_OBJECT_CLASS(g_file_content_parent_class)->finalize(G_OBJECT(content)); } + + /****************************************************************************** * * -* Paramètres : content = instance d'objet GLib à traiter. * +* Paramètres : filename = chemin d'accès au fichier à charger. * * * -* Description : Procède à la libération totale de la mémoire. * +* Description : Charge en mémoire le contenu d'un fichier donné. * * * -* Retour : - * +* Retour : Représentation de contenu à manipuler ou NULL en cas d'échec.* * * * Remarques : - * * * ******************************************************************************/ -static void g_file_content_finalize(GFileContent *content) +GBinContent *g_file_content_new(const char *filename) { - free(content->filename); + GBinContent *result; /* Structure à retourner */ - G_OBJECT_CLASS(g_file_content_parent_class)->finalize(G_OBJECT(content)); + result = g_object_new(G_TYPE_FILE_CONTENT, NULL); + + if (!g_file_content_create(G_FILE_CONTENT(result), filename)) + g_clear_object(&result); + + return result; } /****************************************************************************** * * -* Paramètres : filename = chemin d'accès au fichier à charger. * +* Paramètres : content = instance à initialiser pleinement. * +* filename = chemin d'accès au fichier à charger. * * * -* Description : Charge en mémoire le contenu d'un fichier donné. * +* Description : Met en place un contenu d'un fichier donné. * * * -* Retour : Représentation de contenu à manipuler ou NULL en cas d'échec.* +* Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ -GBinContent *g_file_content_new(const char *filename) +bool g_file_content_create(GFileContent *content, const char *filename) { - GFileContent *result; /* Structure à retourner */ + bool result; /* Bilan à retourner */ int fd; /* Descripteur du fichier */ struct stat info; /* Informations sur le fichier */ int ret; /* Bilan d'un appel */ - void *content; /* Contenu brut du fichier */ + void *data; /* Contenu brut du fichier */ GMemoryContent *base; /* Structure parente */ + result = false; + /* Récupération des données */ fd = open(filename, O_RDONLY); @@ -226,8 +252,8 @@ GBinContent *g_file_content_new(const char *filename) goto file_error; } - content = mmap(NULL, info.st_size, PROT_READ, MAP_PRIVATE, fd, 0); - if (content == MAP_FAILED) + data = mmap(NULL, info.st_size, PROT_READ, MAP_PRIVATE, fd, 0); + if (data == MAP_FAILED) { close(fd); LOG_ERROR_N("mmap"); @@ -236,25 +262,86 @@ GBinContent *g_file_content_new(const char *filename) /* Constitution du contenu officiel */ - result = g_object_new(G_TYPE_FILE_CONTENT, NULL); + content->filename = strdup(filename); - result->filename = strdup(filename); + base = G_MEMORY_CONTENT(content); - base = G_MEMORY_CONTENT(result); + base->data = data; + base->length = info.st_size; - base->data = malloc(info.st_size); - memcpy(base->data, content, info.st_size); + result = true; - base->length = info.st_size; + file_error: - munmap(content, info.st_size); - close(fd); + return result; - return G_BIN_CONTENT(result); +} - file_error: - return NULL; +/****************************************************************************** +* * +* Paramètres : content = contenu binaire à venir consulter. * +* * +* Description : Fournit le nom de fichier associé au contenu binaire. * +* * +* Retour : Chemin d'accès au contenu binaire. * +* * +* Remarques : - * +* * +******************************************************************************/ + +const char *g_file_content_get_filename(const GFileContent *content) +{ + char *result; /* Chemin d'accès à retourner */ + + result = content->filename; + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* 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 char *g_file_content_describe(const GFileContent *content, bool full) +{ + char *result; /* Description à retourner */ + char *tmp; /* Copie modifiable */ + char *base; /* Description à recopier */ + + if (full) + result = strdup(content->filename); + + else + { + tmp = strdup(content->filename); + + base = basename(tmp); + + result = strdup(base); + + free(tmp); + + } + + return result; } @@ -341,26 +428,3 @@ static bool g_file_content_store(const GFileContent *content, GObjectStorage *st return result; } - - -/****************************************************************************** -* * -* Paramètres : content = contenu binaire à venir consulter. * -* * -* Description : Fournit le nom de fichier associé au contenu binaire. * -* * -* Retour : Chemin d'accès au contenu binaire. * -* * -* Remarques : - * -* * -******************************************************************************/ - -const char *g_file_content_get_filename(const GFileContent *content) -{ - char *result; /* Chemin d'accès à retourner */ - - result = content->filename; - - return result; - -} diff --git a/src/analysis/contents/memory-int.h b/src/analysis/contents/memory-int.h index 621e4a6..d3012c7 100644 --- a/src/analysis/contents/memory-int.h +++ b/src/analysis/contents/memory-int.h @@ -28,16 +28,20 @@ #include "memory.h" +#include "../content-int.h" + + /* Contenu de données binaires résidant en mémoire (instance) */ struct _GMemoryContent { - GObject parent; /* A laisser en premier */ + GBinContent parent; /* A laisser en premier */ GContentAttributes *attribs; /* Attributs liés au contenu */ bin_t *data; /* Contenu binaire représenté */ phys_t length; /* Taille totale du contenu */ + bool allocated; /* Nature de la zone de données*/ char *full_desc; /* Description de l'ensemble */ char *desc; /* Description de l'ensemble */ @@ -47,10 +51,14 @@ struct _GMemoryContent /* Contenu de données binaires résidant en mémoire (classe) */ struct _GMemoryContentClass { - GObjectClass parent; /* A laisser en premier */ + GBinContentClass parent; /* A laisser en premier */ }; +/* Met en place un contenu de données brutes depuis la mémoire. */ +bool g_memory_content_create(GMemoryContent *, const bin_t *, phys_t); + + #endif /* _ANALYSIS_CONTENTS_MEMORY_INT_H */ diff --git a/src/analysis/contents/memory.c b/src/analysis/contents/memory.c index 6a020e8..f8ff863 100644 --- a/src/analysis/contents/memory.c +++ b/src/analysis/contents/memory.c @@ -42,29 +42,25 @@ +/* -------------------------- ENSEMBLE DE DONNEES BINAIRES -------------------------- */ + + /* 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 sérialisation. */ -static void g_memory_content_serializable_init(GSerializableObjectInterface *); - -/* 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 *); -/* Charge un contenu depuis une mémoire tampon. */ -static bool g_memory_content_load(GMemoryContent *, GObjectStorage *, packed_buffer_t *); -/* Sauvegarde un contenu dans une mémoire tampon. */ -static bool g_memory_content_store(const GMemoryContent *, GObjectStorage *, packed_buffer_t *); + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + /* Associe un ensemble d'attributs au contenu binaire. */ static void g_memory_content_set_attributes(GMemoryContent *, GContentAttributes *); @@ -120,12 +116,21 @@ static bool g_memory_content_read_uleb128(const GMemoryContent *, vmpa2t *, uleb /* Lit un nombre signé encodé au format LEB128. */ static bool g_memory_content_read_leb128(const GMemoryContent *, vmpa2t *, leb128_t *); +/* Charge un contenu depuis une mémoire tampon. */ +static bool g_memory_content_load(GMemoryContent *, GObjectStorage *, packed_buffer_t *); + +/* Sauvegarde un contenu dans une mémoire tampon. */ +static bool g_memory_content_store(const GMemoryContent *, GObjectStorage *, packed_buffer_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* ENSEMBLE DE DONNEES BINAIRES */ +/* ---------------------------------------------------------------------------------- */ /* 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_SERIALIZABLE_OBJECT, g_memory_content_serializable_init) - G_IMPLEMENT_INTERFACE(G_TYPE_BIN_CONTENT, g_memory_content_interface_init)); +G_DEFINE_TYPE(GMemoryContent, g_memory_content, G_TYPE_BIN_CONTENT); /****************************************************************************** @@ -143,71 +148,53 @@ G_DEFINE_TYPE_WITH_CODE(GMemoryContent, g_memory_content, G_TYPE_OBJECT, static void g_memory_content_class_init(GMemoryContentClass *klass) { GObjectClass *object; /* Autre version de la classe */ + GBinContentClass *content; /* Version parente de la classe*/ object = G_OBJECT_CLASS(klass); object->dispose = (GObjectFinalizeFunc/* ! */)g_memory_content_dispose; object->finalize = (GObjectFinalizeFunc)g_memory_content_finalize; -} + content = G_BIN_CONTENT_CLASS(klass); + content->set_attribs = (set_content_attributes)g_memory_content_set_attributes; + content->get_attribs = (get_content_attributes)g_memory_content_get_attributes; -/****************************************************************************** -* * -* Paramètres : content = instance à initialiser. * -* * -* Description : Initialise une instance de contenu de données en mémoire. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ + content->get_root = (get_content_root_fc)g_memory_content_get_root; -static void g_memory_content_init(GMemoryContent *content) -{ - GContentAttributes *empty; /* Jeu d'attributs vide */ + content->describe = (describe_content_fc)g_memory_content_describe; - content->attribs = NULL; + content->compute_checksum = (compute_checksum_fc)g_memory_content_compute_checksum; - empty = g_content_attributes_new(""); + content->compute_size = (compute_size_fc)g_memory_content_compute_size; + content->compute_start_pos = (compute_start_pos_fc)g_memory_content_compute_start_pos; + content->compute_end_pos = (compute_end_pos_fc)g_memory_content_compute_end_pos; - g_binary_content_set_attributes(G_BIN_CONTENT(content), empty); + content->seek = (seek_fc)g_memory_content_seek; - content->data = NULL; - content->length = 0; + content->get_raw_access = (get_raw_access_fc)g_memory_content_get_raw_access; - content->full_desc = strdup("In-memory content"); - content->desc = strdup("In-memory content"); + content->read_raw = (read_raw_fc)g_memory_content_read_raw; + content->read_u4 = (read_u4_fc)g_memory_content_read_u4; + content->read_u8 = (read_u8_fc)g_memory_content_read_u8; + content->read_u16 = (read_u16_fc)g_memory_content_read_u16; + content->read_u32 = (read_u32_fc)g_memory_content_read_u32; + content->read_u64 = (read_u64_fc)g_memory_content_read_u64; -} + content->read_uleb128 = (read_uleb128_fc)g_memory_content_read_uleb128; + content->read_leb128 = (read_leb128_fc)g_memory_content_read_leb128; - -/****************************************************************************** -* * -* Paramètres : iface = interface GLib à initialiser. * -* * -* Description : Procède à l'initialisation de l'interface de sérialisation. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void g_memory_content_serializable_init(GSerializableObjectInterface *iface) -{ - iface->load = (load_serializable_object_cb)g_memory_content_load; - iface->store = (store_serializable_object_cb)g_memory_content_store; + content->load = (load_content_cb)g_memory_content_load; + content->store = (store_content_cb)g_memory_content_store; } /****************************************************************************** * * -* Paramètres : iface = interface GLib à initialiser. * +* Paramètres : content = instance à initialiser. * * * -* Description : Procède à l'initialisation de l'interface de lecture. * +* Description : Initialise une instance de contenu de données en mémoire. * * * * Retour : - * * * @@ -215,34 +202,24 @@ static void g_memory_content_serializable_init(GSerializableObjectInterface *ifa * * ******************************************************************************/ -static void g_memory_content_interface_init(GBinContentInterface *iface) +static void g_memory_content_init(GMemoryContent *content) { - iface->set_attribs = (set_content_attributes)g_memory_content_set_attributes; - iface->get_attribs = (get_content_attributes)g_memory_content_get_attributes; - - iface->get_root = (get_content_root_fc)g_memory_content_get_root; - - iface->describe = (describe_content_fc)g_memory_content_describe; + GContentAttributes *empty; /* Jeu d'attributs vide */ - iface->compute_checksum = (compute_checksum_fc)g_memory_content_compute_checksum; + content->attribs = NULL; - iface->compute_size = (compute_size_fc)g_memory_content_compute_size; - iface->compute_start_pos = (compute_start_pos_fc)g_memory_content_compute_start_pos; - iface->compute_end_pos = (compute_end_pos_fc)g_memory_content_compute_end_pos; + empty = g_content_attributes_new("", NULL); - iface->seek = (seek_fc)g_memory_content_seek; + g_binary_content_set_attributes(G_BIN_CONTENT(content), empty); - iface->get_raw_access = (get_raw_access_fc)g_memory_content_get_raw_access; + g_object_unref(G_OBJECT(empty)); - 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; + content->data = NULL; + content->length = 0; + content->allocated = false; - iface->read_uleb128 = (read_uleb128_fc)g_memory_content_read_uleb128; - iface->read_leb128 = (read_leb128_fc)g_memory_content_read_leb128; + content->full_desc = strdup("In-memory content"); + content->desc = strdup("In-memory content"); } @@ -282,8 +259,11 @@ static void g_memory_content_dispose(GMemoryContent *content) static void g_memory_content_finalize(GMemoryContent *content) { - if (content->data != NULL) - free(content->data); + if (content->allocated) + { + if (content->data != NULL) + free(content->data); + } if (content->desc != NULL) free(content->desc); @@ -311,35 +291,25 @@ static void g_memory_content_finalize(GMemoryContent *content) GBinContent *g_memory_content_new(const bin_t *data, phys_t size) { - GMemoryContent *result; /* Structure à retourner */ - bin_t *allocated; /* Zone de réception */ - - allocated = malloc(size); - if (allocated == NULL) - { - LOG_ERROR_N("malloc"); - return NULL; - } - - memcpy(allocated, data, size); + GBinContent *result; /* Structure à retourner */ result = g_object_new(G_TYPE_MEMORY_CONTENT, NULL); - result->data = allocated; - result->length = size; + if (!g_memory_content_create(G_MEMORY_CONTENT(result), data, size)) + g_clear_object(&result); - return G_BIN_CONTENT(result); + return result; } /****************************************************************************** * * -* Paramètres : content = élément GLib à constuire. * -* storage = conservateur de données à manipuler ou NULL. * -* pbuf = zone tampon à lire. * +* Paramètres : content = instance à initialiser pleinement. * +* data = données du contenu volatile. * +* size = quantité de ces données. * * * -* Description : Charge un contenu depuis une mémoire tampon. * +* Description : Met en place un contenu de données brutes depuis la mémoire. * * * * Retour : Bilan de l'opération. * * * @@ -347,108 +317,37 @@ GBinContent *g_memory_content_new(const bin_t *data, phys_t size) * * ******************************************************************************/ -static bool g_memory_content_load(GMemoryContent *content, GObjectStorage *storage, packed_buffer_t *pbuf) +bool g_memory_content_create(GMemoryContent *content, const bin_t *data, phys_t size) { bool result; /* Bilan à retourner */ - uleb128_t length; /* Quantité de données à suivre*/ - rle_string str; /* Chaîne à charger */ - - result = unpack_uleb128(&length, pbuf); - - if (result) - { - content->data = malloc(length); - result = (content->data != NULL); - } - - if (result) - { - content->length = length; - result = extract_packed_buffer(pbuf, content->data, length, false); - } - - setup_empty_rle_string(&str); - - if (result) - result = unpack_rle_string(&str, pbuf); + bin_t *allocated; /* Zone de réception */ - if (result) + allocated = malloc(size); + if (allocated == NULL) { - result = (get_rle_string(&str) != NULL); - - if (result) - content->full_desc = strdup(get_rle_string(&str)); - - exit_rle_string(&str); - + LOG_ERROR_N("malloc"); + goto exit; } - if (result) - result = unpack_rle_string(&str, pbuf); + memcpy(allocated, data, size); - if (result) - { - result = (get_rle_string(&str) != NULL); + content->data = allocated; + content->length = size; + content->allocated = true; - if (result) - content->desc = strdup(get_rle_string(&str)); + result = true; - exit_rle_string(&str); - - } + exit: return result; } -/****************************************************************************** -* * -* Paramètres : content = élément GLib à consulter. * -* storage = conservateur de données à manipuler ou NULL. * -* pbuf = zone tampon à remplir. * -* * -* Description : Sauvegarde un contenu dans une mémoire tampon. * -* * -* Retour : Bilan de l'opération. * -* * -* Remarques : - * -* * -******************************************************************************/ - -static bool g_memory_content_store(const GMemoryContent *content, GObjectStorage *storage, packed_buffer_t *pbuf) -{ - bool result; /* Bilan à retourner */ - rle_string str; /* Chaîne à conserver */ - - result = pack_uleb128((uleb128_t []){ content->length }, pbuf); - - if (result) - result = extend_packed_buffer(pbuf, content->data, content->length, false); - - if (result) - { - init_static_rle_string(&str, content->full_desc); - - result = pack_rle_string(&str, pbuf); - - exit_rle_string(&str); - - } - - if (result) - { - init_static_rle_string(&str, content->desc); - - result = pack_rle_string(&str, pbuf); - - exit_rle_string(&str); - - } - - return result; -} +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ /****************************************************************************** @@ -466,7 +365,10 @@ static bool g_memory_content_store(const GMemoryContent *content, GObjectStorage static void g_memory_content_set_attributes(GMemoryContent *content, GContentAttributes *attribs) { + g_clear_object(&content->attribs); + content->attribs = attribs; + g_object_ref(G_OBJECT(attribs)); } @@ -489,6 +391,9 @@ static GContentAttributes *g_memory_content_get_attributes(const GMemoryContent result = content->attribs; + if (result != NULL) + g_object_ref(G_OBJECT(result)); + return result; } @@ -512,6 +417,8 @@ static GBinContent *g_memory_content_get_root(GMemoryContent *content) result = G_BIN_CONTENT(content); + g_object_ref(G_OBJECT(result)); + return result; } @@ -789,15 +696,12 @@ static bool g_memory_content_read_u8(const GMemoryContent *content, vmpa2t *addr { bool result; /* Bilan de lecture à renvoyer */ phys_t pos; /* Tête de lecture courante */ - phys_t length; /* Taille de la surface dispo. */ pos = get_phy_addr(addr); if (pos == VMPA_NO_PHYSICAL) return false; - length = length; - result = read_u8(val, content->data, &pos, content->length); if (result) @@ -979,3 +883,124 @@ static bool g_memory_content_read_leb128(const GMemoryContent *content, vmpa2t * return result; } + + +/****************************************************************************** +* * +* Paramètres : content = élément GLib à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à lire. * +* * +* Description : Charge un contenu depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_memory_content_load(GMemoryContent *content, GObjectStorage *storage, packed_buffer_t *pbuf) +{ + bool result; /* Bilan à retourner */ + uleb128_t length; /* Quantité de données à suivre*/ + rle_string str; /* Chaîne à charger */ + + result = unpack_uleb128(&length, pbuf); + + if (result) + { + content->data = malloc(length); + result = (content->data != NULL); + + content->allocated = true; + + } + + if (result) + { + content->length = length; + result = extract_packed_buffer(pbuf, content->data, length, false); + } + + setup_empty_rle_string(&str); + + if (result) + result = unpack_rle_string(&str, pbuf); + + if (result) + { + result = (get_rle_string(&str) != NULL); + + if (result) + content->full_desc = strdup(get_rle_string(&str)); + + exit_rle_string(&str); + + } + + if (result) + result = unpack_rle_string(&str, pbuf); + + if (result) + { + result = (get_rle_string(&str) != NULL); + + if (result) + content->desc = strdup(get_rle_string(&str)); + + exit_rle_string(&str); + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : content = élément GLib à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un contenu dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_memory_content_store(const GMemoryContent *content, GObjectStorage *storage, packed_buffer_t *pbuf) +{ + bool result; /* Bilan à retourner */ + rle_string str; /* Chaîne à conserver */ + + result = pack_uleb128((uleb128_t []){ content->length }, pbuf); + + if (result) + result = extend_packed_buffer(pbuf, content->data, content->length, false); + + if (result) + { + init_static_rle_string(&str, content->full_desc); + + result = pack_rle_string(&str, pbuf); + + exit_rle_string(&str); + + } + + if (result) + { + init_static_rle_string(&str, content->desc); + + result = pack_rle_string(&str, pbuf); + + exit_rle_string(&str); + + } + + return result; + +} diff --git a/src/analysis/contents/restricted-int.h b/src/analysis/contents/restricted-int.h new file mode 100644 index 0000000..ab86359 --- /dev/null +++ b/src/analysis/contents/restricted-int.h @@ -0,0 +1,59 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * restricted-int.h - prototypes internes pour le chargement de données binaires à partir d'un contenu restreint + * + * Copyright (C) 2023 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_RESTRICTED_INT_H +#define _ANALYSIS_CONTENTS_RESTRICTED_INT_H + + +#include "restricted.h" + + +#include "../content-int.h" + + + +/* Contenu de données binaires issues d'un contenu restreint (instance) */ +struct _GRestrictedContent +{ + GBinContent parent; /* A laisser en premier */ + + GBinContent *internal; /* Contenu de sous-traitance */ + + mrange_t range; /* Restriction de couverture */ + +}; + +/* Contenu de données binaires issues d'un contenu restreint (classe) */ +struct _GRestrictedContentClass +{ + GBinContentClass parent; /* A laisser en premier */ + +}; + + +/* Met en place un contenu restreint de données brutes. */ +bool g_restricted_content_create(GRestrictedContent *, GBinContent *, const mrange_t *); + + + +#endif /* _ANALYSIS_CONTENTS_RESTRICTED_INT_H */ diff --git a/src/analysis/contents/restricted.c b/src/analysis/contents/restricted.c index 3e9cbbb..9b4e1c8 100644 --- a/src/analysis/contents/restricted.c +++ b/src/analysis/contents/restricted.c @@ -28,29 +28,15 @@ #include <string.h> -#include "../content-int.h" +#include "restricted-int.h" #include "../db/misc/rlestr.h" #include "../storage/serialize-int.h" +#include "../../common/extstr.h" +#include "../../core/logs.h" -/* Contenu de données binaires issues d'un contenu restreint (instance) */ -struct _GRestrictedContent -{ - GObject parent; /* A laisser en premier */ - - GBinContent *internal; /* Contenu de sous-traitance */ - - mrange_t range; /* Restriction de couverture */ - -}; - -/* Contenu de données binaires issues d'un contenu restreint (classe) */ -struct _GRestrictedContentClass -{ - GObjectClass parent; /* A laisser en premier */ - -}; +/* -------------------------- ENSEMBLE DE DONNEES BINAIRES -------------------------- */ /* Initialise la classe des contenus de données binaires. */ @@ -59,27 +45,29 @@ static void g_restricted_content_class_init(GRestrictedContentClass *); /* Initialise une instance de contenu de données binaires. */ static void g_restricted_content_init(GRestrictedContent *); -/* Procède à l'initialisation de l'interface de sérialisation. */ -static void g_restricted_content_serializable_init(GSerializableObjectInterface *); - -/* Procède à l'initialisation de l'interface de lecture. */ -static void g_restricted_content_interface_init(GBinContentInterface *); - /* Supprime toutes les références externes. */ static void g_restricted_content_dispose(GRestrictedContent *); /* Procède à la libération totale de la mémoire. */ static void g_restricted_content_finalize(GRestrictedContent *); -/* Charge un contenu depuis une mémoire tampon. */ -static bool g_restricted_content_load(GRestrictedContent *, GObjectStorage *, packed_buffer_t *); -/* Sauvegarde un contenu dans une mémoire tampon. */ -static bool g_restricted_content_store(const GRestrictedContent *, GObjectStorage *, packed_buffer_t *); + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Associe un ensemble d'attributs au contenu binaire. */ +static void g_restricted_content_set_attributes(GRestrictedContent *, GContentAttributes *); + +/* Fournit l'ensemble des attributs associés à un contenu. */ +static GContentAttributes *g_restricted_content_get_attributes(const GRestrictedContent *); /* Donne l'origine d'un contenu binaire. */ static GBinContent *g_restricted_content_get_root(GRestrictedContent *); +/* Fournit le nom associé au contenu binaire. */ +static char *g_restricted_content_describe(const GRestrictedContent *, bool); + /* Calcule une empreinte unique (SHA256) pour les données. */ static void g_restricted_content_compute_checksum(GRestrictedContent *, GChecksum *); @@ -122,12 +110,21 @@ static bool g_restricted_content_read_uleb128(const GRestrictedContent *, vmpa2t /* Lit un nombre signé encodé au format LEB128. */ static bool g_restricted_content_read_leb128(const GRestrictedContent *, vmpa2t *, leb128_t *); +/* Charge un contenu depuis une mémoire tampon. */ +static bool g_restricted_content_load(GRestrictedContent *, GObjectStorage *, packed_buffer_t *); + +/* Sauvegarde un contenu dans une mémoire tampon. */ +static bool g_restricted_content_store(const GRestrictedContent *, GObjectStorage *, packed_buffer_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* ENSEMBLE DE DONNEES BINAIRES */ +/* ---------------------------------------------------------------------------------- */ /* Indique le type défini par la GLib pour les contenus de données. */ -G_DEFINE_TYPE_WITH_CODE(GRestrictedContent, g_restricted_content, G_TYPE_OBJECT, - G_IMPLEMENT_INTERFACE(G_TYPE_SERIALIZABLE_OBJECT, g_restricted_content_serializable_init) - G_IMPLEMENT_INTERFACE(G_TYPE_BIN_CONTENT, g_restricted_content_interface_init)); +G_DEFINE_TYPE(GRestrictedContent, g_restricted_content, G_TYPE_BIN_CONTENT); /****************************************************************************** @@ -145,12 +142,45 @@ G_DEFINE_TYPE_WITH_CODE(GRestrictedContent, g_restricted_content, G_TYPE_OBJECT, static void g_restricted_content_class_init(GRestrictedContentClass *klass) { GObjectClass *object; /* Autre version de la classe */ + GBinContentClass *content; /* Version parente de la classe*/ object = G_OBJECT_CLASS(klass); object->dispose = (GObjectFinalizeFunc/* ! */)g_restricted_content_dispose; object->finalize = (GObjectFinalizeFunc)g_restricted_content_finalize; + content = G_BIN_CONTENT_CLASS(klass); + + content->set_attribs = (set_content_attributes)g_restricted_content_set_attributes; + content->get_attribs = (get_content_attributes)g_restricted_content_get_attributes; + + content->get_root = (get_content_root_fc)g_restricted_content_get_root; + + content->describe = (describe_content_fc)g_restricted_content_describe; + + content->compute_checksum = (compute_checksum_fc)g_restricted_content_compute_checksum; + + content->compute_size = (compute_size_fc)g_restricted_content_compute_size; + content->compute_start_pos = (compute_start_pos_fc)g_restricted_content_compute_start_pos; + content->compute_end_pos = (compute_end_pos_fc)g_restricted_content_compute_end_pos; + + content->seek = (seek_fc)g_restricted_content_seek; + + content->get_raw_access = (get_raw_access_fc)g_restricted_content_get_raw_access; + + content->read_raw = (read_raw_fc)g_restricted_content_read_raw; + content->read_u4 = (read_u4_fc)g_restricted_content_read_u4; + content->read_u8 = (read_u8_fc)g_restricted_content_read_u8; + content->read_u16 = (read_u16_fc)g_restricted_content_read_u16; + content->read_u32 = (read_u32_fc)g_restricted_content_read_u32; + content->read_u64 = (read_u64_fc)g_restricted_content_read_u64; + + content->read_uleb128 = (read_uleb128_fc)g_restricted_content_read_uleb128; + content->read_leb128 = (read_leb128_fc)g_restricted_content_read_leb128; + + content->load = (load_content_cb)g_restricted_content_load; + content->store = (store_content_cb)g_restricted_content_store; + } @@ -180,9 +210,9 @@ static void g_restricted_content_init(GRestrictedContent *content) /****************************************************************************** * * -* Paramètres : iface = interface GLib à initialiser. * +* Paramètres : content = instance d'objet GLib à traiter. * * * -* Description : Procède à l'initialisation de l'interface de sérialisation. * +* Description : Supprime toutes les références externes. * * * * Retour : - * * * @@ -190,19 +220,20 @@ static void g_restricted_content_init(GRestrictedContent *content) * * ******************************************************************************/ -static void g_restricted_content_serializable_init(GSerializableObjectInterface *iface) +static void g_restricted_content_dispose(GRestrictedContent *content) { - iface->load = (load_serializable_object_cb)g_restricted_content_load; - iface->store = (store_serializable_object_cb)g_restricted_content_store; + g_clear_object(&content->internal); + + G_OBJECT_CLASS(g_restricted_content_parent_class)->dispose(G_OBJECT(content)); } /****************************************************************************** * * -* Paramètres : iface = interface GLib à initialiser. * +* Paramètres : content = instance d'objet GLib à traiter. * * * -* Description : Procède à l'initialisation de l'interface de lecture. * +* Description : Procède à la libération totale de la mémoire. * * * * Retour : - * * * @@ -210,154 +241,134 @@ static void g_restricted_content_serializable_init(GSerializableObjectInterface * * ******************************************************************************/ -static void g_restricted_content_interface_init(GBinContentInterface *iface) +static void g_restricted_content_finalize(GRestrictedContent *content) { - iface->get_root = (get_content_root_fc)g_restricted_content_get_root; - - iface->compute_checksum = (compute_checksum_fc)g_restricted_content_compute_checksum; - - iface->compute_size = (compute_size_fc)g_restricted_content_compute_size; - iface->compute_start_pos = (compute_start_pos_fc)g_restricted_content_compute_start_pos; - iface->compute_end_pos = (compute_end_pos_fc)g_restricted_content_compute_end_pos; - - iface->seek = (seek_fc)g_restricted_content_seek; - - iface->get_raw_access = (get_raw_access_fc)g_restricted_content_get_raw_access; - - iface->read_raw = (read_raw_fc)g_restricted_content_read_raw; - iface->read_u4 = (read_u4_fc)g_restricted_content_read_u4; - iface->read_u8 = (read_u8_fc)g_restricted_content_read_u8; - iface->read_u16 = (read_u16_fc)g_restricted_content_read_u16; - iface->read_u32 = (read_u32_fc)g_restricted_content_read_u32; - iface->read_u64 = (read_u64_fc)g_restricted_content_read_u64; - - iface->read_uleb128 = (read_uleb128_fc)g_restricted_content_read_uleb128; - iface->read_leb128 = (read_leb128_fc)g_restricted_content_read_leb128; + G_OBJECT_CLASS(g_restricted_content_parent_class)->finalize(G_OBJECT(content)); } /****************************************************************************** * * -* Paramètres : content = instance d'objet GLib à traiter. * +* Paramètres : internal = contenu binaire où puiser les données à fournir. * +* range = espace de restrictions pour les accès. * * * -* Description : Supprime toutes les références externes. * +* Description : Charge en mémoire le contenu d'un contenu restreint. * * * -* Retour : - * +* Retour : Représentation de contenu à manipuler ou NULL en cas d'échec.* * * * Remarques : - * * * ******************************************************************************/ -static void g_restricted_content_dispose(GRestrictedContent *content) +GBinContent *g_restricted_content_new(GBinContent *internal, const mrange_t *range) { - g_clear_object(&content->internal); + GBinContent *result; /* Structure à retourner */ - G_OBJECT_CLASS(g_restricted_content_parent_class)->dispose(G_OBJECT(content)); + result = g_object_new(G_TYPE_RESTRICTED_CONTENT, NULL); + + if (!g_restricted_content_create(G_RESTRICTED_CONTENT(result), internal, range)) + g_clear_object(&result); + + return result; } /****************************************************************************** * * -* Paramètres : content = instance d'objet GLib à traiter. * +* Paramètres : content = instance à initialiser pleinement. * +* base = contenu binaire d'où réaliser une extraction. * +* path = chemin vers le contenu finalement ciblé. * +* endpoint = contenu final rendu accessible. * * * -* Description : Procède à la libération totale de la mémoire. * +* Description : Met en place un contenu restreint de données brutes. * * * -* Retour : - * +* Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ -static void g_restricted_content_finalize(GRestrictedContent *content) +bool g_restricted_content_create(GRestrictedContent *content, GBinContent *internal, const mrange_t *range) { - G_OBJECT_CLASS(g_restricted_content_parent_class)->finalize(G_OBJECT(content)); + bool result; /* Bilan à retourner */ + + content->internal = internal; + g_object_ref(G_OBJECT(content->internal)); + + copy_mrange(&content->range, range); + + result = true; + + return result; } /****************************************************************************** * * -* Paramètres : content = contenu binaire où puiser les données à fournir. * -* range = espace de restrictions pour les accès. * +* Paramètres : content = contenu binaire à venir lire. * +* range = espace de restrictions pour les accès. [OUT] * * * -* Description : Charge en mémoire le contenu d'un contenu restreint. * +* Description : Indique l'espace de restriction appliqué à un contenu. * * * -* Retour : Représentation de contenu à manipuler ou NULL en cas d'échec.* +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -GBinContent *g_restricted_content_new(GBinContent *content, const mrange_t *range) +void g_restricted_content_get_range(const GRestrictedContent *content, mrange_t *range) { - GRestrictedContent *result; /* Structure à retourner */ - - result = g_object_new(G_TYPE_RESTRICTED_CONTENT, NULL); + copy_mrange(range, &content->range); - result->internal = content; - g_object_ref(G_OBJECT(result->internal)); +} - copy_mrange(&result->range, range); - return G_BIN_CONTENT(result); -} +/* ---------------------------------------------------------------------------------- */ +/* INTERACTIONS AVEC UN CONTENU BINAIRE */ +/* ---------------------------------------------------------------------------------- */ /****************************************************************************** * * -* Paramètres : content = contenu binaire où puiser les données à fournir. * -* range = espace de restrictions pour les accès. * +* Paramètres : content = contenu binaire à actualiser. * +* attribs = jeu d'attributs à lier au contenu courant. * * * -* Description : Charge en mémoire le contenu d'un contenu restreint. * +* Description : Associe un ensemble d'attributs au contenu binaire. * * * -* Retour : Représentation de contenu à manipuler ou NULL en cas d'échec.* +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -GBinContent *g_restricted_content_new_ro(const GBinContent *content, const mrange_t *range) +static void g_restricted_content_set_attributes(GRestrictedContent *content, GContentAttributes *attribs) { - GRestrictedContent *result; /* Structure à retourner */ - - result = g_object_new(G_TYPE_RESTRICTED_CONTENT, NULL); - - result->internal = (GBinContent *)content; - g_object_ref(G_OBJECT(result->internal)); - - copy_mrange(&result->range, range); - - return G_BIN_CONTENT(result); + g_binary_content_set_attributes(content->internal, attribs); } /****************************************************************************** * * -* Paramètres : content = élément GLib à constuire. * -* storage = conservateur de données à manipuler ou NULL. * -* pbuf = zone tampon à lire. * +* Paramètres : content = contenu binaire à consulter. * * * -* Description : Charge un contenu depuis une mémoire tampon. * +* Description : Fournit l'ensemble des attributs associés à un contenu. * * * -* Retour : Bilan de l'opération. * +* Retour : Jeu d'attributs liés au contenu courant. * * * * Remarques : - * * * ******************************************************************************/ -static bool g_restricted_content_load(GRestrictedContent *content, GObjectStorage *storage, packed_buffer_t *pbuf) +static GContentAttributes *g_restricted_content_get_attributes(const GRestrictedContent *content) { - bool result; /* Bilan à retourner */ - - content->internal = G_BIN_CONTENT(g_object_storage_unpack_object(storage, "contents", pbuf)); - result = (content->internal != NULL); + GContentAttributes *result; /* Instance à retourner */ - if (result) - result = unpack_mrange(&content->range, pbuf); + result = g_binary_content_get_attributes(content->internal); return result; @@ -366,26 +377,21 @@ static bool g_restricted_content_load(GRestrictedContent *content, GObjectStorag /****************************************************************************** * * -* Paramètres : content = élément GLib à consulter. * -* storage = conservateur de données à manipuler ou NULL. * -* pbuf = zone tampon à remplir. * +* Paramètres : content = contenu binaire à consulter. * * * -* Description : Sauvegarde un contenu dans une mémoire tampon. * +* Description : Donne l'origine d'un contenu binaire. * * * -* Retour : Bilan de l'opération. * +* Retour : Contenu à l'origine du contenu courant. * * * * Remarques : - * * * ******************************************************************************/ -static bool g_restricted_content_store(const GRestrictedContent *content, GObjectStorage *storage, packed_buffer_t *pbuf) +static GBinContent *g_restricted_content_get_root(GRestrictedContent *content) { - bool result; /* Bilan à retourner */ - - result = g_object_storage_pack_object(storage, "contents", G_SERIALIZABLE_OBJECT(content->internal), pbuf); + GBinContent *result; /* Contenu en place à renvoyer */ - if (result) - result = pack_mrange(&content->range, pbuf); + result = g_binary_content_get_root(content->internal); return result; @@ -395,20 +401,48 @@ static bool g_restricted_content_store(const GRestrictedContent *content, GObjec /****************************************************************************** * * * Paramètres : content = contenu binaire à consulter. * +* full = précise s'il s'agit d'une version longue ou non. * * * -* Description : Donne l'origine d'un contenu binaire. * +* Description : Fournit le nom associé au contenu binaire. * * * -* Retour : Contenu à l'origine du contenu courant. * +* Retour : Nom de fichier avec chemin absolu au besoin. * * * * Remarques : - * * * ******************************************************************************/ -static GBinContent *g_restricted_content_get_root(GRestrictedContent *content) +static char *g_restricted_content_describe(const GRestrictedContent *content, bool full) { - GBinContent *result; /* Contenu en place à renvoyer */ + char *result; /* Description à retourner */ + VMPA_BUFFER(start_str); /* Zone de départ en texte */ + vmpa2t end; /* Position de fin */ + VMPA_BUFFER(end_str); /* Zone de départ en texte */ + char *suffix; /* Construction d'un appendice */ + int ret; /* Bilan de construction */ - result = g_binary_content_get_root(content->internal); + result = g_binary_content_describe(content->internal, full); + + vmpa2_to_string(get_mrange_addr(&content->range), MDS_UNDEFINED, start_str, NULL); + + compute_mrange_end_addr(&content->range, &end); + + vmpa2_to_string(&end, MDS_UNDEFINED, end_str, NULL); + + ret = asprintf(&suffix, "[%s:%s]", start_str, end_str); + + if (ret == -1) + LOG_ERROR_N("asprintf"); + + else + { + if (result != NULL) + result = stradd(result, " "); + + result = stradd(result, suffix); + + free(suffix); + + } return result; @@ -932,19 +966,56 @@ static bool g_restricted_content_read_leb128(const GRestrictedContent *content, /****************************************************************************** * * -* Paramètres : content = contenu binaire à venir lire. * -* range = espace de restrictions pour les accès. [OUT] * +* Paramètres : content = élément GLib à constuire. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à lire. * * * -* Description : Indique l'espace de restriction appliqué à un contenu. * +* Description : Charge un contenu depuis une mémoire tampon. * * * -* Retour : - * +* Retour : Bilan de l'opération. * * * * Remarques : - * * * ******************************************************************************/ -void g_restricted_content_get_range(const GRestrictedContent *content, mrange_t *range) +static bool g_restricted_content_load(GRestrictedContent *content, GObjectStorage *storage, packed_buffer_t *pbuf) { - copy_mrange(range, &content->range); + bool result; /* Bilan à retourner */ + + content->internal = G_BIN_CONTENT(g_object_storage_unpack_object(storage, "contents", pbuf)); + result = (content->internal != NULL); + + if (result) + result = unpack_mrange(&content->range, pbuf); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : content = élément GLib à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un contenu dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_restricted_content_store(const GRestrictedContent *content, GObjectStorage *storage, packed_buffer_t *pbuf) +{ + bool result; /* Bilan à retourner */ + + result = g_object_storage_pack_object(storage, "contents", G_SERIALIZABLE_OBJECT(content->internal), pbuf); + + if (result) + result = pack_mrange(&content->range, pbuf); + + return result; } diff --git a/src/analysis/contents/restricted.h b/src/analysis/contents/restricted.h index 402282a..1cea390 100644 --- a/src/analysis/contents/restricted.h +++ b/src/analysis/contents/restricted.h @@ -53,9 +53,6 @@ GType g_restricted_content_get_type(void); /* Charge en mémoire le contenu d'un contenu restreint. */ GBinContent *g_restricted_content_new(GBinContent *, const mrange_t *); -/* Charge en mémoire le contenu d'un contenu restreint. */ -GBinContent *g_restricted_content_new_ro(const GBinContent *, const mrange_t *); - /* Indique l'espace de restriction appliqué à un contenu. */ void g_restricted_content_get_range(const GRestrictedContent *, mrange_t *); |