/* Chrysalide - Outil d'analyse de fichiers binaires * artificial.c - instructions pures vues de l'esprit * * Copyright (C) 2009-2012 Cyrille Bagard * * This file is part of Chrysalide. * * 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 Foobar. If not, see . */ #include "raw.h" #include #include #include #include #include "immediate.h" #include "instruction-int.h" #include "target.h" /* ------------------------- INSTRUCTION INCONNUE / DONNEES ------------------------- */ /* Définition générique d'une instruction brute d'architecture (instance) */ struct _GRawInstruction { GArchInstruction parent; /* A laisser en premier */ bool is_padding; /* Bourrage à représenter ? */ bool is_string; /* Chaîne de caractères ? */ }; /* Définition générique d'une instruction brute d'architecture (classe) */ struct _GRawInstructionClass { GArchInstructionClass parent; /* A laisser en premier */ }; /* Initialise la classe des instructions brutes d'architecture. */ static void g_raw_instruction_class_init(GRawInstructionClass *); /* Initialise une instance d'instruction brute d'architecture. */ static void g_raw_instruction_init(GRawInstruction *); /* Supprime toutes les références externes. */ static void g_raw_instruction_dispose(GRawInstruction *); /* Procède à la libération totale de la mémoire. */ static void g_raw_instruction_finalize(GRawInstruction *); /* Indique l'encodage d'une instruction de façon détaillée. */ static const char *g_raw_instruction_get_encoding(const GRawInstruction *); /* Ajoute à un tampon GLib le contenu de l'instance spécifiée. */ static GBufferLine *g_raw_instruction_print(GRawInstruction *, GCodeBuffer *, MemoryDataSize, const GBinContent *, AsmSyntax); /* Reconstruit le cache complet d'une désignation d'instruction. */ static void g_raw_instruction_build_keyword(const GRawInstruction *, AsmSyntax); /* ---------------------------------------------------------------------------------- */ /* INSTRUCTION INCONNUE / DONNEES */ /* ---------------------------------------------------------------------------------- */ /* Indique le type défini pour une instruction inconnue d'architecture. */ G_DEFINE_TYPE(GRawInstruction, g_raw_instruction, G_TYPE_ARCH_INSTRUCTION); /****************************************************************************** * * * Paramètres : klass = classe à initialiser. * * * * Description : Initialise la classe des instructions brutes d'architecture. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_raw_instruction_class_init(GRawInstructionClass *klass) { GObjectClass *object; /* Autre version de la classe */ GArchInstructionClass *instr; /* Encore une autre vision... */ object = G_OBJECT_CLASS(klass); object->dispose = (GObjectFinalizeFunc/* ! */)g_raw_instruction_dispose; object->finalize = (GObjectFinalizeFunc)g_raw_instruction_finalize; instr = G_ARCH_INSTRUCTION_CLASS(klass); instr->get_encoding = (get_instruction_encoding_fc)g_raw_instruction_get_encoding; instr->print = (print_instruction_fc)g_raw_instruction_print; instr->build_key = (build_instruction_keyword_fc)g_raw_instruction_build_keyword; } /****************************************************************************** * * * Paramètres : instr = instance à initialiser. * * * * Description : Initialise une instance d'instruction brute d'architecture. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_raw_instruction_init(GRawInstruction *instr) { } /****************************************************************************** * * * Paramètres : instr = instance d'objet GLib à traiter. * * * * Description : Supprime toutes les références externes. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_raw_instruction_dispose(GRawInstruction *instr) { G_OBJECT_CLASS(g_raw_instruction_parent_class)->dispose(G_OBJECT(instr)); } /****************************************************************************** * * * Paramètres : instr = instance d'objet GLib à traiter. * * * * Description : Procède à la libération totale de la mémoire. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static void g_raw_instruction_finalize(GRawInstruction *instr) { G_OBJECT_CLASS(g_raw_instruction_parent_class)->finalize(G_OBJECT(instr)); } /****************************************************************************** * * * Paramètres : addr = position à associer à l'instruction. * * size = taille de l'opérande souhaitée. * * value = valeur sur x bits à venir récupérer. * * * * Description : Crée une instruction de type 'db/dw/etc' simple. * * * * Retour : Instruction mise en place. * * * * Remarques : - * * * ******************************************************************************/ GArchInstruction *g_raw_instruction_new_from_value(const vmpa2t *addr, MemoryDataSize size, uint64_t value) { GArchInstruction *result; /* Instruction à retourner */ GArchOperand *operand; /* Octet non décodé à afficher */ mrange_t range; /* Couverture de l'instruction */ result = g_object_new(G_TYPE_RAW_INSTRUCTION, NULL); operand = g_imm_operand_new_from_value(size, value); if (operand == NULL) goto grinfv_error; g_imm_operand_pad(G_IMM_OPERAND(operand), true); g_arch_instruction_attach_extra_operand(result, operand); switch (size) { case MDS_8_BITS_UNSIGNED: case MDS_8_BITS_SIGNED: init_mrange(&range, addr, 1); break; case MDS_16_BITS_UNSIGNED: case MDS_16_BITS_SIGNED: init_mrange(&range, addr, 2); break; case MDS_32_BITS_UNSIGNED: case MDS_32_BITS_SIGNED: init_mrange(&range, addr, 4); break; case MDS_64_BITS_UNSIGNED: case MDS_64_BITS_SIGNED: init_mrange(&range, addr, 8); break; default: assert(false); goto grinfv_error; break; } g_arch_instruction_set_range(result, &range); return result; grinfv_error: g_object_unref(G_OBJECT(result)); return NULL; } /****************************************************************************** * * * Paramètres : content = flux de données à analyser. * * addr = position courante dans ce flux. [OUT] * * * * Description : Crée une instruction de type 'db/dw/etc' pour un uleb128. * * * * Retour : Instruction mise en place. * * * * Remarques : - * * * ******************************************************************************/ GArchInstruction *g_raw_instruction_new_uleb128(const GBinContent *content, vmpa2t *addr) { GArchInstruction *result; /* Instruction à retourner */ vmpa2t start; /* Départ original de lecture */ uleb128_t value; /* Valeur uleb128 à représenter*/ MemoryDataSize leb_size; /* Taille de la valeur */ copy_vmpa(&start, addr); if (!g_binary_content_read_uleb128(content, addr, &value)) goto grinu_error; leb_size = MDS_FROM_BYTES(compute_vmpa_diff(&start, addr)); assert(leb_size != MDS_UNDEFINED); result = g_raw_instruction_new_from_value(&start, leb_size, (uint64_t)value); return result; grinu_error: return NULL; } /****************************************************************************** * * * Paramètres : content = flux de données à analyser. * * size = taille de chacun des éléments à représenter. * * count = nombre de ces éléments. * * addr = position courante dans ce flux. [OUT] * * endian = ordre des bits dans la source. * * * * Description : Crée une instruction de type 'db/dw/etc' étendue. * * * * Retour : Instruction mise en place. * * * * Remarques : - * * * ******************************************************************************/ GArchInstruction *g_raw_instruction_new_array(const GBinContent *content, MemoryDataSize size, size_t count, vmpa2t *addr, SourceEndian endian) { GArchInstruction *result; /* Instruction à retourner */ vmpa2t old; /* Sauvegarde de la position */ size_t i; /* Boucle de parcours */ GArchOperand *operand; /* Octet non décodé à afficher */ mrange_t range; /* Couverture de l'instruction */ /* Par soucis de cohérence */ if (count == 0) return NULL; result = g_object_new(G_TYPE_RAW_INSTRUCTION, NULL); copy_vmpa(&old, addr); for (i = 0; i < count; i++) { operand = g_imm_operand_new_from_data(size, content, addr, endian); if (operand == NULL) goto grina_error; g_imm_operand_pad(G_IMM_OPERAND(operand), true); g_arch_instruction_attach_extra_operand(result, operand); } init_mrange(&range, &old, compute_vmpa_diff(addr, &old)); g_arch_instruction_set_range(result, &range); return result; grina_error: g_object_unref(G_OBJECT(result)); return NULL; } /****************************************************************************** * * * Paramètres : instr = instruction quelconque à consulter. * * * * Description : Indique l'encodage d'une instruction de façon détaillée. * * * * Retour : Description humaine de l'encodage utilisé. * * * * Remarques : - * * * ******************************************************************************/ static const char *g_raw_instruction_get_encoding(const GRawInstruction *instr) { const char *result; /* Description à retourner */ if (instr->is_string) result = _("String"); else result = _("Raw"); return result; } /****************************************************************************** * * * Paramètres : instr = instruction d'assemblage à représenter. * * buffer = espace où placer ledit contenu. * * msize = taille idéale des positions et adresses; * * content = contenu binaire global à venir lire. * * syntax = type de représentation demandée. * * * * Description : Ajoute à un tampon GLib le contenu de l'instance spécifiée. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ static GBufferLine *g_raw_instruction_print(GRawInstruction *instr, GCodeBuffer *buffer, MemoryDataSize msize, const GBinContent *content, AsmSyntax syntax) { GBufferLine *result; /* Ligne de destination */ GArchInstruction *base; /* Autre version de l'instance */ const char *key; /* Mot clef principal */ size_t klen; /* Taille de ce mot clef */ char *string; /* Chaîne reconstituée */ size_t iter; /* Tête d'écriture */ bool first; /* Mémorise une énumération */ size_t i; /* Boucle de parcours */ char byte; /* Octet à afficher (ou pas) */ bool status; /* Bilan d'une récupération */ base = G_ARCH_INSTRUCTION(instr); if (!instr->is_padding && !instr->is_string) result = G_ARCH_INSTRUCTION_CLASS(g_raw_instruction_parent_class)->print(base, buffer, msize, content, syntax); else { result = g_code_buffer_prepare_new_line(buffer, &base->range); g_buffer_line_add_flag(result, BLF_HAS_CODE); g_buffer_line_fill_mrange(result, msize/* TODO ! */, msize); /* Instruction proprement dite */ key = g_arch_instruction_get_keyword(base, syntax); klen = strlen(key); g_buffer_line_insert_text(result, BLC_ASSEMBLY_HEAD, key, klen, RTT_INSTRUCTION); if (instr->is_padding) g_buffer_line_insert_text(result, BLC_ASSEMBLY, "...", 3, RTT_RAW); else /*if (instr->is_string)*/ { string = (char *)calloc(base->operands_count + 3, sizeof(char)); strcpy(string, "\""); iter = 1; first = true; for (i = 0; i < base->operands_count; i++) { status = g_imm_operand_get_value(G_IMM_OPERAND(base->operands[i]), MDS_8_BITS, &byte); assert(status); /* Si le caractère doit apparaître en hexadécimal... */ if (!isprint(byte)) { /* Si une chaîne précède */ if (iter > 1) { if (!first) { g_buffer_line_insert_text(result, BLC_ASSEMBLY, ",", 1, RTT_PUNCT); g_buffer_line_insert_text(result, BLC_ASSEMBLY, " ", 1, RTT_RAW); } else first = false; string[iter++] = '"'; g_buffer_line_insert_text(result, BLC_ASSEMBLY, string, iter, RTT_STRING); iter = 1; } /* Impression de l'octet */ if (!first) { g_buffer_line_insert_text(result, BLC_ASSEMBLY, ",", 1, RTT_PUNCT); g_buffer_line_insert_text(result, BLC_ASSEMBLY, " ", 1, RTT_RAW); } else first = false; g_arch_operand_print(base->operands[i], result, syntax); } else string[iter++] = byte; } /* Si une chaîne reste encore */ if (iter > 1) { if (!first) { g_buffer_line_insert_text(result, BLC_ASSEMBLY, ",", 1, RTT_PUNCT); g_buffer_line_insert_text(result, BLC_ASSEMBLY, " ", 1, RTT_RAW); } else first = false; string[iter++] = '"'; g_buffer_line_insert_text(result, BLC_ASSEMBLY, string, iter, RTT_STRING); } free(string); } } return result; } /****************************************************************************** * * * Paramètres : instr = instruction à traiter. * * format = format du binaire manipulé. * * syntax = type de représentation demandée. * * * * Description : Reconstruit le cache complet d'une désignation d'instruction.* * * * Retour : Mot clef de bas niveau. * * * * Remarques : - * * * ******************************************************************************/ static void g_raw_instruction_build_keyword(const GRawInstruction *instr, AsmSyntax syntax) { GArchOperand *operand; /* Octet décodé à afficher */ MemoryDataSize size; /* Taille de valeur associée */ static char *defines[] = { "dn", "db", "dw", "dd", "dq" }; operand = g_arch_instruction_get_operand(G_ARCH_INSTRUCTION(instr), 0); if (G_IS_TARGET_OPERAND(operand)) size = g_target_operand_get_size(G_TARGET_OPERAND(operand)); else size = g_imm_operand_get_size(G_IMM_OPERAND(operand)); G_ARCH_INSTRUCTION(instr)->cached_keyword = strdup(defines[MDS_RANGE(size)]); } /****************************************************************************** * * * Paramètres : instr = instruction à traiter. * * is_padding = nouveau statut à associer au contenu. * * * * Description : Marque l'instruction comme ne contenant que du bourrage. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void g_raw_instruction_mark_as_padding(GRawInstruction *instr, bool is_padding) { instr->is_padding = is_padding; } /****************************************************************************** * * * Paramètres : instr = instruction à traiter. * * is_padding = nouveau statut à associer au contenu. * * * * Description : Indique si le contenu de l'instruction est du bourrage. * * * * Retour : Statut du contenu de l'instruction. * * * * Remarques : - * * * ******************************************************************************/ bool g_raw_instruction_is_padding(const GRawInstruction *instr) { return instr->is_padding; } /****************************************************************************** * * * Paramètres : instr = instruction à traiter. * * is_string = nouveau statut à associer au contenu. * * * * Description : Marque l'instruction comme contenant une chaîne de texte. * * * * Retour : - * * * * Remarques : - * * * ******************************************************************************/ void g_raw_instruction_mark_as_string(GRawInstruction *instr, bool is_string) { instr->is_string = is_string; } /****************************************************************************** * * * Paramètres : instr = instruction à traiter. * * is_string = nouveau statut à associer au contenu. * * * * Description : Indique si le contenu de l'instruction est un texte. * * * * Retour : Statut du contenu de l'instruction. * * * * Remarques : - * * * ******************************************************************************/ bool g_raw_instruction_is_string(const GRawInstruction *instr) { return instr->is_string; }