/* OpenIDA - Outil d'analyse de fichiers binaires * plugin.c - interactions avec un greffon donné * * Copyright (C) 2009-2012 Cyrille Bagard * * This file is part of OpenIDA. * * OpenIDA 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. * * OpenIDA 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 "plugin.h" #include #include #include #include #include #include #include #include "plugin-int.h" /* Initialise la classe des greffons. */ static void g_plugin_module_class_init(GPluginModuleClass *); /* Initialise une instance de greffon. */ static void g_plugin_module_init(GPluginModule *); /* Supprime toutes les références externes. */ static void g_plugin_module_dispose(GPluginModule *); /* Procède à la libération totale de la mémoire. */ static void g_plugin_module_finalize(GPluginModule *); /* Indique le type défini pour un greffon. */ G_DEFINE_TYPE(GPluginModule, g_plugin_module, G_TYPE_OBJECT); /****************************************************************************** * * * Paramètres : class = classe à initialiser. * * * * Description : Initialise la classe des greffons. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_plugin_module_class_init(GPluginModuleClass *class) { GObjectClass *object; /* Autre version de la classe */ object = G_OBJECT_CLASS(class); object->dispose = (GObjectFinalizeFunc/* ! */)g_plugin_module_dispose; object->finalize = (GObjectFinalizeFunc)g_plugin_module_finalize; } /****************************************************************************** * * * Paramètres : plugin = instance à initialiser. * * * * Description : Initialise une instance de greffon. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_plugin_module_init(GPluginModule *plugin) { } /****************************************************************************** * * * Paramètres : plugin = instance d'objet GLib à traiter. * * * * Description : Supprime toutes les références externes. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_plugin_module_dispose(GPluginModule *plugin) { if (plugin->exit != NULL) plugin->exit(plugin); if (plugin->module != NULL) g_module_close(plugin->module); G_OBJECT_CLASS(g_plugin_module_parent_class)->dispose(G_OBJECT(plugin)); } /****************************************************************************** * * * Paramètres : plugin = instance d'objet GLib à traiter. * * * * Description : Procède à la libération totale de la mémoire. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_plugin_module_finalize(GPluginModule *plugin) { if (plugin->name != NULL) free(plugin->name); if (plugin->filename != NULL) free(plugin->filename); G_OBJECT_CLASS(g_plugin_module_parent_class)->finalize(G_OBJECT(plugin)); } /****************************************************************************** * * * Paramètres : filename = nom du fichier à charger. * * * * Description : Crée un module pour un greffon donné. * * * * Retour : Adresse de la structure mise en place. * * * * Remarques : - * * * ******************************************************************************/ GPluginModule *g_plugin_module_new(const gchar *filename) { GPluginModule *result; /* Structure à retourner */ get_plugin_name_fc get_name; /* Nom du greffon */ get_plugin_action_fc __get_type; /* Type(s) de greffon */ get_plugin_action_fc get_action; /* Actions du greffon */ char *dir; /* Répertoire modifiable */ result = g_object_new(G_TYPE_PLUGIN_MODULE, NULL); result->module = g_module_open(filename, G_MODULE_BIND_LAZY); if (result->module == NULL) { log_variadic_message(LMT_ERROR, _("Error while loading the plugin candidate '%s' : %s"), filename, g_module_error()); goto bad_plugin; } if (!g_module_symbol(result->module, "get_plugin_name", (gpointer *)&get_name)) { log_variadic_message(LMT_ERROR, _("No 'get_plugin_name' entry in plugin candidate '%s'"), filename); goto bad_plugin; } result->name = get_name(); result->filename = strdup(filename); if (!g_module_symbol(result->module, "init_plugin", (gpointer *)&result->init)) result->init = NULL; if (!g_module_symbol(result->module, "exit_plugin", (gpointer *)&result->exit)) result->exit = NULL; /* if (!g_module_symbol(result->module, "get_plugin_type", (gpointer *)&__get_type)) { printf("No 'get_plugin_type' symbol found in the plugin '%s'\n", filename); goto bad_plugin; } result->type = __get_type(); printf("Plugin type :: 0x%08x\n", result->type); */ if (!g_module_symbol(result->module, "get_plugin_action", (gpointer *)&get_action)) { printf("Err plugin get_action sym\n"); //g_object_destroy(result); return NULL; } result->get_action = get_action; if (g_plugin_module_get_action(result) & (PGA_BINARY_ACTIONS | /* FIXME : supprimer le reste */ PGA_DISASSEMBLE | PGA_DISASS_PROCESS | PGA_CODE_PROCESS)) { if (!g_module_symbol(result->module, "execute_action_on_binary", (gpointer *)&result->exec_on_bin)) { printf("Err plugin disass sym\n"); //g_object_destroy(result); return NULL; } } dir = strdup(filename); dir = dirname(dir); log_variadic_message(LMT_PROCESS, _("Loaded the '%s' from the '%s' directory"), strrchr(filename, G_DIR_SEPARATOR) + 1, dir); free(dir); return result; bad_plugin: g_object_unref(G_OBJECT(result)); return NULL; } /****************************************************************************** * * * Paramètres : plugin = greffon à consulter. * * * * Description : Fournit le nom associé au greffon. * * * * Retour : Désignation humaine. * * * * Remarques : - * * * ******************************************************************************/ const char *g_plugin_module_get_name(const GPluginModule *plugin) { return plugin->name; } /****************************************************************************** * * * Paramètres : plugin = greffon à consulter. * * msg = message à faire apparaître à l'écran. * * * * Description : Présente dans le journal un message simple. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void g_plugin_module_log_simple_message(const GPluginModule *plugin, LogMessageType type, const char *msg) { size_t len; /* Taille tampon disponible */ char *buffer; /* Tampon du msg reconstitué */ len = 1 + strlen(plugin->name) + 2 + strlen(msg) + 1; buffer = calloc(len, sizeof(char)); strcpy(buffer, "["); strcat(buffer, plugin->name); strcat(buffer, "] "); strcat(buffer, msg); log_simple_message(type, buffer); free(buffer); } /****************************************************************************** * * * Paramètres : plugin = greffon à consulter. * * type = espèce du message à ajouter. * * fmt = format du message à faire apparaître à l'écran. * * ... = éventuels arguments venant compléter le message. * * * * Description : Présente dans le journal un message complexe. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void g_plugin_module_log_variadic_message(const GPluginModule *plugin, LogMessageType type, const char *fmt, ...) { size_t len; /* Taille tampon disponible */ char *buffer; /* Tampon du msg reconstitué */ int ret; /* Bilan d'une impression */ char *ptr; /* Nouvelle allocation */ va_list ap; /* Liste d'arguments variable */ len = VARIADIC_LOG_BUFSIZE; buffer = calloc(len, sizeof(char)); while (buffer != NULL) { va_start(ap, fmt); ret = vsnprintf(buffer, len, fmt, ap); va_end(ap); if (ret >= 0 && ret < len) break; else { if (ret > -1) len += 1; /* glibc 2.1 */ else len *= 2; /* glibc 2.0 */ if ((ptr = realloc(buffer, len)) == NULL) { free(buffer); buffer = NULL; } else buffer = ptr; } } g_plugin_module_log_simple_message(plugin, type, buffer); free(buffer); } /****************************************************************************** * * * Paramètres : plugin = greffon à consulter. * * * * Description : Indique les opérations offertes par un greffon donné. * * * * Retour : Action(s) offerte(s) par le greffon. * * * * Remarques : - * * * ******************************************************************************/ PluginAction g_plugin_module_get_action(const GPluginModule *plugin) { return plugin->get_action(plugin); } /****************************************************************************** * * * Paramètres : plugin = greffon de prise en charge à utiliser. * * filename = éventuel nom de fichier associé ou NULL. [OUT] * * data = données chargées. [OUT] * * length = quantité de ces données. [OUT] * * * * Description : Identifie un format à associer à un contenu binaire. * * * * Retour : Bilan de la recherche de correspondances. * * * * Remarques : - * * * ******************************************************************************/ MatchingFormatAction g_plugin_module_is_matching(const GPluginModule *plugin, char **filename, bin_t **data, off_t *length) { MatchingFormatAction result; /* Valeur à retourner */ char *old_filename; /* Ancien nom de fichier */ bin_t *old_data; /* Ancien contenu binaire */ if (plugin->is_matching == NULL) return MFA_NONE; old_filename = *filename; old_data = *data; result = plugin->is_matching(plugin, filename, data, length); return result; } /****************************************************************************** * * * Paramètres : plugin = greffon à consulter. * * binary = binaire dont le contenu est à traiter. * * action = action attendue. * * * * Description : Exécute une action définie sur un binaire chargé. * * * * Retour : true si une action a été menée, false sinon. * * * * Remarques : - * * * ******************************************************************************/ bool g_plugin_module_execute_action_on_binary(const GPluginModule *plugin, GLoadedBinary *binary, PluginAction action) { return plugin->exec_on_bin(plugin, binary, action); } /****************************************************************************** * * * Paramètres : plugin = greffon à consulter. * * debugger = débogueur à l'origine de l'opération. * * action = action attendue. * * * * Description : Exécute une action relative à un débogueur. * * * * Retour : true si une action a été menée, false sinon. * * * * Remarques : - * * * ******************************************************************************/ bool g_plugin_module_handle_debugger(const GPluginModule *plugin, GBinaryDebugger *debugger, PluginAction action) { return plugin->handle_debugger(plugin, debugger, action); }