diff options
author | Cyrille Bagard <nocbos@gmail.com> | 2025-03-07 09:29:32 (GMT) |
---|---|---|
committer | Cyrille Bagard <nocbos@gmail.com> | 2025-03-10 06:27:26 (GMT) |
commit | a59fb1b3fb67a348c40bc3668445d64213e9e674 (patch) | |
tree | fcf493a6b1758c666b95a9c1c645beecc8e42a14 /plugins/pychrysalide/glibext | |
parent | e0614e482b3ca3faf43e296bb70348be0d651394 (diff) |
Prepare a new way to store objects.
Diffstat (limited to 'plugins/pychrysalide/glibext')
-rw-r--r-- | plugins/pychrysalide/glibext/serialize.c | 501 | ||||
-rw-r--r-- | plugins/pychrysalide/glibext/serialize.h | 45 | ||||
-rw-r--r-- | plugins/pychrysalide/glibext/storage.c | 687 | ||||
-rw-r--r-- | plugins/pychrysalide/glibext/storage.h | 48 | ||||
-rw-r--r-- | plugins/pychrysalide/glibext/tpmem.c | 508 | ||||
-rw-r--r-- | plugins/pychrysalide/glibext/tpmem.h | 45 |
6 files changed, 1834 insertions, 0 deletions
diff --git a/plugins/pychrysalide/glibext/serialize.c b/plugins/pychrysalide/glibext/serialize.c new file mode 100644 index 0000000..40fcef7 --- /dev/null +++ b/plugins/pychrysalide/glibext/serialize.c @@ -0,0 +1,501 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * serialize.c - équivalent Python du fichier "analysis/storage/serialize.h" + * + * Copyright (C) 2020 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "serialize.h" + + +#include <pygobject.h> + + +#include <analysis/storage/serialize-int.h> + + +#include "storage.h" +#include "../../access.h" +#include "../../helpers.h" +#include "../../common/packed.h" + + + +/* ------------------------ GLUE POUR CREATION DEPUIS PYTHON ------------------------ */ + + +/* Procède à l'initialisation de l'interface de génération. */ +static void py_serializable_object_interface_init(GSerializableObjectIface *, gpointer *); + +/* Charge un objet depuis une mémoire tampon. */ +static bool py_serializable_object_load_wrapper(GSerializableObject *, GObjectStorage *, packed_buffer_t *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool py_serializable_object_store_wrapper(const GSerializableObject *, GObjectStorage *, packed_buffer_t *); + + + +/* ------------------------- CONNEXION AVEC L'API DE PYTHON ------------------------- */ + + +/* Charge un objet depuis une mémoire tampon. */ +static bool py_serializable_object_load(PyObject *, PyObject *); + +/* Sauvegarde un objet dans une mémoire tampon. */ +static bool py_serializable_object_store(PyObject *, PyObject *); + + + +/* ---------------------------------------------------------------------------------- */ +/* GLUE POUR CREATION DEPUIS PYTHON */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : iface = interface GLib à initialiser. * +* unused = adresse non utilisée ici. * +* * +* Description : Procède à l'initialisation de l'interface de génération. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void py_serializable_object_interface_init(GSerializableObjectIface *iface, gpointer *unused) +{ + +#define SERIALIZABLE_OBJECT_DOC \ + "SerializableObject defines an interface used to store and load" \ + " objects to and from a data buffer.\n" \ + "\n" \ + "A typical class declaration for a new implementation looks like:\n" \ + "\n" \ + " class NewImplem(GObject.Object, SerializableObject):\n" \ + " ...\n" \ + "\n" \ + "The following methods have to be defined for new implementations:\n" \ + "* pychrysalide.analysis.storage.SerializableObject._load();\n" \ + "* pychrysalide.analysis.storage.SerializableObject._store();\n" + + iface->load = py_serializable_object_load_wrapper; + iface->store = py_serializable_object_store_wrapper; + +} + + +/****************************************************************************** +* * +* Paramètres : object = instruction d'assemblage à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool py_serializable_object_load_wrapper(GSerializableObject *object, GObjectStorage *storage, packed_buffer_t *pbuf) +{ + bool result; /* Bilan à retourner */ + PyGILState_STATE gstate; /* Sauvegarde d'environnement */ + PyObject *storage_obj; /* Objet Python à emmployer */ + PyObject *args; /* Arguments pour l'appel */ + PyObject *pyobj; /* Objet Python concerné */ + PyObject *pyret; /* Bilan de consultation */ + +#define SERIALIZABLE_OBJECT_LOAD_WRAPPER PYTHON_WRAPPER_DEF \ +( \ + _load, "$self, storage, pbuf, /", \ + METH_VARARGS, \ + "Abstract method used to load an object definition from buffered data.\n" \ + "\n" \ + "The *storage* is a pychrysalide.analysis.storage.ObjectStorage instance" \ + " provided to store inner objects, if relevant, or None. The *pbuf*" \ + " argument points to a pychrysalide.common.PackedBuffer object containing" \ + " the data to process.\n" \ + "\n" \ + "The result is a boolean indicating the status of the operation." \ +) + + result = false; + + gstate = PyGILState_Ensure(); + + pyobj = pygobject_new(G_OBJECT(object)); + + if (has_python_method(pyobj, "_load")) + { + if (storage == NULL) + { + storage_obj = Py_None; + Py_INCREF(storage_obj); + } + else + storage_obj = pygobject_new(G_OBJECT(storage)); + + args = PyTuple_New(2); + PyTuple_SetItem(args, 0, storage_obj); + PyTuple_SetItem(args, 1, build_from_internal_packed_buffer(pbuf)); + + pyret = run_python_method(pyobj, "_load", args); + + result = (pyret == Py_True ? true : false); + + Py_XDECREF(pyret); + + Py_DECREF(args); + + } + + Py_DECREF(pyobj); + + PyGILState_Release(gstate); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : object = instruction d'assemblage à consulter. * +* storage = conservateur de données à manipuler ou NULL. * +* pbuf = zone tampon à remplir. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool py_serializable_object_store_wrapper(const GSerializableObject *object, GObjectStorage *storage, packed_buffer_t *pbuf) +{ + bool result; /* Bilan à retourner */ + PyGILState_STATE gstate; /* Sauvegarde d'environnement */ + PyObject *storage_obj; /* Objet Python à emmployer */ + PyObject *args; /* Arguments pour l'appel */ + PyObject *pyobj; /* Objet Python concerné */ + PyObject *pyret; /* Bilan de consultation */ + +#define SERIALIZABLE_OBJECT_STORE_WRAPPER PYTHON_WRAPPER_DEF \ +( \ + _store, "$self, storage, pbuf, /", \ + METH_VARARGS, \ + "Abstract method used to store an object definition into buffered data.\n" \ + "\n" \ + "The *storage* is a pychrysalide.analysis.storage.ObjectStorage instance" \ + " provided to store inner objects, if relevant, or None. The *pbuf*" \ + " argument points to a pychrysalide.common.PackedBuffer object containing" \ + " the data to process.\n" \ + "\n" \ + "The result is a boolean indicating the status of the operation." \ +) + + result = false; + + gstate = PyGILState_Ensure(); + + pyobj = pygobject_new(G_OBJECT(object)); + + if (has_python_method(pyobj, "_store")) + { + if (storage == NULL) + { + storage_obj = Py_None; + Py_INCREF(storage_obj); + } + else + storage_obj = pygobject_new(G_OBJECT(storage)); + + args = PyTuple_New(2); + PyTuple_SetItem(args, 0, storage_obj); + PyTuple_SetItem(args, 1, build_from_internal_packed_buffer(pbuf)); + + pyret = run_python_method(pyobj, "_store", args); + + result = (pyret == Py_True ? true : false); + + Py_XDECREF(pyret); + + Py_DECREF(args); + + } + + Py_DECREF(pyobj); + + PyGILState_Release(gstate); + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* CONNEXION AVEC L'API DE PYTHON */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : self = classe représentant un générateur à manipuler. * +* args = arguments fournis à l'appel. * +* * +* Description : Charge un objet depuis une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool py_serializable_object_load(PyObject *self, PyObject *args) +{ + PyObject *result; /* Bilan à retourner */ + GObjectStorage *storage; /* Conservateur à manipuler */ + packed_buffer_t *pbuf; /* Tampon de données à employer*/ + int ret; /* Bilan de lecture des args. */ + GSerializableObject *object; /* Version native */ + bool status; /* Bilan de l'opération */ + +#define SERIALIZABLE_OBJECT_LOAD_METHOD PYTHON_METHOD_DEF \ +( \ + load, "$self, storage, pbuf, /", \ + METH_VARARGS, py_serializable_object, \ + "Load an object definition from buffered data.\n" \ + "\n" \ + "The *storage* is a pychrysalide.analysis.storage.ObjectStorage instance" \ + " provided to store inner objects, if relevant, or None. The *pbuf*" \ + " argument points to a pychrysalide.common.PackedBuffer object containing" \ + " the data to process.\n" \ + "\n" \ + "The result is a boolean indicating the status of the operation." \ +) + + ret = PyArg_ParseTuple(args, "O&O&", convert_to_object_storage_or_none, &storage, + convert_to_packed_buffer, &pbuf); + if (!ret) return NULL; + + object = G_SERIALIZABLE_OBJECT(pygobject_get(self)); + + status = g_serializable_object_load(object, storage, pbuf); + + result = status ? Py_True : Py_False; + Py_INCREF(result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = classe représentant un générateur à manipuler. * +* args = arguments fournis à l'appel. * +* * +* Description : Sauvegarde un objet dans une mémoire tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool py_serializable_object_store(PyObject *self, PyObject *args) +{ + PyObject *result; /* Bilan à retourner */ + GObjectStorage *storage; /* Conservateur à manipuler */ + packed_buffer_t *pbuf; /* Tampon de données à employer*/ + int ret; /* Bilan de lecture des args. */ + GSerializableObject *object; /* Version native */ + bool status; /* Bilan de l'opération */ + +#define SERIALIZABLE_OBJECT_STORE_METHOD PYTHON_METHOD_DEF \ +( \ + store, "$self, storage, pbuf, /", \ + METH_VARARGS, py_serializable_object, \ + "Store an object definition into buffered data.\n" \ + "\n" \ + "The *storage* is a pychrysalide.analysis.storage.ObjectStorage instance" \ + " provided to store inner objects, if relevant, or None. The *pbuf*" \ + " argument points to a pychrysalide.common.PackedBuffer object containing" \ + " the data to process.\n" \ + "\n" \ + "The result is a boolean indicating the status of the operation." \ +) + + ret = PyArg_ParseTuple(args, "O&O&", convert_to_object_storage_or_none, &storage, + convert_to_packed_buffer, &pbuf); + if (!ret) return NULL; + + object = G_SERIALIZABLE_OBJECT(pygobject_get(self)); + + status = g_serializable_object_store(object, storage, pbuf); + + result = status ? Py_True : Py_False; + Py_INCREF(result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Fournit un accès à une définition de type à diffuser. * +* * +* Retour : Définition d'objet pour Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +PyTypeObject *get_python_serializable_object_type(void) +{ + static PyMethodDef py_serializable_object_methods[] = { + SERIALIZABLE_OBJECT_LOAD_WRAPPER, + SERIALIZABLE_OBJECT_STORE_WRAPPER, + SERIALIZABLE_OBJECT_LOAD_METHOD, + SERIALIZABLE_OBJECT_STORE_METHOD, + { NULL } + }; + + static PyGetSetDef py_serializable_object_getseters[] = { + { NULL } + }; + + static PyTypeObject py_serializable_object_type = { + + PyVarObject_HEAD_INIT(NULL, 0) + + .tp_name = "pychrysalide.analysis.storage.SerializableObject", + .tp_basicsize = sizeof(PyObject), + + .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, + + .tp_doc = SERIALIZABLE_OBJECT_DOC, + + .tp_methods = py_serializable_object_methods, + .tp_getset = py_serializable_object_getseters, + + }; + + return &py_serializable_object_type; + +} + + +/****************************************************************************** +* * +* Paramètres : module = module dont la définition est à compléter. * +* * +* Description : Prend en charge l'objet 'pychrysalide....SerializableObject'.* +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool ensure_python_serializable_object_is_registered(void) +{ + PyTypeObject *type; /* Type 'SerializableObject' */ + PyObject *module; /* Module à recompléter */ + PyObject *dict; /* Dictionnaire du module */ + + static GInterfaceInfo info = { /* Paramètres d'inscription */ + + .interface_init = (GInterfaceInitFunc)py_serializable_object_interface_init, + .interface_finalize = NULL, + .interface_data = NULL, + + }; + + type = get_python_serializable_object_type(); + + if (!PyType_HasFeature(type, Py_TPFLAGS_READY)) + { + module = get_access_to_python_module("pychrysalide.analysis.storage"); + + dict = PyModule_GetDict(module); + + if (!register_interface_for_pygobject(dict, G_TYPE_SERIALIZABLE_OBJECT, type, &info)) + return false; + + } + + return true; + +} + + +/****************************************************************************** +* * +* Paramètres : arg = argument quelconque à tenter de convertir. * +* dst = destination des valeurs récupérées en cas de succès. * +* * +* Description : Tente de convertir en objet adapté à une mise en cache. * +* * +* Retour : Bilan de l'opération, voire indications supplémentaires. * +* * +* Remarques : - * +* * +******************************************************************************/ + +int convert_to_serializable_object(PyObject *arg, void *dst) +{ + int result; /* Bilan à retourner */ + + result = PyObject_IsInstance(arg, (PyObject *)get_python_serializable_object_type()); + + switch (result) + { + case -1: + /* L'exception est déjà fixée par Python */ + result = 0; + break; + + case 0: + PyErr_SetString(PyExc_TypeError, "unable to convert the provided argument to serializable object"); + break; + + case 1: + *((GSerializableObject **)dst) = G_SERIALIZABLE_OBJECT(pygobject_get(arg)); + break; + + default: + assert(false); + break; + + } + + return result; + +} diff --git a/plugins/pychrysalide/glibext/serialize.h b/plugins/pychrysalide/glibext/serialize.h new file mode 100644 index 0000000..7e831e5 --- /dev/null +++ b/plugins/pychrysalide/glibext/serialize.h @@ -0,0 +1,45 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * serialize.h - prototypes pour l'équivalent Python du fichier "analysis/storage/serialize.h" + * + * Copyright (C) 2020 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _PLUGINS_PYCHRYSALIDE_ANALYSIS_STORAGE_SERIALIZE_H +#define _PLUGINS_PYCHRYSALIDE_ANALYSIS_STORAGE_SERIALIZE_H + + +#include <Python.h> +#include <stdbool.h> + + + +/* Fournit un accès à une définition de type à diffuser. */ +PyTypeObject *get_python_serializable_object_type(void); + +/* Prend en charge l'objet 'pychrysalide.analysis.storage.SerializableObject'. */ +bool ensure_python_serializable_object_is_registered(void); + +/* Tente de convertir en objet adapté à une mise en cache. */ +int convert_to_serializable_object(PyObject *, void *); + + + +#endif /* _PLUGINS_PYCHRYSALIDE_ANALYSIS_STORAGE_SERIALIZE_H */ diff --git a/plugins/pychrysalide/glibext/storage.c b/plugins/pychrysalide/glibext/storage.c new file mode 100644 index 0000000..c54fe0f --- /dev/null +++ b/plugins/pychrysalide/glibext/storage.c @@ -0,0 +1,687 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * storage.c - équivalent Python du fichier "analysis/storage/storage.c" + * + * Copyright (C) 2020 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "storage.h" + + +#include <pygobject.h> + + +#include <analysis/storage/storage-int.h> +#include <plugins/dt.h> + + +#include "serialize.h" +#include "../../access.h" +#include "../../helpers.h" +#include "../../common/packed.h" + + + +/* ------------------------ GLUE POUR CREATION DEPUIS PYTHON ------------------------ */ + + +/* Accompagne la création d'une instance dérivée en Python. */ +static PyObject *py_object_storage_new(PyTypeObject *, PyObject *, PyObject *); + +/* Initialise une instance sur la base du dérivé de GObject. */ +static int py_object_storage_init(PyObject *, PyObject *, PyObject *); + + + +/* -------------------------- TAMPON POUR CODE DESASSEMBLE -------------------------- */ + + +/* Charge le support d'une conservation d'objets en place. */ +static PyObject *py_object_storage_load(PyObject *, PyObject *); + +/* Sauvegarde le support d'une conservation d'objets en place. */ +static PyObject *py_object_storage_store(PyObject *, PyObject *); + +/* Charge un objet à partir de données rassemblées. */ +static PyObject *py_object_storage_load_object(PyObject *, PyObject *); + +/* Charge un objet interne à partir de données rassemblées. */ +static PyObject *py_object_storage_unpack_object(PyObject *, PyObject *); + +/* Sauvegarde un object sous forme de données rassemblées. */ +static PyObject *py_object_storage_store_object(PyObject *, PyObject *); + +/* Sauvegarde un object interne sous forme de données. */ +static PyObject *py_object_storage_pack_object(PyObject *, PyObject *); + + + +/* ---------------------------------------------------------------------------------- */ +/* GLUE POUR CREATION DEPUIS PYTHON */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : type = type du nouvel objet à mettre en place. * +* args = éventuelle liste d'arguments. * +* kwds = éventuel dictionnaire de valeurs mises à disposition. * +* * +* Description : Accompagne la création d'une instance dérivée en Python. * +* * +* Retour : Nouvel objet Python mis en place ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_object_storage_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *result; /* Objet à retourner */ + PyTypeObject *base; /* Type de base à dériver */ + bool first_time; /* Evite les multiples passages*/ + GType gtype; /* Nouveau type de processeur */ + bool status; /* Bilan d'un enregistrement */ + + /* Validations diverses */ + + base = get_python_object_storage_type(); + + if (type == base) + goto simple_way; + + /* Mise en place d'un type dédié */ + + first_time = (g_type_from_name(type->tp_name) == 0); + + gtype = build_dynamic_type(G_TYPE_OBJECT_STORAGE, type->tp_name, NULL, NULL, NULL); + + if (first_time) + { + status = register_class_for_dynamic_pygobject(gtype, type); + + if (!status) + { + result = NULL; + goto exit; + } + + } + + /* On crée, et on laisse ensuite la main à PyGObject_Type.tp_init() */ + + simple_way: + + result = PyType_GenericNew(type, args, kwds); + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = objet à initialiser (théoriquement). * +* args = arguments fournis à l'appel. * +* kwds = arguments de type key=val fournis. * +* * +* Description : Initialise une instance sur la base du dérivé de GObject. * +* * +* Retour : 0. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static int py_object_storage_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + const char *hash; /* Empreinte de contenu */ + int ret; /* Bilan de lecture des args. */ + GObjectStorage *storage; /* Mécanismes natifs */ + +#define OBJECT_STORAGE_DOC \ + "The ObjectStorage object manages the generic storage of GLib" \ + " objects through serialization.\n" \ + "\n" \ + "Instances can be created using the following constructor:\n" \ + "\n" \ + " ObjectStorage(hash)" \ + "\n" \ + "Where *hash* should a string built from the checksum of the" \ + " relative binary content linked to the storage.pychrysalide." + + /* Récupération des paramètres */ + + ret = PyArg_ParseTuple(args, "s", &hash); + if (!ret) return -1; + + /* Initialisation d'un objet GLib */ + + ret = forward_pygobjet_init(self); + if (ret == -1) return -1; + + /* Eléments de base */ + + storage = G_OBJECT_STORAGE(pygobject_get(self)); + + storage->hash = strdup(hash); + + return 0; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* TAMPON POUR CODE DESASSEMBLE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : self = classe représentant une mémorisation de types. * +* args = arguments fournis à l'appel. * +* * +* Description : Charge le support d'une conservation d'objets en place. * +* * +* Retour : Gestionnaire de conservations construit ou None si erreur. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_object_storage_load(PyObject *self, PyObject *args) +{ + PyObject *result; /* Emplacement à retourner */ + packed_buffer_t *pbuf; /* Tampon de données à employer*/ + int ret; /* Bilan de lecture des args. */ + GObjectStorage *storage; /* Mécanismes natifs */ + +#define OBJECT_STORAGE_LOAD_METHOD PYTHON_METHOD_DEF \ +( \ + load, "pbuf, /", \ + METH_STATIC | METH_VARARGS, py_object_storage, \ + "Construct a new storage from a buffer.\n" \ + "\n" \ + "The *pbuf* has to be an instance of type" \ + " pychrysalide.common.PackedBuffer.\n" \ + "\n" \ + "The result is a new pychrysalide.analysis.storage.ObjectStorage" \ + " object on success, *None* otherwise." \ +) + + ret = PyArg_ParseTuple(args, "O&", convert_to_packed_buffer, &pbuf); + if (!ret) return NULL; + + storage = g_object_storage_load(pbuf); + + if (storage == NULL) + { + result = Py_None; + Py_INCREF(result); + } + else + { + result = pygobject_new(G_OBJECT(storage)); + g_object_unref(G_OBJECT(storage)); + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = classe représentant une mémorisation de types. * +* args = arguments fournis à l'appel. * +* * +* Description : Sauvegarde le support d'une conservation d'objets en place. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_object_storage_store(PyObject *self, PyObject *args) +{ + PyObject *result; /* Emplacement à retourner */ + packed_buffer_t *pbuf; /* Tampon de données à employer*/ + int ret; /* Bilan de lecture des args. */ + GObjectStorage *storage; /* Mécanismes natifs */ + bool status; /* Bilan de l'opération */ + +#define OBJECT_STORAGE_STORE_METHOD PYTHON_METHOD_DEF \ +( \ + store, "$self, pbuf, /", \ + METH_VARARGS, py_object_storage, \ + "Save a storage into a buffer.\n" \ + "\n" \ + "The *pbuf* has to be an instance of type" \ + " pychrysalide.common.PackedBuffer.\n" \ + "\n" \ + "The result is *True* on success, *False* otherwise." \ +) + + ret = PyArg_ParseTuple(args, "O&", convert_to_packed_buffer, &pbuf); + if (!ret) return NULL; + + storage = G_OBJECT_STORAGE(pygobject_get(self)); + + status = g_object_storage_store(storage, pbuf); + + result = status ? Py_True : Py_False; + Py_INCREF(result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = classe représentant une mémorisation de types. * +* args = arguments fournis à l'appel. * +* * +* Description : Charge un objet à partir de données rassemblées. * +* * +* Retour : Objet restauré en mémoire ou None en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_object_storage_load_object(PyObject *self, PyObject *args) +{ + PyObject *result; /* Bilan à retourner */ + const char *name; /* Désignation de groupe */ + unsigned long long pos; /* Emplacement des données */ + int ret; /* Bilan de lecture des args. */ + GObjectStorage *storage; /* Mécanismes natifs */ + GSerializableObject *object; /* Objet reconstruit ou NULL */ + +#define OBJECT_STORAGE_LOAD_OBJECT_METHOD PYTHON_METHOD_DEF \ +( \ + load_object, "$self, name, pos, /", \ + METH_VARARGS, py_object_storage, \ + "Load an object from serialized data.\n" \ + "\n" \ + "The *name* is a string label for the group of target objects and" \ + " *pos* is an offset into the data stream indicating the start of" \ + " the data to unserialize.\n" \ + "\n" \ + "The result is a pychrysalide.analysis.storage.SerializableObject" \ + " instancet in case of success, or None in case of failure." \ +) + + ret = PyArg_ParseTuple(args, "sK", &name, &pos); + if (!ret) return NULL; + + storage = G_OBJECT_STORAGE(pygobject_get(self)); + + object = g_object_storage_load_object(storage, name, pos); + + if (object != NULL) + result = pygobject_new(G_OBJECT(object)); + else + { + result = Py_None; + Py_INCREF(result); + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = classe représentant une mémorisation de types. * +* args = arguments fournis à l'appel. * +* * +* Description : Charge un objet interne à partir de données rassemblées. * +* * +* Retour : Objet restauré en mémoire ou None en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_object_storage_unpack_object(PyObject *self, PyObject *args) +{ + PyObject *result; /* Bilan à retourner */ + const char *name; /* Désignation de groupe */ + packed_buffer_t *pbuf; /* Tampon de données à employer*/ + int ret; /* Bilan de lecture des args. */ + GObjectStorage *storage; /* Mécanismes natifs */ + GSerializableObject *object; /* Objet reconstruit ou NULL */ + +#define OBJECT_STORAGE_UNPACK_OBJECT_METHOD PYTHON_METHOD_DEF \ +( \ + unpack_object, "$self, name, pbuf, /", \ + METH_VARARGS, py_object_storage, \ + "Load an object from a buffer with a location pointing to data.\n" \ + "\n" \ + "The *name* is a string label for the group of target objects and" \ + " *pbuf* has to be a pychrysalide.common.PackedBuffer instance.\n" \ + "\n" \ + "The result is a pychrysalide.analysis.storage.SerializableObject" \ + " instancet in case of success, or None in case of failure." \ +) + + ret = PyArg_ParseTuple(args, "sO&", &name, convert_to_packed_buffer, &pbuf); + if (!ret) return NULL; + + storage = G_OBJECT_STORAGE(pygobject_get(self)); + + object = g_object_storage_unpack_object(storage, name, pbuf); + + if (object != NULL) + result = pygobject_new(G_OBJECT(object)); + else + { + result = Py_None; + Py_INCREF(result); + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = classe représentant une mémorisation de types. * +* args = arguments fournis à l'appel. * +* * +* Description : Sauvegarde un object sous forme de données rassemblées. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_object_storage_store_object(PyObject *self, PyObject *args) +{ + PyObject *result; /* Emplacement à retourner */ + const char *name; /* Désignation de groupe */ + GSerializableObject *object; /* Objet à traiter */ + int ret; /* Bilan de lecture des args. */ + GObjectStorage *storage; /* Mécanismes natifs */ + off64_t pos; /* Emplacement d'enregistrement*/ + bool status; /* Bilan de l'opération */ + +#define OBJECT_STORAGE_STORE_OBJECT_METHOD PYTHON_METHOD_DEF \ +( \ + store_object, "$self, name, object, /", \ + METH_VARARGS, py_object_storage, \ + "Save an object as serialized data.\n" \ + "\n" \ + "The *name* is a string label for the group of target objects" \ + " and the processed *object* has to be a" \ + " pychrysalide.analysis.storage.SerializableObject instance.\n" \ + "\n" \ + "The result is the position of the data for stored object," \ + " provided as an integer offset, in case of success or None" \ + " in case of failure." \ +) + + ret = PyArg_ParseTuple(args, "sO&", &name, convert_to_serializable_object, &object); + if (!ret) return NULL; + + storage = G_OBJECT_STORAGE(pygobject_get(self)); + + status = g_object_storage_store_object(storage, name, object, &pos); + + if (status) + result = PyLong_FromUnsignedLongLong((unsigned long long)pos); + else + { + result = Py_None; + Py_INCREF(result); + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = classe représentant une mémorisation de types. * +* args = arguments fournis à l'appel. * +* * +* Description : Sauvegarde un object interne sous forme de données. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_object_storage_pack_object(PyObject *self, PyObject *args) +{ + PyObject *result; /* Emplacement à retourner */ + const char *name; /* Désignation de groupe */ + GSerializableObject *object; /* Objet à traiter */ + packed_buffer_t *pbuf; /* Tampon de données à employer*/ + int ret; /* Bilan de lecture des args. */ + GObjectStorage *storage; /* Mécanismes natifs */ + bool status; /* Bilan de l'opération */ + +#define OBJECT_STORAGE_PACK_OBJECT_METHOD PYTHON_METHOD_DEF \ +( \ + pack_object, "$self, name, object, pbuf/", \ + METH_VARARGS, py_object_storage, \ + "Save an object as serialized data and store the location of" \ + " the data intro a buffer.\n" \ + "\n" \ + "The *name* is a string label for the group of target objects," \ + " the processed *object* has to be a" \ + " pychrysalide.analysis.storage.SerializableObject instance" \ + " and *pbuf* is expected to be a" \ + " pychrysalide.common.PackedBuffer instance.\n" \ + "\n" \ + "The status of the operation is returned as a boolean value:" \ + " *True* for success, *False* for failure." \ +) + + ret = PyArg_ParseTuple(args, "sO&O&", &name, convert_to_serializable_object, &object, + convert_to_packed_buffer, &pbuf); + if (!ret) return NULL; + + storage = G_OBJECT_STORAGE(pygobject_get(self)); + + status = g_object_storage_pack_object(storage, name, object, pbuf); + + result = status ? Py_True : Py_False; + Py_INCREF(result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Fournit un accès à une définition de type à diffuser. * +* * +* Retour : Définition d'objet pour Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +PyTypeObject *get_python_object_storage_type(void) +{ + static PyMethodDef py_object_storage_methods[] = { + OBJECT_STORAGE_LOAD_METHOD, + OBJECT_STORAGE_STORE_METHOD, + OBJECT_STORAGE_LOAD_OBJECT_METHOD, + OBJECT_STORAGE_UNPACK_OBJECT_METHOD, + OBJECT_STORAGE_STORE_OBJECT_METHOD, + OBJECT_STORAGE_PACK_OBJECT_METHOD, + { NULL } + }; + + static PyGetSetDef py_object_storage_getseters[] = { + { NULL } + }; + + static PyTypeObject py_object_storage_type = { + + PyVarObject_HEAD_INIT(NULL, 0) + + .tp_name = "pychrysalide.analysis.storage.ObjectStorage", + .tp_basicsize = sizeof(PyGObject), + + .tp_flags = Py_TPFLAGS_DEFAULT, + + .tp_doc = OBJECT_STORAGE_DOC, + + .tp_methods = py_object_storage_methods, + .tp_getset = py_object_storage_getseters, + + .tp_init = py_object_storage_init, + .tp_new = py_object_storage_new + + }; + + return &py_object_storage_type; + +} + + +/****************************************************************************** +* * +* Paramètres : module = module dont la définition est à compléter. * +* * +* Description : Prend en charge l'objet 'pychrysalide....ObjectStorage'. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool ensure_python_object_storage_is_registered(void) +{ + PyTypeObject *type; /* Type Python 'ObjectStorage' */ + PyObject *module; /* Module à recompléter */ + PyObject *dict; /* Dictionnaire du module */ + + type = get_python_object_storage_type(); + + if (!PyType_HasFeature(type, Py_TPFLAGS_READY)) + { + module = get_access_to_python_module("pychrysalide.analysis.storage"); + + dict = PyModule_GetDict(module); + + if (!register_class_for_pygobject(dict, G_TYPE_OBJECT_STORAGE, type)) + return false; + + } + + return true; + +} + + +/****************************************************************************** +* * +* Paramètres : arg = argument quelconque à tenter de convertir. * +* dst = destination des valeurs récupérées en cas de succès. * +* * +* Description : Tente de convertir en conservateur d'objets. * +* * +* Retour : Bilan de l'opération, voire indications supplémentaires. * +* * +* Remarques : - * +* * +******************************************************************************/ + +int convert_to_object_storage(PyObject *arg, void *dst) +{ + int result; /* Bilan à retourner */ + + result = PyObject_IsInstance(arg, (PyObject *)get_python_object_storage_type()); + + switch (result) + { + case -1: + /* L'exception est déjà fixée par Python */ + result = 0; + break; + + case 0: + PyErr_SetString(PyExc_TypeError, "unable to convert the provided argument to object storage"); + break; + + case 1: + *((GObjectStorage **)dst) = G_OBJECT_STORAGE(pygobject_get(arg)); + break; + + default: + assert(false); + break; + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : arg = argument quelconque à tenter de convertir. * +* dst = destination des valeurs récupérées en cas de succès. * +* * +* Description : Tente de convertir en conservateur d'objets ou NULL. * +* * +* Retour : Bilan de l'opération, voire indications supplémentaires. * +* * +* Remarques : - * +* * +******************************************************************************/ + +int convert_to_object_storage_or_none(PyObject *arg, void *dst) +{ + int result; /* Bilan à retourner */ + + if (arg == Py_None) + { + *((GTypeMemory **)dst) = NULL; + result = 1; + } + + else + result = convert_to_object_storage(arg, dst); + + return result; + +} diff --git a/plugins/pychrysalide/glibext/storage.h b/plugins/pychrysalide/glibext/storage.h new file mode 100644 index 0000000..a0a2c18 --- /dev/null +++ b/plugins/pychrysalide/glibext/storage.h @@ -0,0 +1,48 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * storage.h - prototypes pour l'équivalent Python du fichier "analysis/storage/storage.h" + * + * Copyright (C) 2020 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _PLUGINS_PYCHRYSALIDE_ANALYSIS_STORAGE_STORAGE_H +#define _PLUGINS_PYCHRYSALIDE_ANALYSIS_STORAGE_STORAGE_H + + +#include <Python.h> +#include <stdbool.h> + + + +/* Fournit un accès à une définition de type à diffuser. */ +PyTypeObject *get_python_object_storage_type(void); + +/* Prend en charge l'objet 'pychrysalide.analysis.storage.ObjectStorage'. */ +bool ensure_python_object_storage_is_registered(void); + +/* Tente de convertir en conservateur d'objets. */ +int convert_to_object_storage(PyObject *, void *); + +/* Tente de convertir en conservateur d'objets ou NULL. */ +int convert_to_object_storage_or_none(PyObject *, void *); + + + +#endif /* _PLUGINS_PYCHRYSALIDE_ANALYSIS_STORAGE_STORAGE_H */ diff --git a/plugins/pychrysalide/glibext/tpmem.c b/plugins/pychrysalide/glibext/tpmem.c new file mode 100644 index 0000000..ae07008 --- /dev/null +++ b/plugins/pychrysalide/glibext/tpmem.c @@ -0,0 +1,508 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * tpmem.c - équivalent Python du fichier "analysis/storage/tpmem.c" + * + * Copyright (C) 2020 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#include "tpmem.h" + + +#include <pygobject.h> + + +#include <analysis/storage/tpmem.h> +#include <plugins/dt.h> + + +#include "../../access.h" +#include "../../helpers.h" +#include "../../common/packed.h" + + + +/* ------------------------ GLUE POUR CREATION DEPUIS PYTHON ------------------------ */ + + +/* Accompagne la création d'une instance dérivée en Python. */ +static PyObject *py_type_memory_new(PyTypeObject *, PyObject *, PyObject *); + +/* Initialise une instance sur la base du dérivé de GObject. */ +static int py_type_memory_init(PyObject *, PyObject *, PyObject *); + + + +/* -------------------------- TAMPON POUR CODE DESASSEMBLE -------------------------- */ + + +/* Apprend tous les types mémorisés dans un tampon. */ +static PyObject *py_type_memory_load_types(PyObject *, PyObject *); + +/* Crée une nouvelle instance d'objet à partir de son type. */ +static PyObject *py_type_memory_create_object(PyObject *, PyObject *); + +/* Sauvegarde le type d'un objet instancié. */ +static PyObject *py_type_memory_store_object_gtype(PyObject *, PyObject *); + +/* Enregistre tous les types mémorisés dans un tampon. */ +static PyObject *py_type_memory_store_types(PyObject *, PyObject *); + + + +/* ---------------------------------------------------------------------------------- */ +/* GLUE POUR CREATION DEPUIS PYTHON */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : type = type du nouvel objet à mettre en place. * +* args = éventuelle liste d'arguments. * +* kwds = éventuel dictionnaire de valeurs mises à disposition. * +* * +* Description : Accompagne la création d'une instance dérivée en Python. * +* * +* Retour : Nouvel objet Python mis en place ou NULL en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_type_memory_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + PyObject *result; /* Objet à retourner */ + PyTypeObject *base; /* Type de base à dériver */ + bool first_time; /* Evite les multiples passages*/ + GType gtype; /* Nouveau type de processeur */ + bool status; /* Bilan d'un enregistrement */ + + /* Validations diverses */ + + base = get_python_type_memory_type(); + + if (type == base) + goto simple_way; + + /* Mise en place d'un type dédié */ + + first_time = (g_type_from_name(type->tp_name) == 0); + + gtype = build_dynamic_type(G_TYPE_TYPE_MEMORY, type->tp_name, NULL, NULL, NULL); + + if (first_time) + { + status = register_class_for_dynamic_pygobject(gtype, type); + + if (!status) + { + result = NULL; + goto exit; + } + + } + + /* On crée, et on laisse ensuite la main à PyGObject_Type.tp_init() */ + + simple_way: + + result = PyType_GenericNew(type, args, kwds); + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = objet à initialiser (théoriquement). * +* args = arguments fournis à l'appel. * +* kwds = arguments de type key=val fournis. * +* * +* Description : Initialise une instance sur la base du dérivé de GObject. * +* * +* Retour : 0. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static int py_type_memory_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + int ret; /* Bilan de lecture des args. */ + +#define TYPE_MEMORY_DOC \ + "The TypeMemory remembers all the types of objects involved in" \ + " a serialization process.\n" \ + "\n" \ + "Instances can be created using the following constructor:\n" \ + "\n" \ + " TypeMemory()" \ + + /* Initialisation d'un objet GLib */ + + ret = forward_pygobjet_init(self); + if (ret == -1) return -1; + + return 0; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* TAMPON POUR CODE DESASSEMBLE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : self = classe représentant une mémorisation de types. * +* args = arguments fournis à l'appel. * +* * +* Description : Apprend tous les types mémorisés dans un tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_type_memory_load_types(PyObject *self, PyObject *args) +{ + PyObject *result; /* Bilan à retourner */ + packed_buffer_t *pbuf; /* Tampon à consulter */ + int ret; /* Bilan de lecture des args. */ + GTypeMemory *tpmem; /* Mémorisation native */ + bool status; /* Bilan de l'opération */ + +#define TYPE_MEMORY_LOAD_TYPES_METHOD PYTHON_METHOD_DEF \ +( \ + load_types, "$self, pbuf", \ + METH_VARARGS, py_type_memory, \ + "Read types from a buffer.\n" \ + "\n" \ + "This operation is usually handled internally by the" \ + " Chrysalide's core.\n" \ + "\n" \ + "The *pbuf* parameter is a pychrysalide.common.PackedBuffer"\ + " instance providing buffered data to read." \ + "\n" \ + "The result is a boolean value indicating the status of" \ + " the operation: True for success, False for failure." \ +) + + ret = PyArg_ParseTuple(args, "O&", convert_to_packed_buffer, &pbuf); + if (!ret) return NULL; + + tpmem = G_TYPE_MEMORY(pygobject_get(self)); + + status = g_type_memory_load_types(tpmem, pbuf); + + result = status ? Py_True : Py_False; + Py_INCREF(result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = classe représentant une mémorisation de types. * +* args = arguments fournis à l'appel. * +* * +* Description : Crée une nouvelle instance d'objet à partir de son type. * +* * +* Retour : Instance issue de l'opération ou NULL. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_type_memory_create_object(PyObject *self, PyObject *args) +{ + PyObject *result; /* Instance à retourner */ + packed_buffer_t *pbuf; /* Tampon à consulter */ + int ret; /* Bilan de lecture des args. */ + GTypeMemory *tpmem; /* Mémorisation native */ + GObject *obj; /* Instance retournée */ + +#define TYPE_MEMORY_CREATE_OBJECT_METHOD PYTHON_METHOD_DEF \ +( \ + create_object, "$self, pbuf", \ + METH_VARARGS, py_type_memory, \ + "Create a new GLib object from serialized data.\n" \ + "\n" \ + "The *pbuf* parameter is a pychrysalide.common.PackedBuffer" \ + " instance providing buffered data to read." \ + "\n" \ + "The result is a Python object linked to a native GLib" \ + " object instance." \ +) + + ret = PyArg_ParseTuple(args, "O&", convert_to_packed_buffer, &pbuf); + if (!ret) return NULL; + + tpmem = G_TYPE_MEMORY(pygobject_get(self)); + + obj = g_type_memory_create_object(tpmem, pbuf); + + result = pygobject_new(obj); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = classe représentant une mémorisation de types. * +* args = arguments fournis à l'appel. * +* * +* Description : Sauvegarde le type d'un objet instancié. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_type_memory_store_object_gtype(PyObject *self, PyObject *args) +{ + PyObject *result; /* Bilan à retourner */ + GObject *obj; /* Instance à traiter */ + packed_buffer_t *pbuf; /* Tampon à consulter */ + int ret; /* Bilan de lecture des args. */ + GTypeMemory *tpmem; /* Mémorisation native */ + bool status; /* Bilan de l'opération */ + +#define TYPE_MEMORY_STORE_OBJECT_GTYPE_METHOD PYTHON_METHOD_DEF \ +( \ + store_object_gtype, "$self, obj, pbuf", \ + METH_VARARGS, py_type_memory, \ + "Create a new GLib object from serialized data.\n" \ + "\n" \ + "The *obj* parameter is the Python version of the GObject" \ + " whose type is to process and the *pbuf* parameter is a" \ + " pychrysalide.common.PackedBuffer instance providing buffered" \ + " data to extend." \ + "\n" \ + "The result is a boolean value indicating the status of the" \ + " operation: True for success, False for failure." \ +) + + ret = PyArg_ParseTuple(args, "O!O&", PyGObject_Type, &obj, convert_to_packed_buffer, &pbuf); + if (!ret) return NULL; + + tpmem = G_TYPE_MEMORY(pygobject_get(self)); + + status = g_type_memory_store_object_gtype(tpmem, obj, pbuf); + + result = status ? Py_True : Py_False; + Py_INCREF(result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : self = classe représentant une mémorisation de types. * +* args = arguments fournis à l'appel. * +* * +* Description : Enregistre tous les types mémorisés dans un tampon. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_type_memory_store_types(PyObject *self, PyObject *args) +{ + PyObject *result; /* Bilan à retourner */ + packed_buffer_t *pbuf; /* Tampon à consulter */ + int ret; /* Bilan de lecture des args. */ + GTypeMemory *tpmem; /* Mémorisation native */ + bool status; /* Bilan de l'opération */ + +#define TYPE_MEMORY_STORE_TYPES_METHOD PYTHON_METHOD_DEF \ +( \ + store_types, "$self, pbuf", \ + METH_VARARGS, py_type_memory, \ + "Write types into a buffer.\n" \ + "\n" \ + "This operation is usually handled internally by the" \ + " Chrysalide's core.\n" \ + "\n" \ + "The *pbuf* parameter is a pychrysalide.common.PackedBuffer"\ + " instance providing buffered data to read." \ + "\n" \ + "The result is a boolean value indicating the status of" \ + " the operation: True for success, False for failure." \ +) + + ret = PyArg_ParseTuple(args, "O&", convert_to_packed_buffer, &pbuf); + if (!ret) return NULL; + + tpmem = G_TYPE_MEMORY(pygobject_get(self)); + + status = g_type_memory_store_types(tpmem, pbuf); + + result = status ? Py_True : Py_False; + Py_INCREF(result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Fournit un accès à une définition de type à diffuser. * +* * +* Retour : Définition d'objet pour Python. * +* * +* Remarques : - * +* * +******************************************************************************/ + +PyTypeObject *get_python_type_memory_type(void) +{ + static PyMethodDef py_type_memory_methods[] = { + TYPE_MEMORY_LOAD_TYPES_METHOD, + TYPE_MEMORY_CREATE_OBJECT_METHOD, + TYPE_MEMORY_STORE_OBJECT_GTYPE_METHOD, + TYPE_MEMORY_STORE_TYPES_METHOD, + { NULL } + }; + + static PyGetSetDef py_type_memory_getseters[] = { + { NULL } + }; + + static PyTypeObject py_type_memory_type = { + + PyVarObject_HEAD_INIT(NULL, 0) + + .tp_name = "pychrysalide.analysis.storage.TypeMemory", + .tp_basicsize = sizeof(PyGObject), + + .tp_flags = Py_TPFLAGS_DEFAULT, + + .tp_doc = TYPE_MEMORY_DOC, + + .tp_methods = py_type_memory_methods, + .tp_getset = py_type_memory_getseters, + + .tp_init = py_type_memory_init, + .tp_new = py_type_memory_new + + }; + + return &py_type_memory_type; + +} + + +/****************************************************************************** +* * +* Paramètres : module = module dont la définition est à compléter. * +* * +* Description : Prend en charge l'objet 'pychrysalide.analysis...TypeMemory'.* +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool ensure_python_type_memory_is_registered(void) +{ + PyTypeObject *type; /* Type Python 'BufferCache' */ + PyObject *module; /* Module à recompléter */ + PyObject *dict; /* Dictionnaire du module */ + + type = get_python_type_memory_type(); + + if (!PyType_HasFeature(type, Py_TPFLAGS_READY)) + { + module = get_access_to_python_module("pychrysalide.analysis.storage"); + + dict = PyModule_GetDict(module); + + if (!register_class_for_pygobject(dict, G_TYPE_TYPE_MEMORY, type)) + return false; + + } + + return true; + +} + + +/****************************************************************************** +* * +* Paramètres : arg = argument quelconque à tenter de convertir. * +* dst = destination des valeurs récupérées en cas de succès. * +* * +* Description : Tente de convertir en mémorisation de types. * +* * +* Retour : Bilan de l'opération, voire indications supplémentaires. * +* * +* Remarques : - * +* * +******************************************************************************/ + +int convert_to_type_memory(PyObject *arg, void *dst) +{ + int result; /* Bilan à retourner */ + + result = PyObject_IsInstance(arg, (PyObject *)get_python_type_memory_type()); + + switch (result) + { + case -1: + /* L'exception est déjà fixée par Python */ + result = 0; + break; + + case 0: + PyErr_SetString(PyExc_TypeError, "unable to convert the provided argument to buffer cache"); + break; + + case 1: + *((GTypeMemory **)dst) = G_TYPE_MEMORY(pygobject_get(arg)); + break; + + default: + assert(false); + break; + + } + + return result; + +} diff --git a/plugins/pychrysalide/glibext/tpmem.h b/plugins/pychrysalide/glibext/tpmem.h new file mode 100644 index 0000000..1085632 --- /dev/null +++ b/plugins/pychrysalide/glibext/tpmem.h @@ -0,0 +1,45 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * tpmem.h - prototypes pour l'équivalent Python du fichier "analysis/storage/tpmem.h" + * + * Copyright (C) 2020 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 this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + + +#ifndef _PLUGINS_PYCHRYSALIDE_ANALYSIS_STORAGE_TPMEM_H +#define _PLUGINS_PYCHRYSALIDE_ANALYSIS_STORAGE_TPMEM_H + + +#include <Python.h> +#include <stdbool.h> + + + +/* Fournit un accès à une définition de type à diffuser. */ +PyTypeObject *get_python_type_memory_type(void); + +/* Prend en charge l'objet 'pychrysalide.analysis.storage.TypeMemory'. */ +bool ensure_python_type_memory_is_registered(void); + +/* Tente de convertir en mémorisation de types. */ +int convert_to_type_memory(PyObject *, void *); + + + +#endif /* _PLUGINS_PYCHRYSALIDE_ANALYSIS_STORAGE_TPMEM_H */ |