diff options
Diffstat (limited to 'plugins/pychrysalide/format/executable.c')
| -rw-r--r-- | plugins/pychrysalide/format/executable.c | 273 |
1 files changed, 240 insertions, 33 deletions
diff --git a/plugins/pychrysalide/format/executable.c b/plugins/pychrysalide/format/executable.c index ff2d14a..d886e9a 100644 --- a/plugins/pychrysalide/format/executable.c +++ b/plugins/pychrysalide/format/executable.c @@ -2,7 +2,7 @@ /* Chrysalide - Outil d'analyse de fichiers binaires * executable.c - équivalent Python du fichier "format/executable.c" * - * Copyright (C) 2018-2019 Cyrille Bagard + * Copyright (C) 2018-2024 Cyrille Bagard * * This file is part of Chrysalide. * @@ -30,15 +30,31 @@ #include <i18n.h> -#include <core/processors.h> +#include <format/executable-int.h> -#include "format.h" +#include "program.h" #include "../access.h" #include "../helpers.h" -#include "../arch/processor.h" -#include "../arch/vmpa.h" -#include "../glibext/binportion.h" +//#include "../arch/processor.h" +//#include "../arch/vmpa.h" +//#include "../glibext/binportion.h" + + + +/* ------------------------ GLUE POUR CREATION DEPUIS PYTHON ------------------------ */ + + +/* Initialise la classe des formats exécutables. */ +static void py_executable_format_init_gclass(GExecutableFormatClass *, gpointer); + +CREATE_DYN_ABSTRACT_CONSTRUCTOR(executable_format, G_TYPE_EXECUTABLE_FORMAT, py_executable_format_init_gclass); + +/* Initialise une instance sur la base du dérivé de GObject. */ +static int py_executable_format_init(PyObject *, PyObject *, PyObject *); + +/* Indique le type d'architecture visée par le format. */ +static char *py_executable_format_get_target_machine_wrapper(const GExecutableFormat *); @@ -46,13 +62,145 @@ /* Enregistre une portion artificielle pour le format. */ -static PyObject *py_exe_format_register_user_portion(PyObject *, PyObject *); +//static PyObject *py_executable_format_register_user_portion(PyObject *, PyObject *); /* Fournit l'emplacement correspondant à une position physique. */ -static PyObject *py_exe_format_translate_offset_into_vmpa(PyObject *, PyObject *); +//static PyObject *py_executable_format_translate_offset_into_vmpa(PyObject *, PyObject *); /* Fournit l'emplacement correspondant à une adresse virtuelle. */ -static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *, PyObject *); +//static PyObject *py_executable_format_translate_address_into_vmpa(PyObject *, PyObject *); + +/* Indique le type d'architecture visée par le format. */ +static PyObject *py_executable_format_get_target_machine(PyObject *, void *); + + + +/* ---------------------------------------------------------------------------------- */ +/* GLUE POUR CREATION DEPUIS PYTHON */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : class = classe à initialiser. * +* unused = données non utilisées ici. * +* * +* Description : Initialise la classe des formats exécutables. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void py_executable_format_init_gclass(GExecutableFormatClass *class, gpointer unused) +{ + class->get_machine = py_executable_format_get_target_machine_wrapper; + +} + + +/****************************************************************************** +* * +* 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_executable_format_init(PyObject *self, PyObject *args, PyObject *kwds) +{ + int ret; /* Bilan de lecture des args. */ + +#define EXECUTABLE_FORMAT_DOC \ + "The ExecutableFormat class provides support for formats containing"\ + " code to run.\n" \ + "\n" \ + "The following method has to be defined for new classes:\n" \ + "* pychrysalide.format.ExecutableFormat._get_target_machine();\n" \ + "\n" \ + "\n" \ + "Calls to the *__init__* constructor of this abstract object expect"\ + " no particular argument." + + /* Initialisation d'un objet GLib */ + + ret = forward_pygobjet_init(self); + if (ret == -1) return -1; + + return 0; + +} + + +/****************************************************************************** +* * +* Paramètres : format = description du format exécutable à consulter. * +* * +* Description : Indique le type d'architecture visée par le format. * +* * +* Retour : Identifiant de l'architecture ciblée par le format. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static char *py_executable_format_get_target_machine_wrapper(const GExecutableFormat *format) +{ + char *result; /* Désignation à renvoyer */ + PyGILState_STATE gstate; /* Sauvegarde d'environnement */ + PyObject *pyobj; /* Objet Python concerné */ + PyObject *pyret; /* Valeur retournée */ + int ret; /* Bilan d'une conversion */ + +#define EXECUTABLE_FORMAT_GET_TARGET_MACHINE_WRAPPER PYTHON_WRAPPER_DEF \ +( \ + _get_target_machine, "$self", \ + METH_NOARGS, \ + "Abstract method used to define the identifier of the architecture" \ + " suitable for the executable format.\n" \ + "\n" \ + "The return value has to be a (tiny) string." \ +) + + result = NULL; + + gstate = PyGILState_Ensure(); + + pyobj = pygobject_new(G_OBJECT(format)); + + if (has_python_method(pyobj, "_get_target_machine")) + { + pyret = run_python_method(pyobj, "_get_target_machine", NULL); + + if (pyret != NULL) + { + ret = PyUnicode_Check(pyret); + + if (ret) + result = strdup(PyUnicode_AsUTF8(pyret)); + else + PyErr_SetString(PyExc_ValueError, _("unexpected value type for executable format target machine")); + + Py_DECREF(pyret); + + } + + } + + Py_DECREF(pyobj); + + PyGILState_Release(gstate); + + return result; + +} @@ -61,6 +209,7 @@ static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *, PyObject /* ---------------------------------------------------------------------------------- */ +#if 0 /****************************************************************************** * * * Paramètres : self = description de l'exécutable à consulter. * @@ -74,16 +223,16 @@ static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *, PyObject * * ******************************************************************************/ -static PyObject *py_exe_format_register_user_portion(PyObject *self, PyObject *args) +static PyObject *py_executable_format_register_user_portion(PyObject *self, PyObject *args) { GBinPortion *portion; /* Portion binaire à conserver */ int ret; /* Bilan de lecture des args. */ - GExeFormat *format; /* Version GLib du format */ + GExecutableFormat *format; /* Version GLib du format */ ret = PyArg_ParseTuple(args, "O&", convert_to_binary_portion, &portion); if (!ret) return NULL; - format = G_EXE_FORMAT(pygobject_get(self)); + format = G_EXECUTABLE_FORMAT(pygobject_get(self)); g_object_ref(G_OBJECT(portion)); g_exe_format_register_user_portion(format, portion); @@ -106,16 +255,16 @@ static PyObject *py_exe_format_register_user_portion(PyObject *self, PyObject *a * * ******************************************************************************/ -static PyObject *py_exe_format_translate_offset_into_vmpa(PyObject *self, PyObject *args) +static PyObject *py_executable_format_translate_offset_into_vmpa(PyObject *self, PyObject *args) { PyObject *result; /* Instance à retourner */ - GExeFormat *format; /* Version GLib du format */ + GExecutableFormat *format; /* Version GLib du format */ unsigned long long off; /* Adresse en mémoire virtuelle*/ int ret; /* Bilan de lecture des args. */ vmpa2t pos; /* Position complète déterminée*/ bool status; /* Bilan de l'opération */ - format = G_EXE_FORMAT(pygobject_get(self)); + format = G_EXECUTABLE_FORMAT(pygobject_get(self)); assert(format != NULL); ret = PyArg_ParseTuple(args, "K", &off); @@ -150,16 +299,16 @@ static PyObject *py_exe_format_translate_offset_into_vmpa(PyObject *self, PyObje * * ******************************************************************************/ -static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *self, PyObject *args) +static PyObject *py_executable_format_translate_address_into_vmpa(PyObject *self, PyObject *args) { PyObject *result; /* Instance à retourner */ - GExeFormat *format; /* Version GLib du format */ + GExecutableFormat *format; /* Version GLib du format */ unsigned long long addr; /* Adresse en mémoire virtuelle*/ int ret; /* Bilan de lecture des args. */ vmpa2t pos; /* Position complète déterminée*/ bool status; /* Bilan de l'opération */ - format = G_EXE_FORMAT(pygobject_get(self)); + format = G_EXECUTABLE_FORMAT(pygobject_get(self)); assert(format != NULL); ret = PyArg_ParseTuple(args, "K", &addr); @@ -179,6 +328,56 @@ static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *self, PyObj return result; } +#endif + + +/****************************************************************************** +* * +* Paramètres : self = objet Python concerné par l'appel. * +* closure = non utilisé ici. * +* * +* Description : Indique le type d'architecture visée par le format. * +* * +* Retour : Identifiant de l'architecture ciblée par le format. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static PyObject *py_executable_format_get_target_machine(PyObject *self, void *closure) +{ + PyObject *result; /* Trouvailles à retourner */ + GExecutableFormat *format; /* Format exécutable manipulé */ + char *machine; /* Désignation machine ciblée */ + +#define EXECUTABLE_FORMAT_TARGET_MACHINE_ATTRIB PYTHON_GET_DEF_FULL \ +( \ + target_machine, py_executable_format, \ + "Identifier of the architecture suitable for the executable format,"\ + " provided as a (tiny) string." \ +) + + format = G_EXECUTABLE_FORMAT(pygobject_get(self)); + + machine = g_executable_format_get_target_machine(format); + + if (machine != NULL) + { + result = PyUnicode_FromString(machine); + free(machine); + } + else + { + result = NULL; + + if (PyErr_Occurred() == NULL) + PyErr_SetString(PyExc_ValueError, _("unexpected NULL value for executable format target machine")); + + } + + return result; + +} /****************************************************************************** @@ -195,46 +394,53 @@ static PyObject *py_exe_format_translate_address_into_vmpa(PyObject *self, PyObj PyTypeObject *get_python_executable_format_type(void) { - static PyMethodDef py_exe_format_methods[] = { + static PyMethodDef py_executable_format_methods[] = { + EXECUTABLE_FORMAT_GET_TARGET_MACHINE_WRAPPER, +#if 0 { - "register_user_portion", py_exe_format_register_user_portion, + "register_user_portion", py_executable_format_register_user_portion, METH_VARARGS, "register_user_portion($self, portion, /)\n--\n\nRemember a given user-defined binary portion as part of the executable format content." }, { - "translate_offset_into_vmpa", py_exe_format_translate_offset_into_vmpa, + "translate_offset_into_vmpa", py_executable_format_translate_offset_into_vmpa, METH_VARARGS, "translate_offset_into_vmpa($self, off, /)\n--\n\nTranslate a physical offset to a full location." }, { - "translate_address_into_vmpa", py_exe_format_translate_address_into_vmpa, + "translate_address_into_vmpa", py_executable_format_translate_address_into_vmpa, METH_VARARGS, "translate_address_into_vmpa($self, addr, /)\n--\n\nTranslate a physical offset to a full location." }, +#endif { NULL } }; - static PyGetSetDef py_exe_format_getseters[] = { + static PyGetSetDef py_executable_format_getseters[] = { + EXECUTABLE_FORMAT_TARGET_MACHINE_ATTRIB, { NULL } }; - static PyTypeObject py_exe_format_type = { + static PyTypeObject py_executable_format_type = { PyVarObject_HEAD_INIT(NULL, 0) - .tp_name = "pychrysalide.format.ExeFormat", + .tp_name = "pychrysalide.format.ExecutableFormat", .tp_basicsize = sizeof(PyGObject), .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, - .tp_doc = "PyChrysalide executable format", + .tp_doc = EXECUTABLE_FORMAT_DOC, + + .tp_methods = py_executable_format_methods, + .tp_getset = py_executable_format_getseters, - .tp_methods = py_exe_format_methods, - .tp_getset = py_exe_format_getseters, + .tp_init = py_executable_format_init, + .tp_new = py_executable_format_new, }; - return &py_exe_format_type; + return &py_executable_format_type; } @@ -265,10 +471,10 @@ bool ensure_python_executable_format_is_registered(void) dict = PyModule_GetDict(module); - if (!ensure_python_binary_format_is_registered()) + if (!ensure_python_program_format_is_registered()) return false; - if (!register_class_for_pygobject(dict, G_TYPE_EXE_FORMAT, type)) + if (!register_class_for_pygobject(dict, G_TYPE_EXECUTABLE_FORMAT, type)) return false; } @@ -309,7 +515,7 @@ int convert_to_executable_format(PyObject *arg, void *dst) break; case 1: - *((GExeFormat **)dst) = G_EXE_FORMAT(pygobject_get(arg)); + *((GExecutableFormat **)dst) = G_EXECUTABLE_FORMAT(pygobject_get(arg)); break; default: @@ -328,7 +534,7 @@ int convert_to_executable_format(PyObject *arg, void *dst) /* TRADUCTION D'EMPLACEMENT */ /* ---------------------------------------------------------------------------------- */ - +#if 0 /****************************************************************************** * * * Paramètres : obj = objet Python à convertir en emplacement. * @@ -391,3 +597,4 @@ int convert_to_vmpa_using_executable(PyObject *obj, exe_cv_info_t *info) return result; } +#endif |