diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/analysis/disass/area.c | 1085 | ||||
| -rw-r--r-- | src/analysis/disass/area.h | 43 | ||||
| -rw-r--r-- | src/analysis/disass/disassembler.c | 11 | ||||
| -rw-r--r-- | src/analysis/disass/fetch.c | 429 | ||||
| -rw-r--r-- | src/analysis/disass/fetch.h | 3 | ||||
| -rw-r--r-- | src/arch/archbase.h | 25 | ||||
| -rw-r--r-- | src/arch/arm/context-int.h | 1 | ||||
| -rw-r--r-- | src/arch/arm/context.c | 18 | ||||
| -rw-r--r-- | src/arch/arm/v7/context.c | 10 | ||||
| -rw-r--r-- | src/arch/context-int.h | 12 | ||||
| -rw-r--r-- | src/arch/context.c | 69 | ||||
| -rw-r--r-- | src/arch/context.h | 2 | ||||
| -rw-r--r-- | src/common/bits.c | 68 | ||||
| -rw-r--r-- | src/common/bits.h | 9 | ||||
| -rw-r--r-- | src/format/elf/elf.c | 6 | ||||
| -rw-r--r-- | src/format/symbol.h | 4 |
16 files changed, 1711 insertions, 84 deletions
diff --git a/src/analysis/disass/area.c b/src/analysis/disass/area.c index 1d841be..355b716 100644 --- a/src/analysis/disass/area.c +++ b/src/analysis/disass/area.c @@ -27,6 +27,1087 @@ #include <assert.h> +#include <i18n.h> + + +#include "../../analysis/contents/restricted.h" +#include "../../common/bits.h" +#include "../../gui/panels/log.h" + + + + +/* Zone mémoire bien bornée */ +typedef struct _mem_area_v2 +{ + GBinFormat *format; /* Format du fichier binaire */ + GBinContent *content; /* Données binaires à lire */ + GArchProcessor *proc; /* Architecture du binaire */ + SourceEndian endianness; /* Boutisme de cette machine */ + + mrange_t range; /* Couverture de la zone */ + + phys_t packing_size; /* Granularité des découpages */ + + bitfield_t *processed; /* Octets traités dans la zone */ + GArchInstruction **instructions; /* Instructions en place */ + + + + + bool is_exec; /* Zone exécutable ? */ + +} mem_area_v2; + + + +/* Initialise une aire de données à partir d'une adresse donnée. */ +static void init_mem_area_from_addr_v2(mem_area_v2 *, const vmpa2t *, phys_t, const GLoadedBinary *); + +/* Libère d'une aire de données les ressources allouées. */ +static void fini_mem_area_v2(mem_area_v2 *); + +/* Indique si une zone donnée est intégralement vierge ou non. */ +static bool is_range_blank_in_mem_area_v2(mem_area_v2 *, phys_t, phys_t); + +/* Marque une série d'octets comme ayant été traités. */ +static bool mark_range_in_mem_area_as_processed_v2(mem_area_v2 *, GArchInstruction *, bool); + + + + +/* Procède au désassemblage d'un contenu binaire non exécutable. */ +static void load_data_from_mem_area_v2(mem_area_v2 *, GProcContext *, const vmpa2t *, status_blob_info *); + +/* S'assure qu'une aire contient toutes ses instructions. */ +static void fill_mem_area_v2(mem_area_v2 *, mem_area_v2 *, size_t, GProcContext *, status_blob_info *); + +/* Rassemble les instructions conservées dans une zone donnée. */ +static GArchInstruction *get_instructions_from_mem_area_v2(const mem_area_v2 *); + + + + + + +/* S'assure de la présence d'un début de routine à un point. */ +static void update_address_as_routine(GBinFormat *, const vmpa2t *); + + +/** + * Content :: à passer en restricted. + + * Les sections croisées : pas de sens de les traiter ici, car au final une instruction sera à cheval + * sur deux sections différentes -> incohérence au niveau de l'éditeur. + * => régler le périmètres de segments règle donc tous les soucis. + + */ + + + + + + + + +/****************************************************************************** +* * +* Paramètres : area = aire représentant à contenu à initialiser. * +* addr = adresse de départ de l'espace à mettre en place. * +* len = longueur de l'espace à créer. * +* binary = binaire analysé content quantités d'informations. * +* * +* Description : Initialise une aire de données à partir d'une adresse donnée.* +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void init_mem_area_from_addr_v2(mem_area_v2 *area, const vmpa2t *addr, phys_t len, const GLoadedBinary *binary) +{ + GBinContent *content; /* Données binaires à lire */ + + assert(len > 0); + + area->format = G_BIN_FORMAT(g_loaded_binary_get_format(binary)); + + content = g_binary_format_get_content(area->format); + + area->proc = g_loaded_binary_get_processor(binary); + area->endianness = g_arch_processor_get_endianness(area->proc); + + init_mrange(&area->range, addr, len); + + area->content = g_restricted_content_new(content, &area->range); + + area->packing_size = 2; /* FIXME */ + + area->processed = create_bit_field(len, false); + area->instructions = (GArchInstruction **)calloc(len, sizeof(GArchInstruction *)); + +} + + +/****************************************************************************** +* * +* Paramètres : area = aire représentant à contenu à nettoyer en mémoire. * +* * +* Description : Libère d'une aire de données les ressources allouées. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void fini_mem_area_v2(mem_area_v2 *area) +{ + phys_t len; /* Etendue du parcours total */ + phys_t i; /* Boucle de parcours */ + + //g_object_unref(area->format); /* FIXME */ + g_object_unref(area->content); + //g_object_unref(area->proc); /* FIXME */ + + delete_bit_field(area->processed); + + len = get_mrange_length(&area->range); + + for (i = 0; i < len; i++) + if (area->instructions[i] != NULL) + g_object_unref(G_OBJECT(area->instructions[i])); + + free(area->instructions); + +} + + +/****************************************************************************** +* * +* Paramètres : area = aire représentant à contenu à parcourir. * +* start = début de la zone à manipuler. * +* len = taille de cette même aire de données. * +* * +* Description : Indique si une zone donnée est intégralement vierge ou non. * +* * +* Retour : true si l'aire visée n'a jamais été traitée, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool is_range_blank_in_mem_area_v2(mem_area_v2 *area, phys_t start, phys_t len) +{ + bool result; /* Résultat à renvoyer */ + + if ((start + len) >= get_mrange_length(&area->range)) + result = false; + + else + result = !test_in_bit_field(area->processed, start, len); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : area = aire représentant à contenu à parcourir. * +* instr = instruction à mémoriser pour la suite. * +* force = impose l'enregistrement de l'instruction. * +* * +* Description : Marque une série d'octets comme ayant été traités. * +* * +* Retour : true si l'enregistrement a bien été réalisé, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool mark_range_in_mem_area_as_processed_v2(mem_area_v2 *area, GArchInstruction *instr, bool force) +{ + bool result; /* Bilan d'action à renvoyer */ + const vmpa2t *start; /* Adresse de départ de la zone*/ + const mrange_t *range; /* Emplacement d'instruction */ + const vmpa2t *addr; /* Début de la zone à traiter */ + phys_t len; /* Taille de l'aire visée */ + phys_t offset; /* Décallage de départ */ + + start = get_mrange_addr(&area->range); + + range = g_arch_instruction_get_range(instr); + addr = get_mrange_addr(range); + len = get_mrange_length(range); + + offset = compute_vmpa_diff(start, addr); + + result = set_atomic_in_bit_field(area->processed, offset, len); + + /* Si l'instruction était bien la première à s'inscrire... */ + + result |= force; + + if (result) + area->instructions[offset] = instr; + + return result; + +} + + + + + + + + + + + + + + + +/****************************************************************************** +* * +* Paramètres : area = aire représentant à contenu à parcourir. * +* list = liste de zones délimitant des contenus à traiter. * +* count = nombre de zones à disposition. * +* index = indice de l'aire à considérer pendant l'opération. * +* binary = représentation de binaire chargé. * +* ctx = contexte offert en soutien à un désassemblage. * +* start = démarrage de l'exécution au sein de la zone. * +* info = indications quant à la progression à afficher. * +* * +* Description : Procède au désassemblage d'un contenu binaire exécutable. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void load_code_from_mem_area_v2(mem_area_v2 *area, mem_area_v2 *list, size_t count, GProcContext *ctx, const vmpa2t *start, status_blob_info *info) +{ + + + + GBinFormat *format; /* Format du fichier binaire */ + GArchProcessor *proc; /* Architecture du binaire */ + GBinContent *content; /* Données binaires à lire */ + + phys_t diff; /* Volume de données traité */ + phys_t alen; /* Taille de l'aire utilisée */ + + phys_t i; /* Boucle de parcours */ + + + vmpa2t pos; /* Boucle de parcours */ + vmpa2t prev; /* Boucle de parcours */ + + GArchInstruction *instr; /* Instruction décodée */ + + + + mrange_t range; /* Couverture de l'instruction */ + + + bool done; /* Enregistrement effectué ? */ + + + vmpa2t sym_addr; /* Adresse de nouveau symbole */ + bool has_new_sym; /* Statut d'un dépilement */ + + GBinSymbol *symbol; /* Symbole créé en parallèle */ + + + + + + /* Récupération des informations de base */ + + format = area->format; + proc = area->proc; + content = area->content; + + diff = compute_vmpa_diff(get_mrange_addr(&area->range), start); + alen = get_mrange_length(&area->range); + + copy_vmpa(&pos, start); + + /* Traitement de la zone */ + + printf("=== processing @ 0x%08x\n", (unsigned int)start->virtual); + + for (i = diff; i < alen; i += diff) + { + /** + * On réalise un premier test informel (car non atomique) peu coûteux + * avant de se lancer dans un désassemblage d'instruction potentiellement + * inutile. + */ + + printf(" (%u) blank ? %d\n", (unsigned int)i, is_range_blank_in_mem_area_v2(area, i, 1)); + printf(" +1 blank ? %d\n", is_range_blank_in_mem_area_v2(area, i + 1, 1)); + + if (!is_range_blank_in_mem_area_v2(area, i, 1)) + break; + + /* Décodage d'une nouvelle instruction */ + + copy_vmpa(&prev, &pos); + + instr = g_arch_processor_disassemble(proc, ctx, content, &pos); + if (instr == NULL) break; + + /* Enregistrement des positions et adresses */ + + diff = compute_vmpa_diff(&prev, &pos); + + init_mrange(&range, &prev, diff); + + g_arch_instruction_set_range(instr, &range); + + /* Progression dans les traitements */ + + done = mark_range_in_mem_area_as_processed_v2(area, instr, false); + + if (!done) + { + g_object_unref(G_OBJECT(instr)); + break; + } + + inc_progessive_status(info, diff); + + assert(!is_range_blank_in_mem_area_v2(area, i, diff)); + + /* Enregistrement d'un éventuel début de routine */ + + if (g_arch_instruction_get_flags(instr) & AIF_ROUTINE_START) + update_address_as_routine(format, &prev); + + /* Eventuel renvoi vers d'autres adresses */ + + g_arch_instruction_call_hook(instr, IPH_FETCH, proc, ctx, format); + + /* Insertion des symboles découverts en parallèle */ + + for (has_new_sym = g_proc_context_pop_new_symbol_at(ctx, &sym_addr); + has_new_sym; + has_new_sym = g_proc_context_pop_new_symbol_at(ctx, &sym_addr)) + { + has_new_sym = g_binary_format_find_symbol_at(format, &sym_addr, &symbol); + assert(has_new_sym); + + insert_extra_symbol_into_mem_areas_v2(list, count, symbol); + + } + + /* Rupture du flot d'exécution ? */ + if (g_arch_instruction_get_flags(instr) & AIF_RETURN_POINT) + break; + + } + +} + + +/****************************************************************************** +* * +* Paramètres : area = aire représentant à contenu à parcourir. * +* ctx = contexte offert en soutien à un désassemblage. * +* start = démarrage de l'exécution au sein de la zone. * +* info = indications quant à la progression à afficher. * +* * +* Description : Procède au désassemblage d'un contenu binaire non exécutable.* +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void load_data_from_mem_area_v2(mem_area_v2 *area, GProcContext *ctx, const vmpa2t *start, status_blob_info *info) +{ + GBinContent *content; /* Données binaires à lire */ + SourceEndian endianness; /* Boutisme de cette machine */ + phys_t diff; /* Volume de données traité */ + phys_t alen; /* Taille de l'aire utilisée */ + vmpa2t pos; /* Boucle de parcours */ + phys_t i; /* Boucle de parcours */ + vmpa2t prev; /* Boucle de parcours */ + GArchInstruction *instr; /* Instruction décodée */ + mrange_t range; /* Couverture de l'instruction */ + bool done; /* Enregistrement effectué ? */ + + /* Récupération des informations de base */ + + content = area->content; + endianness = area->endianness; + + diff = compute_vmpa_diff(get_mrange_addr(&area->range), start); + alen = get_mrange_length(&area->range); + + copy_vmpa(&pos, start); + + /* Traitement de la zone */ + + for (i = diff; i < alen; i += diff) + { + /* On cherche à obtenir l'assurance que le traitement n'a jamais été fait */ + + if (!is_range_blank_in_mem_area_v2(area, i, 1)) + break; + + instr = NULL; + + copy_vmpa(&prev, &pos); + + /* Décodage d'une nouvelle instruction, sur mesure puis minimale */ + + if (get_virt_addr(&pos) % area->packing_size == 0 + && is_range_blank_in_mem_area_v2(area, i, area->packing_size)) + { + diff = area->packing_size; + + instr = g_raw_instruction_new_array(content, MDS_FROM_BYTES(diff), 1, &pos, endianness); + + if (instr == NULL) + copy_vmpa(&pos, &prev); + + } + + if (instr == NULL) + { + diff = 1; + + instr = g_raw_instruction_new_array(content, MDS_8_BITS, 1, &pos, endianness); + + } + + /* On rencontre ici un morceau déjà traité. */ + + if (instr == NULL) break; + + /* Enregistrement des positions et adresses */ + + assert(diff == compute_vmpa_diff(&prev, &pos)); + + init_mrange(&range, &prev, diff); + + g_arch_instruction_set_range(instr, &range); + + /* Progression dans les traitements */ + + done = mark_range_in_mem_area_as_processed_v2(area, instr, false); + + if (!done) + { + g_object_unref(G_OBJECT(instr)); + break; + } + + inc_progessive_status(info, diff); + + assert(!is_range_blank_in_mem_area_v2(area, i, diff)); + + /* On laisse une chance au code pour se reprendre... */ + + if (area->is_exec) break; + + } + +} + + +/****************************************************************************** +* * +* Paramètres : area = aire représentant à contenu à parcourir. * +* list = liste de zones délimitant des contenus à traiter. * +* count = nombre de zones à disposition. * +* binary = représentation de binaire chargé. * +* ctx = contexte offert en soutien à un désassemblage. * +* info = indications quant à la progression à afficher. * +* * +* Description : S'assure qu'une aire contient toutes ses instructions. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void fill_mem_area_v2(mem_area_v2 *area, mem_area_v2 *list, size_t count, GProcContext *ctx, status_blob_info *info) +{ + const vmpa2t *addr; /* Début de la zone à traiter */ + phys_t len; /* Taille de la zone à remplir */ + phys_t i; /* Boucle de parcours */ + vmpa2t start; /* Adresse de départ de combles*/ + + addr = get_mrange_addr(&area->range); + len = get_mrange_length(&area->range); + + for (i = 0; i < len; i++) + { + if (is_range_blank_in_mem_area_v2(area, i, 1)) + { + copy_vmpa(&start, addr); + advance_vmpa(&start, i); + + if (area->is_exec && get_virt_addr(&start) % area->packing_size == 0) + load_code_from_mem_area_v2(area, list, count, ctx, &start, info); + + if (is_range_blank_in_mem_area_v2(area, i, 1)) + load_data_from_mem_area_v2(area, ctx, &start, info); + + } + + assert(!is_range_blank_in_mem_area_v2(area, i, 1)); + + } + +} + + +/****************************************************************************** +* * +* Paramètres : area = aire représentant à contenu à parcourir. * +* * +* Description : Rassemble les instructions conservées dans une zone donnée. * +* * +* Retour : Liste d'instructions prêtes à emploi. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static GArchInstruction *get_instructions_from_mem_area_v2(const mem_area_v2 *area) +{ + GArchInstruction *result; /* Liste d'instr. à renvoyer */ + phys_t len; /* Nombre d'instructions au max*/ + phys_t i; /* Boucle de parcours */ + GArchInstruction *instr; /* Instruction décodée */ + + result = NULL; + + len = get_mrange_length(&area->range); + + for (i = 0; i < len; i++) + { + instr = area->instructions[i]; + + if (instr != NULL) + { + g_object_ref(G_OBJECT(instr)); + g_arch_instruction_add_to_list(&result, instr); + } + + } + + return result; + +} + + + + + + + + + + + + + + + + + + + + + + + +/****************************************************************************** +* * +* Paramètres : list = listes de zones utable à consulter. * +* count = nombre de zones mises en place. * +* addr = adresse à retrouver dans les aires présentes. * +* * +* Description : Détermine une liste de zones contigües à traiter. * +* * +* Retour : Indice de la zone trouvée, ou nombre d'aires en cas d'échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +mem_area_v2 *find_memory_area_by_addr_v2(mem_area_v2 *list, size_t count, const vmpa2t *addr) +{ + mem_area_v2 *result; /* Elément trouvé à renvoyer */ + + int find_mem_area(const vmpa2t *addr, const mem_area_v2 *area) + { + int status; /* Bilan à retourner */ + + if (mrange_contains_addr(&area->range, addr)) + status = 0; + + else + status = cmp_vmpa(addr, get_mrange_addr(&area->range)); + + return status; + + } + + result = bsearch(addr, list, count, sizeof(mem_area_v2), (__compar_fn_t)find_mem_area); + + return result; + +} + + + + + + + + +/****************************************************************************** +* * +* Paramètres : binary = binaire analysé contenant quantités d'infos. * +* bin_length = quantité d'octets à traiter au total. * +* count = nombre de zones mises en place. [OUT] * +* * +* Description : Détermine une liste de zones contigües à traiter. * +* * +* Retour : Liste de zones mémoire à libérer après usage. * +* * +* Remarques : - * +* * +******************************************************************************/ + +mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *binary, phys_t bin_length, size_t *count) +{ + mem_area_v2 *result; /* Liste à renvoyer */ + GExeFormat *format; /* Format de fichier associé */ + mrange_t *exe_ranges; /* Liste de zones exécutables */ + size_t exe_count; /* Nombre de ces zones */ + GBinSymbol **symbols; /* Symboles à représenter */ + size_t sym_count; /* Qté de symboles présents */ + vmpa2t last; /* Dernière bordure rencontrée */ + bool status; /* Bilan d'une conversion */ + size_t i; /* Boucle de parcours #1 */ + const vmpa2t *border; /* Nouvelle bordure rencontrée */ + mem_area_v2 *area; /* Zone avec valeurs à éditer */ + vmpa2t tmp; /* Stockage temporaire */ + GBinPortion **portions; /* Morceaux d'encadrement */ + size_t portions_count; /* Taille de cette liste */ + const vmpa2t *portion_start; /* Point de départ de portion */ + size_t j; /* Boucle de parcours #2 */ + SymbolType type; /* Nature d'un symbole */ + const mrange_t *range; /* Couverture d'un symbole */ + phys_t length; /* Taille de ce même symbole */ + phys_t new_length; /* Nouvelle taille déterminée */ + + result = NULL; + *count = 0; + + /** + * Le parcours n'est valide que si les zones exécutables sont triées ! + */ + + format = g_loaded_binary_get_format(binary); + + exe_ranges = g_exe_format_get_x_ranges(format, &exe_count); + + symbols = g_binary_format_get_symbols(G_BIN_FORMAT(format), &sym_count); + + /* Première étape : on comble les trous ! */ + + status = g_exe_format_translate_offset_into_vmpa(format, 0, &last); + assert(status); + + for (i = 0; i < exe_count; i++) + { + border = get_mrange_addr(&exe_ranges[i]); + + /* Zone tampon à constituer */ + + if (cmp_vmpa(&last, border) < 0) + { + result = (mem_area_v2 *)realloc(result, ++(*count) * sizeof(mem_area_v2)); + + area = &result[*count - 1]; + + init_mem_area_from_addr_v2(area, &last, compute_vmpa_diff(&last, border), binary); + area->is_exec = false; + + } + + /* Insertion d'une zone exécutable déjà définie */ + + result = (mem_area_v2 *)realloc(result, ++(*count) * sizeof(mem_area_v2)); + + area = &result[*count - 1]; + + init_mem_area_from_addr_v2(area, get_mrange_addr(&exe_ranges[i]), + get_mrange_length(&exe_ranges[i]), binary); + area->is_exec = true; + + /* Avancée du curseur */ + + compute_mrange_end_addr(&exe_ranges[i], &last); + + } + + /* Extension finale complémentaire ? */ + + area = &result[*count - 1]; + + copy_vmpa(&tmp, get_mrange_addr(&area->range)); + advance_vmpa(&tmp, get_mrange_length(&area->range)); + + if (get_phy_addr(&tmp) < bin_length) + { + result = (mem_area_v2 *)realloc(result, ++(*count) * sizeof(mem_area_v2)); + + area = &result[*count - 1]; + + init_mem_area_from_addr_v2(area, &tmp, bin_length - get_phy_addr(&tmp), binary); + area->is_exec = false; + + } + + + + + + + + + for (i = 0; i < *count; i++) + { + printf(" (init) AREA %zu :: 0x%x / 0x%x + 0x%x\n", + i, + (unsigned int)get_phy_addr(get_mrange_addr(&result[i].range)), + (unsigned int)get_virt_addr(get_mrange_addr(&result[i].range)), + (unsigned int)get_mrange_length(&result[i].range)); + + } + + printf("--------------------\n"); + + + + + + + + + /* Seconde étape : on s'assure du découpage autour des portions pour respecter l'alignement */ + + portions = g_exe_format_get_portions_at_level(format, -1, &portions_count); + + for (i = 1; i < portions_count; i++) + { + portion_start = get_mrange_addr(g_binary_portion_get_range(portions[i])); + + printf(" [portion % 3zu] addr = 0x%x / 0x%x\n", + i, + (unsigned int)get_phy_addr(portion_start), + (unsigned int)get_virt_addr(portion_start)); + + for (j = 0; j < *count; j++) + { + area = &result[j]; + + if (!mrange_contains_addr(&area->range, portion_start)) + continue; + + /* Si le déccoupage actuel ne correspond pas au besoin des portions... */ + if (cmp_vmpa(get_mrange_addr(&area->range), portion_start) != 0) + { + fini_mem_area_v2(&result[j]); + + result = (mem_area_v2 *)realloc(result, ++(*count) * sizeof(mem_area_v2)); + + memmove(&result[j + 2], &result[j + 1], (*count - j - 2) * sizeof(mem_area_v2)); + + status = result[j].is_exec; + + /* Première moitié */ + + area = &result[j]; + + copy_vmpa(&tmp, get_mrange_addr(&area->range)); + length = get_mrange_length(&area->range); + + new_length = compute_vmpa_diff(&tmp, portion_start); + + init_mem_area_from_addr_v2(area, &tmp, new_length, binary); + area->is_exec = status; + + /* Seconde moitié */ + + length -= get_mrange_length(&area->range); + + area = &result[j + 1]; + + init_mem_area_from_addr_v2(area, portion_start, length, binary); + area->is_exec = status; + + } + + j = *count; + + } + + } + + + + + + + + + for (i = 0; i < *count; i++) + { + printf(" (fini) AREA %zu :: 0x%x / 0x%x + 0x%x\n", + i, + (unsigned int)get_phy_addr(get_mrange_addr(&result[i].range)), + (unsigned int)get_virt_addr(get_mrange_addr(&result[i].range)), + (unsigned int)get_mrange_length(&result[i].range)); + + } + + printf("--------------------\n"); + + + + + + + + + /* Troisième étape : on insère les symboles existants */ + + for (i = 0; i < sym_count; i++) + { + type = g_binary_symbol_get_target_type(symbols[i]); + + /** + * On ne garde que les symboles renvoyant directement une ou + * plusieurs instructions, c'est à dire les symboles valides + * pour un appel à g_binary_symbol_get_instruction(). + * + * Les instructions des autres symboles sont obtenues et mises + * en place durant la procédure de désassemblage. + */ + + if (type == STP_ROUTINE || type == STP_ENTRY_POINT || type == STP_CODE_LABEL) + continue; + + range = g_binary_symbol_get_range(symbols[i]); + + length = get_mrange_length(range); + + if (length == 0) + continue; + + insert_extra_symbol_into_mem_areas_v2(result, *count, symbols[i]); + + } + + /* Nettoyage final */ + + if (portions != NULL) + free(portions); + + if (exe_ranges != NULL) + free(exe_ranges); + + /// FIXME g_object_unref(G_OBJECT(format)); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : areas = liste de zones délimitant des contenus à traiter. * +* count = nombre de zones à disposition. * +* symbol = élément nouveau à venir insérer dans les zones. * +* * +* Description : Insère un symbole dans un découpage en aires. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void insert_extra_symbol_into_mem_areas_v2(mem_area_v2 *areas, size_t count, const GBinSymbol *symbol) +{ + SymbolType type; /* Type de symbole */ + GArchInstruction *list; /* Ensemble à insérer */ + GArchInstruction *iter; /* Boucle de parcours */ + const mrange_t *range; /* Emplacement d'instruction */ + const vmpa2t *addr; /* Départ de cet emplacement */ + mem_area_v2 *area; /* Zone d'accueil désignée */ + VMPA_BUFFER(loc); /* Description d'un emplacement*/ + phys_t start; /* Point de départ */ + + type = g_binary_symbol_get_target_type(symbol); + + if (!HAS_DATA_INSTR(type)) + return; + + list = g_binary_symbol_get_instruction(symbol); + + for (iter = list; iter != NULL; iter = g_arch_instruction_get_next_iter(list, iter, ~0)) + { + range = g_arch_instruction_get_range(iter); + addr = get_mrange_addr(range); + + /* Une aire d'accueil existe-t-elle ? */ + + area = find_memory_area_by_addr_v2(areas, count, addr); + + if (area == NULL) + { + vmpa2_virt_to_string(addr, MDS_UNDEFINED, loc, NULL); + + log_variadic_message(LMT_WARNING, _("No place found for symbol located at %s."), loc); + continue; + + } + + /* L'instruction est-elle accueillie dans son intégralité ? */ + + start = compute_vmpa_diff(get_mrange_addr(&area->range), addr); + + if (start + get_mrange_length(range) > get_mrange_length(&area->range)) + { + vmpa2_virt_to_string(addr, MDS_UNDEFINED, loc, NULL); + + log_variadic_message(LMT_WARNING, _("The symbol located at %s is too big for one place only."), loc); + continue; + + } + + /* Inscription d'une instruction de symbole (sans retour arrière possible :/ ) */ + + mark_range_in_mem_area_as_processed_v2(area, iter, true); + + g_object_ref(G_OBJECT(iter)); + + } + +} + + +/****************************************************************************** +* * +* Paramètres : list = liste de zones délimitant des contenus à traiter. * +* count = nombre de zones à disposition. * +* binary = représentation de binaire chargé. * +* ctx = contexte offert en soutien à un désassemblage. * +* info = indications quant à la progression à afficher. * +* * +* Description : S'assure que l'ensemble des aires est entièrement décodé. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void ensure_all_mem_areas_are_filled(mem_area_v2 *list, size_t count, GProcContext *ctx, status_blob_info *info) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < count; i++) + fill_mem_area_v2(&list[i], list, count, ctx, info); + +} + + +/****************************************************************************** +* * +* Paramètres : areas = série d'aires représentant à contenu à parcourir. * +* count = nombre de ces zones présentes. * +* * +* Description : Rassemble les instructions conservées dans des zones données.* +* * +* Retour : Liste d'instructions prêtes à emploi. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GArchInstruction *collect_instructions_from_mem_areas_v2(const mem_area_v2 *list, size_t count) +{ + GArchInstruction *result; /* Liste d'instr. à renvoyer */ + size_t i; /* Boucle de parcours */ + GArchInstruction *instr; /* Instruction(s) à insérer */ + + result = NULL; + + for (i = 0; i < count; i++) + { + instr = get_instructions_from_mem_area_v2(&list[i]); + g_arch_instruction_merge_lists(&result, &instr); + } + + return result; + +} + + + + + + + + + + + + + + + +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// +//////////////////////////////////:::////////////////////////////////////////////////////////////////////// + + + /* Zone mémoire bien bornée */ typedef struct _mem_area @@ -72,7 +1153,7 @@ static bool mark_range_in_mem_area_as_processed(mem_area *, phys_t, phys_t, GArc /* S'assure de la présence d'un début de routine à un point. */ -static void update_address_as_routine(GBinFormat *, const vmpa2t *); +//static void update_address_as_routine(GBinFormat *, const vmpa2t *); @@ -1468,8 +2549,6 @@ static bool insert_extra_symbol_into_mem_areas(mem_area **list, size_t *count, G memmove(&(*list)[index + 1], &(*list)[index], (*count - index - 1) * sizeof(mem_area)); - /* Aire raccourcie */ - copy_vmpa(&area_pos, get_mrange_addr(&area_range)); new_length = get_mrange_length(&area_range) - get_mrange_length(sym_range); diff --git a/src/analysis/disass/area.h b/src/analysis/disass/area.h index 35a3533..aa26da0 100644 --- a/src/analysis/disass/area.h +++ b/src/analysis/disass/area.h @@ -25,10 +25,52 @@ #define _ANALYSIS_DISASS_AREA_H +#include "../binary.h" +#include "../../arch/instruction.h" +#include "../../gtkext/gtkextstatusbar.h" + + + + +/* Zone mémoire bien bornée */ +typedef struct _mem_area_v2 mem_area_v2; + + + + + +/* Procède au désassemblage d'un contenu binaire exécutable. */ +void load_code_from_mem_area_v2(mem_area_v2 *, mem_area_v2 *, size_t, GProcContext *, const vmpa2t *, status_blob_info *); + + + + +/* Détermine une liste de zones contigües à traiter. */ +mem_area_v2 *find_memory_area_by_addr_v2(mem_area_v2 *, size_t, const vmpa2t *); + + + +/* Détermine une liste de zones contigües à traiter. */ +mem_area_v2 *compute_memory_areas_v2(const GLoadedBinary *, phys_t, size_t *); + +/* Insère un symbole dans un découpage en aires. */ +void insert_extra_symbol_into_mem_areas_v2(mem_area_v2 *, size_t, const GBinSymbol *); + +/* S'assure que l'ensemble des aires est entièrement décodé. */ +void ensure_all_mem_areas_are_filled(mem_area_v2 *, size_t, GProcContext *, status_blob_info *); + +/* Rassemble les instructions conservées dans des zones données. */ +GArchInstruction *collect_instructions_from_mem_areas_v2(const mem_area_v2 *, size_t); + + + + + #include <stdbool.h> + #include "../binary.h" #include "../../format/executable.h" #include "../../gtkext/gtkextstatusbar.h" @@ -48,6 +90,7 @@ typedef struct _mem_area mem_area; + /* Procède au désassemblage d'un contenu binaire exécutable. */ bool load_code_from_mem_area(mem_area **, size_t *, size_t *, const GLoadedBinary *, GProcContext *, const vmpa2t *, status_blob_info *); diff --git a/src/analysis/disass/disassembler.c b/src/analysis/disass/disassembler.c index ce49aca..ce2e6ff 100644 --- a/src/analysis/disass/disassembler.c +++ b/src/analysis/disass/disassembler.c @@ -190,6 +190,8 @@ static GDelayedDisassembly *g_delayed_disassembly_new(GLoadedBinary *binary, GAr static void g_delayed_disassembly_process(GDelayedDisassembly *disass, GtkExtStatusBar *statusbar) { + wgroup_id_t gid; /* Identifiant pour les tâches */ + //GBinFormat *format; /* Format du fichier binaire */ GArchProcessor *proc; /* Architecture du binaire */ @@ -208,6 +210,13 @@ static void g_delayed_disassembly_process(GDelayedDisassembly *disass, GtkExtSta //GArchProcessor *proc; /* Architecture du binaire */ + + gid = g_work_queue_define_work_group(get_work_queue()); + + + + + //format = G_BIN_FORMAT(g_loaded_binary_get_format(binary)); proc = g_loaded_binary_get_processor(disass->binary); @@ -225,7 +234,7 @@ static void g_delayed_disassembly_process(GDelayedDisassembly *disass, GtkExtSta - *disass->instrs = disassemble_binary_content(disass->binary, statusbar); + *disass->instrs = disassemble_binary_content(disass->binary, gid, statusbar); g_arch_processor_set_disassembled_instructions(proc, *disass->instrs); diff --git a/src/analysis/disass/fetch.c b/src/analysis/disass/fetch.c index 67a6f3b..bfc0598 100644 --- a/src/analysis/disass/fetch.c +++ b/src/analysis/disass/fetch.c @@ -31,18 +31,331 @@ #include "area.h" +#include "../../glibext/delayed-int.h" + + + + + + + + +/* ------------------------- RECUPERATIONS EN TOILE DE FOND ------------------------- */ +/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */ + + +#define G_TYPE_DELAYED_FETCHING g_delayed_fetching_get_type() +#define G_DELAYED_FETCHING(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_delayed_fetching_get_type(), GDelayedFetching)) +#define G_IS_DELAYED_FETCHING(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_delayed_fetching_get_type())) +#define G_DELAYED_FETCHING_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_DELAYED_FETCHING, GDelayedFetchingClass)) +#define G_IS_DELAYED_FETCHING_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_DELAYED_FETCHING)) +#define G_DELAYED_FETCHING_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_DELAYED_FETCHING, GDelayedFetchingClass)) + + +/* Ensembles binaires à désassembler (instance) */ +typedef struct _GDelayedFetching +{ + GDelayedWork parent; /* A laisser en premier */ + + wgroup_id_t gid; /* Groupe de travail parallèle */ + + GExeFormat *format; /* Format du fichier binaire */ + + GProcContext *ctx; /* Contexte de désassemblage */ + mem_area_v2 *areas; /* Zone de productions */ + size_t count; /* Nombre de ces zones */ + status_blob_info *info; /* Informations de progression */ + + virt_t virt; /* Adresse de départ dépilée */ + +} GDelayedFetching; + +/* Ensembles binaires à désassembler (classe) */ +typedef struct _GDelayedFetchingClass +{ + GDelayedWorkClass parent; /* A laisser en premier */ + +} GDelayedFetchingClass; + + +/* Indique le type défini pour les tâches de récupération différée. */ +GType g_delayed_fetching_get_type(void); + +/* Initialise la classe des tâches de désassemblage différé. */ +static void g_delayed_fetching_class_init(GDelayedFetchingClass *); + +/* Initialise une tâche de désassemblage différé. */ +static void g_delayed_fetching_init(GDelayedFetching *); + +/* Supprime toutes les références externes. */ +static void g_delayed_fetching_dispose(GDelayedFetching *); + +/* Procède à la libération totale de la mémoire. */ +static void g_delayed_fetching_finalize(GDelayedFetching *); + +/* Crée une tâche de récupération d'instructions différée. */ +static GDelayedFetching *g_delayed_fetching_new(const GDelayedFetching *, virt_t); + +/* Assure la récupération d'instructions en différé. */ +static void g_delayed_fetching_process(GDelayedFetching *, GtkExtStatusBar *); + + + + + + + + + + +/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */ +/* ------------------------ DESASSEMBLAGE DE BINAIRE DIFFERE ------------------------ */ + /* Suit un flot d'exécution pour désassembler du code. */ static void follow_execution_flow(const GLoadedBinary *, GProcContext *, mem_area **, size_t *, status_blob_info *); -/* S'assure que l'ensemble des aires est entièrement décodé. */ -static void ensure_all_mem_areas_are_filled(mem_area **, size_t *, const GLoadedBinary *, GProcContext *, status_blob_info *); + + +/* ---------------------------------------------------------------------------------- */ +/* RECUPERATIONS EN TOILE DE FOND */ +/* ---------------------------------------------------------------------------------- */ + + + + + + + + +/* Indique le type défini pour les tâches de récupération différée. */ +G_DEFINE_TYPE(GDelayedFetching, g_delayed_fetching, G_TYPE_DELAYED_WORK); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des tâches de récupération différée. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_delayed_fetching_class_init(GDelayedFetchingClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GDelayedWorkClass *work; /* Version en classe parente */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_delayed_fetching_dispose; + object->finalize = (GObjectFinalizeFunc)g_delayed_fetching_finalize; + + work = G_DELAYED_WORK_CLASS(klass); + + work->run = (run_task_fc)g_delayed_fetching_process; + +} + + +/****************************************************************************** +* * +* Paramètres : fetching = instance à initialiser. * +* * +* Description : Initialise une tâche de récupération différée. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_delayed_fetching_init(GDelayedFetching *fetching) +{ + + + +} + + +/****************************************************************************** +* * +* Paramètres : fetching = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_delayed_fetching_dispose(GDelayedFetching *fetching) +{ + g_object_unref(G_OBJECT(fetching->format)); + + g_object_unref(G_OBJECT(fetching->ctx)); + + G_OBJECT_CLASS(g_delayed_fetching_parent_class)->dispose(G_OBJECT(fetching)); + +} + + +/****************************************************************************** +* * +* Paramètres : fetching = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_delayed_fetching_finalize(GDelayedFetching *fetching) +{ + G_OBJECT_CLASS(g_delayed_fetching_parent_class)->finalize(G_OBJECT(fetching)); + +} + + +/****************************************************************************** +* * +* Paramètres : template = modèle dont les informations sont à copier. * +* virt = point départ dépilé et personnalisant l'instance. * +* * +* Description : Crée une tâche de récupération d'instructions différée. * +* * +* Retour : Tâche créée. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static GDelayedFetching *g_delayed_fetching_new(const GDelayedFetching *template, virt_t virt) +{ + GDelayedFetching *result; /* Tâche à retourner */ + + result = g_object_new(G_TYPE_DELAYED_FETCHING, NULL); + + result->gid = template->gid; + + result->format = template->format; + g_object_ref(G_OBJECT(result->format)); + + result->ctx = template->ctx; + g_object_ref(G_OBJECT(result->ctx)); + + result->areas = template->areas; + result->count = template->count; + result->info = template->info; + + result->virt = virt; + + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : fetching = récupération à mener. * +* statusbar = barre de statut à tenir informée. * +* * +* Description : Assure la récupération d'instructions en différé. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_delayed_fetching_process(GDelayedFetching *fetching, GtkExtStatusBar *statusbar) +{ + vmpa2t addr; /* Conversion en pleine adresse*/ + mem_area_v2 *area; /* Zone trouvée à traiter */ + + if (!g_exe_format_translate_address_into_vmpa(fetching->format, fetching->virt, &addr)) + init_vmpa(&addr, VMPA_NO_PHYSICAL, fetching->virt); + + area = find_memory_area_by_addr_v2(fetching->areas, fetching->count, &addr); + + if (area != NULL) + load_code_from_mem_area_v2(area, fetching->areas, fetching->count, + fetching->ctx, &addr, fetching->info); + +} + + + + + + + + + + +/* Poursuit l'analyse à partir des points d'entrée découverts. */ +static void follow_execution_flow_v2(GProcContext *, const GDelayedFetching *); + + + + + + + +/****************************************************************************** +* * +* Paramètres : ctx = contexte de désass. avec une nouvelle entrée. * +* template = modèle dont les informations sont à copier. * +* * +* Description : Poursuit l'analyse à partir des points d'entrée découverts. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void follow_execution_flow_v2(GProcContext *ctx, const GDelayedFetching *template) +{ + GWorkQueue *queue; /* Gestionnaire de différés */ + virt_t virt; /* Adresse de départ dépilée */ + GDelayedFetching *fetching; /* Récupération à mener */ + + queue = get_work_queue(); + + while (g_proc_context_pop_drop_point(ctx, &virt)) + { + fetching = g_delayed_fetching_new(template, virt); + + /** + * Pas très élégant : l'identifiant du groupe de travail ne sert qu'ici ; + * il n'est donc aucune utilité dans la tâche elle-même. + * + * Cependant, les paramètres d'appel étant limités, il faudrait créer + * une structure intermediare pour communiquer l'identifiant, ce qui + * est tout aussi moche. + */ + + g_work_queue_schedule_work(queue, G_DELAYED_WORK(fetching), template->gid); + + } + +} + + /****************************************************************************** * * * Paramètres : binary = représentation de binaire chargé. * @@ -68,7 +381,7 @@ static void follow_execution_flow(const GLoadedBinary *binary, GProcContext *ctx while (g_proc_context_has_drop_points(ctx)) { - virt = g_proc_context_pop_drop_point(ctx); + g_proc_context_pop_drop_point(ctx, &virt); format = g_loaded_binary_get_format(binary); @@ -96,38 +409,13 @@ static void follow_execution_flow(const GLoadedBinary *binary, GProcContext *ctx } - -/****************************************************************************** -* * -* Paramètres : list = liste de zones délimitant des contenus à traiter. * -* count = nombre de zones à disposition. * -* binary = représentation de binaire chargé. * -* ctx = contexte offert en soutien à un désassemblage. * -* info = indications quant à la progression à afficher. * -* * -* Description : S'assure que l'ensemble des aires est entièrement décodé. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -static void ensure_all_mem_areas_are_filled(mem_area **list, size_t *count, const GLoadedBinary *binary, GProcContext *ctx, status_blob_info *info) -{ - size_t i; /* Boucle de parcours */ - - for (i = 0; i < *count; i++) - fill_mem_area(list, count, &i, binary, ctx, info); - -} - +static GDelayedFetching template; /* Patron des tâches à venir */ /****************************************************************************** * * * Paramètres : binary = représentation de binaire chargé. * +* gid = identifiant du groupe de travail à utiliser. * * statusbar = barre de statut avec progression à mettre à jour.* -* id = identifiant du message affiché à l'utilisateur. * * * * Description : Procède au désassemblage basique d'un contenu binaire. * * * @@ -137,75 +425,96 @@ static void ensure_all_mem_areas_are_filled(mem_area **list, size_t *count, cons * * ******************************************************************************/ -GArchInstruction *disassemble_binary_content(const GLoadedBinary *binary, GtkExtStatusBar *statusbar) +GArchInstruction *disassemble_binary_content(const GLoadedBinary *binary, wgroup_id_t gid, GtkExtStatusBar *statusbar) { GArchInstruction *result; /* Instruction désassemblées */ + //GDelayedFetching template; /* Patron des tâches à venir */ GBinFormat *format; /* Format du fichier binaire */ GArchProcessor *proc; /* Architecture du binaire */ - GProcContext *ctx; /* Contexte de désassemblage */ GBinContent *content; /* Contenu binaire à manipuler */ phys_t length; /* Taille des données à lire */ - mem_area *areas; /* Zone de productions */ - size_t count; /* Nombre de ces zones */ - status_blob_info *info; /* Informations de progression */ + GWorkQueue *queue; /* Gestionnaire de différés */ double done; /* Portion de travail accompli */ - format = G_BIN_FORMAT(g_loaded_binary_get_format(binary)); - proc = g_loaded_binary_get_processor(binary); - ctx = g_arch_processor_get_context(proc); - g_binary_format_setup_disassembling_context(format, ctx); - /* Définition à la découpe des parties à traiter */ + + + + + + /* Constitution du modèle de référence */ + + template.gid = gid; + + template.format = g_loaded_binary_get_format(binary); + format = G_BIN_FORMAT(template.format); + + proc = g_loaded_binary_get_processor(binary); + template.ctx = g_arch_processor_get_context(proc); + g_object_unref(G_OBJECT(proc)); content = g_binary_format_get_content(format); length = g_binary_content_compute_size(content); + g_object_unref(G_OBJECT(content)); - areas = compute_memory_areas(G_EXE_FORMAT(format), length, &count); + template.areas = compute_memory_areas_v2(binary, length, &template.count); + + /* Amorce des traitements */ + + g_signal_connect(template.ctx, "drop-point-pushed", G_CALLBACK(follow_execution_flow_v2), &template); + + queue = get_work_queue(); /** * Première phase de désassemblage : suivi des chemins tracés. */ - info = init_progessive_status(statusbar, - _("Disassembling following the execution flow..."), - 0, length); + template.info = init_progessive_status(statusbar, + _("Disassembling following the execution flow..."), + 0, length); + + g_binary_format_setup_disassembling_context(format, template.ctx); + + g_work_queue_wait_for_completion(queue, gid); - follow_execution_flow(binary, ctx, &areas, &count, info); + printf("===================== DONE !\n"); - done = get_current_progessive_status(info); + done = get_current_progessive_status(template.info); - fini_progessive_status(info); + fini_progessive_status(template.info); /** * Seconde phase : on comble les trous laissés. */ - info = init_progessive_status(statusbar, - _("Disassembling the remaining instructions..."), - done, length); + template.info = init_progessive_status(statusbar, + _("Disassembling the remaining instructions..."), + done, length); - ensure_all_mem_areas_are_filled(&areas, &count, binary, ctx, info); + ensure_all_mem_areas_are_filled(template.areas, template.count, template.ctx, template.info); - fini_progessive_status(info); + fini_progessive_status(template.info); /** * Troisième et dernière phase : récolte des fruits. */ - info = init_progessive_status(statusbar, - _("Collecting disassembled instructions..."), - 0, length); + template.info = init_progessive_status(statusbar, + _("Collecting disassembled instructions..."), + 0, length); - result = collect_instructions_from_mem_areas(areas, count); + result = collect_instructions_from_mem_areas_v2(template.areas, template.count); - fini_progessive_status(info); + fini_progessive_status(template.info); - /* free */ + /* Libérations finales */ - g_object_unref(G_OBJECT(content)); + //g_object_unref(G_OBJECT(template.format)); - g_object_unref(G_OBJECT(proc)); + g_object_unref(G_OBJECT(template.ctx)); + + /* TODO / del(areas); */ return result; diff --git a/src/analysis/disass/fetch.h b/src/analysis/disass/fetch.h index 0270f78..37dac80 100644 --- a/src/analysis/disass/fetch.h +++ b/src/analysis/disass/fetch.h @@ -26,12 +26,13 @@ #include "../binary.h" +#include "../../glibext/delayed.h" #include "../../gtkext/gtkextstatusbar.h" /* Procède au désassemblage basique d'un contenu binaire. */ -GArchInstruction *disassemble_binary_content(const GLoadedBinary *, GtkExtStatusBar *); +GArchInstruction *disassemble_binary_content(const GLoadedBinary *, wgroup_id_t, GtkExtStatusBar *); diff --git a/src/arch/archbase.h b/src/arch/archbase.h index 24cfd77..fc6fe4d 100644 --- a/src/arch/archbase.h +++ b/src/arch/archbase.h @@ -74,6 +74,31 @@ typedef enum _MemoryDataSize #define MDS_IS_SIGNED(mds) (mds & 0x80) +#define MDS_FROM_BYTES(sz) \ + ({ \ + MemoryDataSize __result; \ + switch (sz) \ + { \ + case 1: \ + __result = MDS_8_BITS_UNSIGNED; \ + break; \ + case 2: \ + __result = MDS_16_BITS_UNSIGNED; \ + break; \ + case 4: \ + __result = MDS_32_BITS_UNSIGNED; \ + break; \ + case 8: \ + __result = MDS_64_BITS_UNSIGNED; \ + break; \ + default: \ + __result = MDS_UNDEFINED; \ + break; \ + } \ + __result; \ + }) + + #define MDS_4_BITS MDS_4_BITS_UNSIGNED #define MDS_8_BITS MDS_8_BITS_UNSIGNED #define MDS_16_BITS MDS_16_BITS_UNSIGNED diff --git a/src/arch/arm/context-int.h b/src/arch/arm/context-int.h index 51ed6d0..fbd3a6f 100644 --- a/src/arch/arm/context-int.h +++ b/src/arch/arm/context-int.h @@ -50,6 +50,7 @@ struct _GArmContext disass_arm_area *areas; /* Désassemblage découpé */ size_t acount; /* Nombre de zones définies */ + GMutex areas_access; /* Accès aux découpes de zones */ }; diff --git a/src/arch/arm/context.c b/src/arch/arm/context.c index b54de42..d805e8c 100644 --- a/src/arch/arm/context.c +++ b/src/arch/arm/context.c @@ -139,6 +139,7 @@ static void g_arm_context_class_init(GArmContextClass *klass) static void g_arm_context_init(GArmContext *ctx) { + g_mutex_init(&ctx->areas_access); } @@ -157,6 +158,8 @@ static void g_arm_context_init(GArmContext *ctx) static void g_arm_context_dispose(GArmContext *ctx) { + g_mutex_clear(&ctx->areas_access); + G_OBJECT_CLASS(g_arm_context_parent_class)->dispose(G_OBJECT(ctx)); } @@ -263,11 +266,11 @@ void _g_arm_context_define_encoding(GArmContext *ctx, virt_t addr, unsigned int { size_t selected; /* Zone associée à une adresse */ - /* TODO : pose de verroux ? */ + g_mutex_lock(&ctx->areas_access); selected = find_disass_arm_area(ctx->areas, addr, 0, ctx->acount - 1); - assert(ctx->areas[selected].start != addr || ctx->areas[selected].marker == marker); + //assert(ctx->areas[selected].start != addr || ctx->areas[selected].marker == marker); /* S'agit-il d'une redéfinition ? */ if (ctx->areas[selected].start == addr) @@ -290,6 +293,8 @@ void _g_arm_context_define_encoding(GArmContext *ctx, virt_t addr, unsigned int } + g_mutex_unlock(&ctx->areas_access); + } @@ -308,13 +313,18 @@ void _g_arm_context_define_encoding(GArmContext *ctx, virt_t addr, unsigned int unsigned int _g_arm_context_find_encoding(GArmContext *ctx, virt_t addr) { + unsigned int result; /* Identifiant à retourner */ size_t selected; /* Zone associée à une adresse */ - /* TODO : pose de verroux ? */ + g_mutex_lock(&ctx->areas_access); selected = find_disass_arm_area(ctx->areas, addr, 0, ctx->acount - 1); - return ctx->areas[selected].marker; + result = ctx->areas[selected].marker; + + g_mutex_unlock(&ctx->areas_access); + + return result; } diff --git a/src/arch/arm/v7/context.c b/src/arch/arm/v7/context.c index 885ce70..030457e 100644 --- a/src/arch/arm/v7/context.c +++ b/src/arch/arm/v7/context.c @@ -245,7 +245,15 @@ void g_armv7_context_push_drop_point_ext(GArmV7Context *ctx, virt_t addr, ArmV7I g_armv7_context_define_encoding(ctx, addr, marker); - G_PROC_CONTEXT_CLASS(g_armv7_context_parent_class)->push_point(G_PROC_CONTEXT(ctx), addr); + /** + * Il faut impérativement passer pour l'interface publique afin : + * - de poser le verrou associé. + * - de déclencher l'émission du signal lié. + * + * Pas d'appel via G_PROC_CONTEXT_CLASS(g_armv7_context_parent_class)->push_point() donc. + */ + + g_proc_context_push_drop_point(G_PROC_CONTEXT(ctx), addr); } diff --git a/src/arch/context-int.h b/src/arch/context-int.h index 64465a2..086a8ec 100644 --- a/src/arch/context-int.h +++ b/src/arch/context-int.h @@ -29,6 +29,10 @@ +/* Granularité des allocations */ +#define DP_ALLOC_BLOCK 10 + + /* Ajoute une adresse virtuelle comme point de départ de code. */ typedef void (* push_drop_point_fc) (GProcContext *, virt_t); @@ -39,7 +43,9 @@ struct _GProcContext GObject parent; /* A laisser en premier */ virt_t *drop_points; /* Liste de points de départ */ - size_t dp_count; /* Taille de cette liste */ + size_t dp_allocated; /* Taille de liste allouée */ + size_t dp_count; /* Quantité utile de la liste */ + GMutex dp_access; /* Accès à la liste FIFO */ vmpa2t *extra_symbols; /* Adresses de symboles */ size_t esyms_count; /* Nombres de nouveautés */ @@ -54,6 +60,10 @@ struct _GProcContextClass push_drop_point_fc push_point; /* Inclusion de points de chute*/ + /* Signaux */ + + void (* drop_point_pushed) (GProcContext *); + }; diff --git a/src/arch/context.c b/src/arch/context.c index 5427e4a..968a6ea 100644 --- a/src/arch/context.c +++ b/src/arch/context.c @@ -65,6 +65,14 @@ static void g_proc_context_class_init(GProcContextClass *klass) { klass->push_point = (push_drop_point_fc)_g_proc_context_push_drop_point; + g_signal_new("drop-point-pushed", + G_TYPE_PROC_CONTEXT, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(GProcContextClass, drop_point_pushed), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + } @@ -83,7 +91,9 @@ static void g_proc_context_class_init(GProcContextClass *klass) static void g_proc_context_init(GProcContext *ctx) { ctx->drop_points = NULL; + ctx->dp_allocated = 0; ctx->dp_count = 0; + g_mutex_init(&ctx->dp_access); ctx->extra_symbols = NULL; ctx->esyms_count = 0; @@ -106,9 +116,15 @@ static void g_proc_context_init(GProcContext *ctx) static void _g_proc_context_push_drop_point(GProcContext *ctx, virt_t addr) { - ctx->drop_points = (virt_t *)realloc(ctx->drop_points, ++ctx->dp_count * sizeof(virt_t)); + if (ctx->dp_count >= ctx->dp_allocated) + { + ctx->dp_allocated += DP_ALLOC_BLOCK; + + ctx->drop_points = (virt_t *)realloc(ctx->drop_points, ctx->dp_allocated * sizeof(virt_t)); + + } - ctx->drop_points[ctx->dp_count - 1] = addr; + ctx->drop_points[ctx->dp_count++] = addr; } @@ -128,7 +144,13 @@ static void _g_proc_context_push_drop_point(GProcContext *ctx, virt_t addr) void g_proc_context_push_drop_point(GProcContext *ctx, virt_t addr) { - return G_PROC_CONTEXT_GET_CLASS(ctx)->push_point(ctx, addr); + g_mutex_lock(&ctx->dp_access); + + G_PROC_CONTEXT_GET_CLASS(ctx)->push_point(ctx, addr); + + g_mutex_unlock(&ctx->dp_access); + + g_signal_emit_by_name(ctx, "drop-point-pushed"); } @@ -147,7 +169,15 @@ void g_proc_context_push_drop_point(GProcContext *ctx, virt_t addr) bool g_proc_context_has_drop_points(const GProcContext *ctx) { - return ctx->dp_count > 0; + bool result; /* Etat à retourner */ + + g_mutex_lock(&ctx->dp_access); + + result = (ctx->dp_count > 0); + + g_mutex_unlock(&ctx->dp_access); + + return result; } @@ -172,9 +202,13 @@ bool g_proc_context_has_addr_as_drop_points(const GProcContext *ctx, virt_t addr result = false; + g_mutex_lock(&ctx->dp_access); + for (i = 0; i < ctx->dp_count && !result; i++) result = (ctx->drop_points[i] == addr); + g_mutex_unlock(&ctx->dp_access); + return result; } @@ -183,27 +217,38 @@ bool g_proc_context_has_addr_as_drop_points(const GProcContext *ctx, virt_t addr /****************************************************************************** * * * Paramètres : ctx = contexte de désassemblage à compléter. * +* virt = adresse d'un point de départ de code à traiter. * * * * Description : Fournit une adresse virtuelle comme point de départ de code. * * * -* Retour : Adresse d'un point de départ de code à traiter. * +* Retour : true si une adresse a pu être dépilée, false sinon. * * * * Remarques : - * * * ******************************************************************************/ -virt_t g_proc_context_pop_drop_point(GProcContext *ctx) +bool g_proc_context_pop_drop_point(GProcContext *ctx, virt_t *virt) { - virt_t result; /* Adresse à retourner */ + bool result; /* Bilan d'accès à retourner */ - assert(ctx->dp_count > 0); + g_mutex_lock(&ctx->dp_access); - result = ctx->drop_points[0]; + if (ctx->dp_count > 0) + { + result = true; + + *virt = ctx->drop_points[0]; + + if (ctx->dp_count > 1) + memmove(&ctx->drop_points[0], &ctx->drop_points[1], (ctx->dp_count - 1) * sizeof(virt_t)); - if (ctx->dp_count > 1) - memmove(&ctx->drop_points[0], &ctx->drop_points[1], (ctx->dp_count - 1) * sizeof(virt_t)); + ctx->dp_count--; + + } + else + result = false; - ctx->drop_points = (virt_t *)realloc(ctx->drop_points, --ctx->dp_count * sizeof(virt_t)); + g_mutex_unlock(&ctx->dp_access); return result; diff --git a/src/arch/context.h b/src/arch/context.h index 390d9f9..973b7ae 100644 --- a/src/arch/context.h +++ b/src/arch/context.h @@ -61,7 +61,7 @@ bool g_proc_context_has_drop_points(const GProcContext *); bool g_proc_context_has_addr_as_drop_points(const GProcContext *, virt_t); /* Fournit une adresse virtuelle comme point de départ de code. */ -virt_t g_proc_context_pop_drop_point(GProcContext *); +bool g_proc_context_pop_drop_point(GProcContext *, virt_t *); /* Empile une adresse de nouveau symbole à prendre en compte. */ void g_proc_context_push_new_symbol_at(GProcContext *, const vmpa2t *); diff --git a/src/common/bits.c b/src/common/bits.c index d451100..b08dcb4 100644 --- a/src/common/bits.c +++ b/src/common/bits.c @@ -25,6 +25,7 @@ #include <assert.h> +#include <glib.h> #include <malloc.h> #include <string.h> @@ -41,6 +42,7 @@ struct _bitfield_t void *tail; /* Limite du tableau de bits */ + GMutex mutex; /* Garantie d'atomicité */ unsigned long bits[0]; /* Mémoire d'accès associée */ }; @@ -94,6 +96,8 @@ static bitfield_t *_create_bit_field(size_t length, bool state, size_t extra) result->tail = ((char *)result) + base; + g_mutex_init(&result->mutex); + if (state) set_all_in_bit_field(result); else @@ -177,6 +181,8 @@ bitfield_t *create_bit_field_from(const bitfield_t *field) void delete_bit_field(bitfield_t *field) { + g_mutex_clear(&field->mutex); + free(field); } @@ -330,6 +336,68 @@ void set_in_bit_field(bitfield_t *field, size_t first, size_t count) /****************************************************************************** * * +* Paramètres : field = champ de bits à modifier. * +* first = indice du premier bit à traiter. * +* count = nombre de bits à marquer. * +* * +* Description : Bascule à 1 de façon atomique une partie d'un champ de bits. * +* * +* Retour : true si la zone traitée était entièrement vierge. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool set_atomic_in_bit_field(bitfield_t *field, size_t first, size_t count) +{ + bool result; /* Bilan à retourner */ + size_t start; /* Mot de départ */ + size_t end; /* Mot d'arrivée */ + size_t remaining; /* Nombre de bits restants */ + unsigned long oldval; /* Ancienne valeur présente */ + unsigned long mask; /* Nouvelle valeur à insérer */ + + start = first / (sizeof(unsigned long) * 8); + end = (first + count - 1) / (sizeof(unsigned long) * 8); + +#if 0 //sizeof(gsize) != sizeof(unsigned long) +# warning "Can not perform atomic operations on bit fields!" +#else + if (start == end) + { + remaining = first % (sizeof(unsigned long) * 8); + + assert(count > 0); + + mask = (1 << count) - 1; + mask <<= remaining; + + oldval = g_atomic_pointer_or(&field->bits[start], mask); + + result = ((oldval & mask) == 0); + + } + else +#endif + { + g_mutex_lock(&field->mutex); + + result = !test_in_bit_field(field, first, count); + + if (result) + set_in_bit_field(field, first, count); + + g_mutex_unlock(&field->mutex); + + } + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : dest = champ de bits à modifier. * * src = champ de bits à utiliser pour l'opération. * * * diff --git a/src/common/bits.h b/src/common/bits.h index 0e8ef65..074aac4 100644 --- a/src/common/bits.h +++ b/src/common/bits.h @@ -60,6 +60,9 @@ void set_all_in_bit_field(bitfield_t *); /* Bascule à 1 une partie d'un champ de bits. */ void set_in_bit_field(bitfield_t *, size_t, size_t); +/* Bascule à 1 de façon atomique une partie d'un champ de bits. */ +bool set_atomic_in_bit_field(bitfield_t *, size_t, size_t); + /* Réalise une opération ET logique entre deux champs de bits. */ void and_bit_field(bitfield_t *, const bitfield_t *); @@ -74,6 +77,7 @@ bool is_bit_field_equal_to(const bitfield_t *, const bitfield_t *); + unsigned long gfw(const bitfield_t *); @@ -104,4 +108,9 @@ bool test_in_mem_field(memfield_t *, const vmpa2t *); +#define set_atomic_in_mem_field(f, range) false + + + + #endif /* _COMMON_BITS_H */ diff --git a/src/format/elf/elf.c b/src/format/elf/elf.c index ea520b9..3dc5d64 100644 --- a/src/format/elf/elf.c +++ b/src/format/elf/elf.c @@ -432,6 +432,12 @@ static void g_elf_format_refine_portions(const GElfFormat *format, GBinPortion * sh_flags = ELF_SHDR(format, section, sh_flags); + printf("[section % 2hu] 0x%08x -> %x -> %d\n", i, sh_flags, + sh_flags & SHF_ALLOC, (sh_flags & SHF_ALLOC) == 0); + + if ((sh_flags & SHF_ALLOC) == 0) + continue; + if (sh_flags & SHF_EXECINSTR) background = BPC_CODE; else if (sh_flags & SHF_WRITE) background = BPC_DATA; else background = BPC_DATA_RO; diff --git a/src/format/symbol.h b/src/format/symbol.h index 1368691..6f38020 100644 --- a/src/format/symbol.h +++ b/src/format/symbol.h @@ -51,6 +51,10 @@ typedef enum _SymbolType } SymbolType; +#define HAS_DATA_INSTR(type) (type == STP_DATA || type == STP_RO_STRING) + + + #define G_TYPE_BIN_SYMBOL g_binary_symbol_get_type() #define G_BIN_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), g_binary_symbol_get_type(), GBinSymbol)) #define G_IS_BIN_SYMBOL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), g_binary_symbol_get_type())) |