diff options
| author | Cyrille Bagard <nocbos@gmail.com> | 2023-08-18 00:07:39 (GMT) |
|---|---|---|
| committer | Cyrille Bagard <nocbos@gmail.com> | 2023-08-18 00:07:39 (GMT) |
| commit | 2424c52c4f3bc44ce5f36348442cfa103e0989c2 (patch) | |
| tree | f68aea488f403b234d4fcc6fd6e0f7b88a628ac8 /src/analysis/scan | |
| parent | 1c5a0e67186def152536d9c506e2e6c3a3a265c5 (diff) | |
Create some modifiers and handle match properties inside ROST.
Diffstat (limited to 'src/analysis/scan')
76 files changed, 7897 insertions, 524 deletions
diff --git a/src/analysis/scan/context-int.h b/src/analysis/scan/context-int.h index 3a971b8..8a5fbaf 100644 --- a/src/analysis/scan/context-int.h +++ b/src/analysis/scan/context-int.h @@ -74,6 +74,7 @@ struct _GScanContext GScanOptions *options; /* Options d'analyses */ GBinContent *content; /* Contenu binaire traité */ + bool scan_done; /* Phase d'analyse terminée ? */ patid_t next_patid; /* Prochain indice utilisable */ diff --git a/src/analysis/scan/context.c b/src/analysis/scan/context.c index f108e93..a3be86b 100644 --- a/src/analysis/scan/context.c +++ b/src/analysis/scan/context.c @@ -55,7 +55,7 @@ static void add_match_to_full_match_tracker(full_match_tracker_t *, GScanMatch * - +/* --------------------- MEMORISATION DE PROGRESSIONS D'ANALYSE --------------------- */ /* Initialise la classe des contextes de suivi d'analyses. */ @@ -72,10 +72,6 @@ static void g_scan_context_finalize(GScanContext *); - - - - /* ---------------------------------------------------------------------------------- */ /* ADMINISTRATION DES CORRESPONDANCES TOTALES */ /* ---------------------------------------------------------------------------------- */ @@ -191,10 +187,9 @@ static void add_match_to_full_match_tracker(full_match_tracker_t *tracker, GScan - - - - +/* ---------------------------------------------------------------------------------- */ +/* MEMORISATION DE PROGRESSIONS D'ANALYSE */ +/* ---------------------------------------------------------------------------------- */ /* Indique le type défini pour un contexte de suivi d'analyse. */ @@ -242,6 +237,7 @@ static void g_scan_context_init(GScanContext *context) context->options = NULL; context->content = NULL; + context->scan_done = false; context->next_patid = 0; @@ -378,7 +374,7 @@ GScanContext *g_scan_context_new(GScanOptions *options) * * ******************************************************************************/ -GScanOptions *g_scan_context_get_options(GScanContext *context) +GScanOptions *g_scan_context_get_options(const GScanContext *context) { GScanOptions *result; /* Ensemble à retourner */ @@ -467,6 +463,48 @@ GBinContent *g_scan_context_get_content(const GScanContext *context) /****************************************************************************** * * +* Paramètres : context = instance à consulter. * +* * +* Description : Indique si la phase d'analyse de contenu est terminée. * +* * +* Retour : true si la phase de scan est terminée, false sinon. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_scan_context_is_scan_done(const GScanContext *context) +{ + bool result; /* Statut à retourner */ + + result = context->scan_done; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : context = instance à mettre à jour. * +* * +* Description : Note que la phase d'analyse de contenu est terminée. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_scan_context_mark_scan_as_done(GScanContext *context) +{ + context->scan_done = true; + +} + + +/****************************************************************************** +* * * Paramètres : context = instance à mettre à jour. * * id = identifiant du motif trouvé. * * offset = localisation du motif au sein d'un contenu. * @@ -615,41 +653,6 @@ const GScanMatch **g_scan_context_get_full_matches(const GScanContext *context, /****************************************************************************** * * -* Paramètres : context = mémoire de résultats d'analyse à consulter. * -* * -* Description : Affiche les correspondances identifiées. * -* * -* Retour : - * -* * -* Remarques : - * -* * -******************************************************************************/ - -void g_scan_context_display(GScanContext *context) -{ - size_t i; /* Boucle de parcours */ - const rule_condition_t *cond; /* Conditions de orrespondance */ - - /* - FIXME : ordre - for (i = 0; i < context->full_used; i++) - g_scan_match_display(context->full_matches[i]); - */ - - for (i = 0; i < context->cond_count; i++) - { - cond = &context->conditions[i]; - - if (g_scan_context_has_match_for_rule(context, cond->name)) - fprintf(stderr, "Rule '%s' has matched!\n", cond->name); - - } - -} - - -/****************************************************************************** -* * * Paramètres : context = mémoire de résultats d'analyse à compléter. * * name = désignation de la règle ciblée. * * expr = expression de condition à réduire. * diff --git a/src/analysis/scan/context.h b/src/analysis/scan/context.h index 563a53e..ff6b373 100644 --- a/src/analysis/scan/context.h +++ b/src/analysis/scan/context.h @@ -66,7 +66,7 @@ GType g_scan_context_get_type(void); GScanContext *g_scan_context_new(GScanOptions *); /* Fournit l'ensemble des options à respecter pour les analyses. */ -GScanOptions *g_scan_context_get_options(GScanContext *); +GScanOptions *g_scan_context_get_options(const GScanContext *); /* Fournit un identifiant unique pour un motif recherché. */ patid_t g_scan_context_get_new_pattern_id(GScanContext *); @@ -77,6 +77,12 @@ void g_scan_context_set_content(GScanContext *, GBinContent *); /* Fournit une référence au contenu principal analysé. */ GBinContent *g_scan_context_get_content(const GScanContext *); +/* Indique si la phase d'analyse de contenu est terminée. */ +bool g_scan_context_is_scan_done(const GScanContext *); + +/* Note que la phase d'analyse de contenu est terminée. */ +void g_scan_context_mark_scan_as_done(GScanContext *); + /* Enregistre une correspondance partielle dans un contenu. */ void g_scan_context_register_atom_match(GScanContext *, patid_t, phys_t); @@ -89,9 +95,6 @@ void g_scan_context_register_full_match(GScanContext *, GScanMatch *); /* Fournit la liste de toutes les correspondances d'un motif. */ const GScanMatch **g_scan_context_get_full_matches(const GScanContext *, const GSearchPattern *, size_t *); -/* Affiche les correspondances identifiées. */ -void g_scan_context_display(GScanContext *); - /* Intègre une condition de correspondance pour règle. */ bool g_scan_context_set_rule_condition(GScanContext *, const char *, const GScanExpression *); diff --git a/src/analysis/scan/core.c b/src/analysis/scan/core.c index d940ab5..d102d58 100644 --- a/src/analysis/scan/core.c +++ b/src/analysis/scan/core.c @@ -25,6 +25,8 @@ #include <config.h> +#include <malloc.h> +#include <string.h> #include "items/count.h" @@ -38,8 +40,168 @@ #endif #include "items/time/make.h" #include "items/time/now.h" +#include "patterns/modifiers/hex.h" +#include "patterns/modifiers/plain.h" +#include "patterns/modifiers/rev.h" +/* Liste des modificateurs disponibles */ + +typedef struct _available_modifier_t +{ + char *name; /* Désignation humaine */ + GScanTokenModifier *instance; /* Mécanisme correspondant */ + +} available_modifier_t; + +static available_modifier_t *__modifiers = NULL; +static size_t __modifiers_count = 0; + + +/****************************************************************************** +* * +* Paramètres : modifier = modificateur à rendre disponible. * +* * +* Description : Inscrit un modificateur dans la liste des disponibles. * +* * +* Retour : Bilan des enregistrements effectués : true si nouveauté. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool register_scan_token_modifier(GScanTokenModifier *modifier) +{ + bool result; /* Bilan à retourner */ + char *name; /* Nom donné au modificateur */ + GScanTokenModifier *found; /* Alternative présente */ + available_modifier_t *last; /* Emplacement disponible */ + + name = g_scan_token_modifier_get_name(modifier); + + found = find_scan_token_modifiers_for_name(name); + + result = (found == NULL); + + if (!result) + free(name); + + else + { + __modifiers_count++; + __modifiers = realloc(__modifiers, __modifiers_count * sizeof(available_modifier_t)); + + last = &__modifiers[__modifiers_count - 1]; + + last->name = name; + last->instance = modifier; + + g_object_ref(G_OBJECT(modifier)); + + } + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Charge tous les modificateurs de base. * +* * +* Retour : Bilan des opérations d'enregistrement. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool load_all_known_scan_token_modifiers(void) +{ + bool result; /* Bilan à retourner */ + + result = true; + +#define REGISTER_SCAN_MODIFIER(m) \ + ({ \ + bool __status; \ + __status = register_scan_token_modifier(m); \ + g_object_unref(G_OBJECT(m)); \ + __status; \ + }) + + if (result) result = REGISTER_SCAN_MODIFIER(g_scan_hex_modifier_new()); + if (result) result = REGISTER_SCAN_MODIFIER(g_scan_plain_modifier_new()); + if (result) result = REGISTER_SCAN_MODIFIER(g_scan_reverse_modifier_new()); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Décharge tous les modificateurs inscrits. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void unload_all_scan_token_modifiers(void) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < __modifiers_count; i++) + g_object_unref(G_OBJECT(__modifiers[i].instance)); + + if (__modifiers != NULL) + free(__modifiers); + +} + + +/****************************************************************************** +* * +* Paramètres : name = désignation du modificateur recherché. * +* * +* Description : Fournit le modificateur correspondant à un nom. * +* * +* Retour : Instance du modificateur identifié ou NULL. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GScanTokenModifier *find_scan_token_modifiers_for_name(const char *name) +{ + GScanTokenModifier *result; /* Instance à renvoyer */ + size_t i; /* Boucle de parcours */ + available_modifier_t *registered; /* Infos d'enregistrement */ + + result = NULL; + + for (i = 0; i < __modifiers_count; i++) + { + registered = __modifiers + i; + + if (strcmp(registered->name, name) == 0) + { + result = registered->instance; + g_object_ref(G_OBJECT(result)); + break; + } + + } + + return result; + +} + /****************************************************************************** * * diff --git a/src/analysis/scan/core.h b/src/analysis/scan/core.h index 21d6e7c..86a47da 100644 --- a/src/analysis/scan/core.h +++ b/src/analysis/scan/core.h @@ -26,9 +26,22 @@ #include "space.h" +#include "patterns/modifier.h" +/* Inscrit un modificateur dans la liste des disponibles. */ +bool register_scan_token_modifier(GScanTokenModifier *); + +/* Charge tous les modificateurs de base. */ +bool load_all_known_scan_token_modifiers(void); + +/* Décharge tous les modificateurs inscrits. */ +void unload_all_scan_token_modifiers(void); + +/* Fournit le modificateur correspondant à un nom. */ +GScanTokenModifier *find_scan_token_modifiers_for_name(const char *); + /* Inscrit les principales fonctions dans l'espace racine. */ bool populate_main_scan_namespace(GScanNamespace *); diff --git a/src/analysis/scan/expr-int.h b/src/analysis/scan/expr-int.h index 48668b5..30a32d0 100644 --- a/src/analysis/scan/expr-int.h +++ b/src/analysis/scan/expr-int.h @@ -54,10 +54,10 @@ typedef ScanReductionState (* reduce_expr_fc) (GScanExpression *, GScanContext * typedef bool (* reduce_expr_to_bool_fc) (GScanExpression *, GScanContext *, GScanScope *, GScanExpression **); /* Dénombre les éléments portés par une expression. */ -typedef bool (* count_scan_expr_fc) (const GScanExpression *, size_t *); +typedef bool (* count_scan_expr_fc) (const GScanExpression *, GScanContext *, size_t *); /* Fournit un élément donné issu d'un ensemble constitué. */ -typedef bool (* get_scan_expr_fc) (const GScanExpression *, size_t, GScanExpression **); +typedef bool (* get_scan_expr_fc) (const GScanExpression *, size_t, GScanContext *, GScanExpression **); /* Réalise l'intersection entre deux ensembles. */ typedef GScanExpression * (* intersect_scan_expr_fc) (GScanExpression *, const GScanExpression *, GScanContext *, GScanScope *); diff --git a/src/analysis/scan/expr.c b/src/analysis/scan/expr.c index 808b14f..2b00544 100644 --- a/src/analysis/scan/expr.c +++ b/src/analysis/scan/expr.c @@ -466,6 +466,7 @@ bool g_scan_expression_handle_set_features(const GScanExpression *expr) /****************************************************************************** * * * Paramètres : expr = expression à consulter. * +* ctx = contexte de suivi de l'analyse courante. * * count = quantité d'éléments déterminée. [OUT] * * * * Description : Dénombre les éléments portés par une expression. * @@ -476,7 +477,7 @@ bool g_scan_expression_handle_set_features(const GScanExpression *expr) * * ******************************************************************************/ -bool g_scan_expression_count_items(const GScanExpression *expr, size_t *count) +bool g_scan_expression_count_items(const GScanExpression *expr, GScanContext *ctx, size_t *count) { bool result; /* Bilan à retourner */ GScanExpressionClass *class; /* Classe à activer */ @@ -486,7 +487,7 @@ bool g_scan_expression_count_items(const GScanExpression *expr, size_t *count) class = G_SCAN_EXPRESSION_GET_CLASS(expr); if (class->count != NULL) - result = class->count(expr, count); + result = class->count(expr, ctx, count); else result = false; @@ -504,6 +505,7 @@ bool g_scan_expression_count_items(const GScanExpression *expr, size_t *count) * * * Paramètres : expr = expression à consulter. * * index = indice de l'élément à transférer. * +* ctx = contexte de suivi de l'analyse courante. * * out = zone d'enregistrement de la réduction opérée. [OUT] * * * * Description : Fournit un élément donné issu d'un ensemble constitué. * @@ -514,7 +516,7 @@ bool g_scan_expression_count_items(const GScanExpression *expr, size_t *count) * * ******************************************************************************/ -bool g_scan_expression_get_item(const GScanExpression *expr, size_t index, GScanExpression **out) +bool g_scan_expression_get_item(const GScanExpression *expr, size_t index, GScanContext *ctx, GScanExpression **out) { bool result; /* Bilan à retourner */ GScanExpressionClass *class; /* Classe à activer */ @@ -525,7 +527,7 @@ bool g_scan_expression_get_item(const GScanExpression *expr, size_t index, GScan if (class->get != NULL) { - result = class->get(expr, index, out); + result = class->get(expr, index, ctx, out); if (*out != NULL) g_object_ref(G_OBJECT(*out)); @@ -574,27 +576,27 @@ static GScanExpression *_g_scan_expression_intersect(GScanExpression *expr, cons result = NULL; - valid = g_scan_expression_count_items(other, &other_count); + valid = g_scan_expression_count_items(other, ctx, &other_count); if (!valid) goto done; /* Intersection entre deux ensembles ? */ if (g_scan_expression_handle_set_features(expr)) { - valid = g_scan_expression_count_items(expr, &expr_count); + valid = g_scan_expression_count_items(expr, ctx, &expr_count); if (!valid) goto done; result = g_scan_generic_set_new(); for (k = 0; k < expr_count; k++) { - valid = g_scan_expression_get_item(expr, k, &item); + valid = g_scan_expression_get_item(expr, k, ctx, &item); if (!valid) break; comparable = G_COMPARABLE_ITEM(item); for (i = 0; i < other_count; i++) { - valid = g_scan_expression_get_item(other, i, &item); + valid = g_scan_expression_get_item(other, i, ctx, &item); if (!valid) break; valid = g_comparable_item_compare_rich(comparable, G_COMPARABLE_ITEM(item), RCO_EQ, &status); @@ -619,7 +621,7 @@ static GScanExpression *_g_scan_expression_intersect(GScanExpression *expr, cons for (i = 0; i < other_count && result == NULL; i++) { - valid = g_scan_expression_get_item(other, i, &item); + valid = g_scan_expression_get_item(other, i, ctx, &item); if (!valid) break; valid = g_comparable_item_compare_rich(comparable, G_COMPARABLE_ITEM(item), RCO_EQ, &status); diff --git a/src/analysis/scan/expr.h b/src/analysis/scan/expr.h index dd4bc3f..797abec 100644 --- a/src/analysis/scan/expr.h +++ b/src/analysis/scan/expr.h @@ -50,7 +50,7 @@ typedef struct _GScanExpressionClass GScanExpressionClass; /* Types naturel équivalant à l'expression */ -typedef enum _ExprValueType +typedef enum _ExprValueType /* REMME */ { EVT_BOOLEAN, /* Valeur booléenne */ EVT_INTEGER, /* Nombre entier 64 bits */ @@ -97,10 +97,10 @@ bool g_scan_expression_reduce_to_boolean(GScanExpression *, GScanContext *, GSca bool g_scan_expression_handle_set_features(const GScanExpression *); /* Dénombre les éléments portés par une expression. */ -bool g_scan_expression_count_items(const GScanExpression *, size_t *); +bool g_scan_expression_count_items(const GScanExpression *, GScanContext *, size_t *); /* Fournit un élément donné issu d'un ensemble constitué. */ -bool g_scan_expression_get_item(const GScanExpression *, size_t, GScanExpression **); +bool g_scan_expression_get_item(const GScanExpression *, size_t, GScanContext *, GScanExpression **); /* Réalise l'intersection entre deux ensembles. */ GScanExpression *g_scan_expression_intersect(GScanExpression *, const GScanExpression *, GScanContext *, GScanScope *); diff --git a/src/analysis/scan/exprs/Makefile.am b/src/analysis/scan/exprs/Makefile.am index 1266a63..d1a122a 100644 --- a/src/analysis/scan/exprs/Makefile.am +++ b/src/analysis/scan/exprs/Makefile.am @@ -11,8 +11,12 @@ libanalysisscanexprs_la_SOURCES = \ call.h call.c \ counter-int.h \ counter.h counter.c \ + handler-int.h \ + handler.h handler.c \ intersect-int.h \ intersect.h intersect.c \ + item-int.h \ + item.h item.c \ literal-int.h \ literal.h literal.c \ logical-int.h \ diff --git a/src/analysis/scan/exprs/counter.c b/src/analysis/scan/exprs/counter.c index 290fd02..bb4e523 100644 --- a/src/analysis/scan/exprs/counter.c +++ b/src/analysis/scan/exprs/counter.c @@ -50,7 +50,7 @@ static void g_scan_match_counter_finalize(GScanMatchCounter *); /* Réduit une expression à une forme plus simple. */ -static bool g_scan_match_counter_reduce(GScanMatchCounter *, GScanContext *, GScanScope *, GScanExpression **); +static ScanReductionState g_scan_match_counter_reduce(GScanMatchCounter *, GScanContext *, GScanScope *, GScanExpression **); @@ -226,22 +226,22 @@ bool g_scan_match_counter_create(GScanMatchCounter *counter, GSearchPattern *pat * * ******************************************************************************/ -static bool g_scan_match_counter_reduce(GScanMatchCounter *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out) +static ScanReductionState g_scan_match_counter_reduce(GScanMatchCounter *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out) { - bool result; /* Bilan à retourner */ + ScanReductionState result; /* Etat synthétisé à retourner */ size_t count; /* Quantité de correspondances */ - const GScanMatch **matches; /* Correspondances établies */ - - - matches = g_scan_context_get_full_matches(ctx, expr->pattern, &count); + if (g_scan_context_is_scan_done(ctx)) + { + g_scan_context_get_full_matches(ctx, expr->pattern, &count); - printf("matches: %zu\n", count); + *out = g_scan_literal_expression_new(LVT_UNSIGNED_INTEGER, (unsigned long long []){ count }); + result = SRS_REDUCED; - *out = g_scan_literal_expression_new(LVT_UNSIGNED_INTEGER, (unsigned long long []){ count }); - result = true; - + } + else + result = SRS_WAIT_FOR_SCAN; return result; diff --git a/src/analysis/scan/exprs/handler-int.h b/src/analysis/scan/exprs/handler-int.h new file mode 100644 index 0000000..f707fdb --- /dev/null +++ b/src/analysis/scan/exprs/handler-int.h @@ -0,0 +1,58 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * handler-int.h - prototypes internes pour la manipulation des correspondances établies lors d'un scan + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_EXPRS_HANDLER_INT_H +#define _ANALYSIS_SCAN_EXPRS_HANDLER_INT_H + + +#include "handler.h" + + +#include "../expr-int.h" + + + +/* Manipulation des correspondances établies lors d'un scan de binaire (instance) */ +struct _GScanPatternHandler +{ + GScanExpression parent; /* A laisser en premier */ + + GSearchPattern *pattern; /* Motif associé */ + ScanHandlerType type; /* Manipulation attendue */ + +}; + +/* Manipulation des correspondances établies lors d'un scan de binaire (classe) */ +struct _GScanPatternHandlerClass +{ + GScanExpressionClass parent; /* A laisser en premier */ + +}; + + +/* Met en place une manipulation de correspondances établies. */ +bool g_scan_pattern_handler_create(GScanPatternHandler *, GSearchPattern *, ScanHandlerType); + + + +#endif /* _ANALYSIS_SCAN_EXPRS_HANDLER_INT_H */ diff --git a/src/analysis/scan/exprs/handler.c b/src/analysis/scan/exprs/handler.c new file mode 100644 index 0000000..a14140a --- /dev/null +++ b/src/analysis/scan/exprs/handler.c @@ -0,0 +1,402 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * handler.c - manipulation des correspondances établies lors d'un scan + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "handler.h" + + +#include <assert.h> + + +#include "literal.h" +#include "handler-int.h" +#include "../matches/bytes.h" + + + +/* --------------------- INTRODUCTION D'UNE NOUVELLE EXPRESSION --------------------- */ + + +/* Initialise la classe des manipulations de correspondances. */ +static void g_scan_pattern_handler_class_init(GScanPatternHandlerClass *); + +/* Initialise une instance de manipulation de correspondances. */ +static void g_scan_pattern_handler_init(GScanPatternHandler *); + +/* Supprime toutes les références externes. */ +static void g_scan_pattern_handler_dispose(GScanPatternHandler *); + +/* Procède à la libération totale de la mémoire. */ +static void g_scan_pattern_handler_finalize(GScanPatternHandler *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Réduit une expression à une forme plus simple. */ +static ScanReductionState g_scan_pattern_handler_reduce(GScanPatternHandler *, GScanContext *, GScanScope *, GScanExpression **); + +/* Réduit une expression à une forme booléenne. */ +static bool g_scan_pattern_handler_reduce_to_boolean(GScanPatternHandler *, GScanContext *, GScanScope *, GScanExpression **); + +/* Dénombre les éléments portés par une expression. */ +static bool g_scan_pattern_handler_count_items(const GScanPatternHandler *, GScanContext *, size_t *); + +/* Fournit un élément donné issu d'un ensemble constitué. */ +static bool g_scan_pattern_handler_get_item(const GScanPatternHandler *, size_t, GScanContext *, GScanExpression **); + + + +/* ---------------------------------------------------------------------------------- */ +/* INTRODUCTION D'UNE NOUVELLE EXPRESSION */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour une manipulation de correspondances établies lors d'un scan. */ +G_DEFINE_TYPE(GScanPatternHandler, g_scan_pattern_handler, G_TYPE_SCAN_EXPRESSION); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des manipulations de correspondances. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_pattern_handler_class_init(GScanPatternHandlerClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GScanExpressionClass *expr; /* Version de classe parente */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_pattern_handler_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_pattern_handler_finalize; + + expr = G_SCAN_EXPRESSION_CLASS(klass); + + expr->reduce = (reduce_expr_fc)g_scan_pattern_handler_reduce; + expr->reduce_to_bool = (reduce_expr_to_bool_fc)g_scan_pattern_handler_reduce_to_boolean; + expr->count = (count_scan_expr_fc)g_scan_pattern_handler_count_items; + expr->get = (get_scan_expr_fc)g_scan_pattern_handler_get_item; + +} + + +/****************************************************************************** +* * +* Paramètres : handler = instance à initialiser. * +* * +* Description : Initialise une instance de manipulation de correspondances. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_pattern_handler_init(GScanPatternHandler *handler) +{ + handler->pattern = NULL; + handler->type = SHT_RAW; + +} + + +/****************************************************************************** +* * +* Paramètres : handler = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_pattern_handler_dispose(GScanPatternHandler *handler) +{ + g_clear_object(&handler->pattern); + + G_OBJECT_CLASS(g_scan_pattern_handler_parent_class)->dispose(G_OBJECT(handler)); + +} + + +/****************************************************************************** +* * +* Paramètres : handler = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_pattern_handler_finalize(GScanPatternHandler *handler) +{ + G_OBJECT_CLASS(g_scan_pattern_handler_parent_class)->finalize(G_OBJECT(handler)); + +} + + +/****************************************************************************** +* * +* Paramètres : pattern = motif à impliquer. * +* type = type de manipulation attendue. * +* * +* Description : Met en place une manipulation de correspondances établies. * +* * +* Retour : Expression mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GScanExpression *g_scan_pattern_handler_new(GSearchPattern *pattern, ScanHandlerType type) +{ + GScanExpression *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_SCAN_PATTERN_HANDLER, NULL); + + if (!g_scan_pattern_handler_create(G_SCAN_PATTERN_HANDLER(result), pattern, type)) + g_clear_object(&result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : handler = instance à initialiser pleinement. * +* pattern = motif à impliquer. * +* type = type de manipulation attendue. * +* * +* Description : Met en place une manipulation de correspondances établies. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_scan_pattern_handler_create(GScanPatternHandler *handler, GSearchPattern *pattern, ScanHandlerType type) +{ + bool result; /* Bilan à retourner */ + + result = true; + + handler->pattern = pattern; + g_object_ref(G_OBJECT(pattern)); + + handler->type = type; + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : expr = expression à consulter. * +* ctx = contexte de suivi de l'analyse courante. * +* scope = portée courante des variables locales. * +* out = zone d'enregistrement de la réduction opérée. [OUT] * +* * +* Description : Réduit une expression à une forme plus simple. * +* * +* Retour : Bilan de l'opération : false en cas d'erreur irrécupérable. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static ScanReductionState g_scan_pattern_handler_reduce(GScanPatternHandler *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out) +{ + ScanReductionState result; /* Etat synthétisé à retourner */ + + if (g_scan_context_is_scan_done(ctx)) + result = SRS_REDUCED; + + else + result = SRS_WAIT_FOR_SCAN; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : expr = expression à consulter. * +* ctx = contexte de suivi de l'analyse courante. * +* scope = portée courante des variables locales. * +* out = zone d'enregistrement de la réduction opérée. [OUT] * +* * +* Description : Réduit une expression à une forme booléenne. * +* * +* Retour : Bilan de l'opération : false en cas d'erreur irrécupérable. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_scan_pattern_handler_reduce_to_boolean(GScanPatternHandler *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out) +{ + bool result; /* Bilan à retourner */ + size_t count; /* Quantité de correspondances */ + + result = true; + + g_scan_context_get_full_matches(ctx, expr->pattern, &count); + + *out = g_scan_literal_expression_new(LVT_BOOLEAN, (bool []){ count > 0 }); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : expr = expression à consulter. * +* ctx = contexte de suivi de l'analyse courante. * +* count = quantité d'éléments déterminée. [OUT] * +* * +* Description : Dénombre les éléments portés par une expression. * +* * +* Retour : Bilan de l'opération : false en cas d'erreur irrécupérable. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_scan_pattern_handler_count_items(const GScanPatternHandler *expr, GScanContext *ctx, size_t *count) +{ + bool result; /* Bilan à retourner */ + + result = true; + + assert(g_scan_context_is_scan_done(ctx)); + + g_scan_context_get_full_matches(ctx, expr->pattern, count); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : expr = expression à consulter. * +* index = indice de l'élément à transférer. * +* ctx = contexte de suivi de l'analyse courante. * +* out = zone d'enregistrement de la réduction opérée. [OUT] * +* * +* Description : Fournit un élément donné issu d'un ensemble constitué. * +* * +* Retour : Bilan de l'opération : false en cas d'erreur irrécupérable. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_scan_pattern_handler_get_item(const GScanPatternHandler *expr, size_t index, GScanContext *ctx, GScanExpression **out) +{ + bool result; /* Bilan à retourner */ + size_t count; /* Quantité de correspondances */ + const GScanMatch **matches; /* Correspondances en place */ + const GScanBytesMatch *match; /* Correspondance ciblée */ + phys_t start; /* Point de départ du motif */ + phys_t end; /* Point d'arrivée du motif */ + phys_t len; /* Taille du motif */ + GBinContent *content; /* Contenu binaire à relire */ + vmpa2t pos; /* Tête de lecture */ + const bin_t *data; /* Accès aux données brutes */ + sized_string_t binary; /* Conversion de formats */ + + assert(g_scan_context_is_scan_done(ctx)); + + matches = g_scan_context_get_full_matches(ctx, expr->pattern, &count); + + result = (index < count); + if (!result) goto done; + + result = G_IS_SCAN_BYTES_MATCH(matches[index]); + if (!result) goto done; + + match = G_SCAN_BYTES_MATCH(matches[index]); + + len = g_scan_bytes_match_get_location(match, &start, &end); + + switch (expr->type) + { + case SHT_RAW: + content = g_scan_bytes_match_get_content(match); + + init_vmpa(&pos, start, VMPA_NO_VIRTUAL); + + data = g_binary_content_get_raw_access(content, &pos, len); + + binary.data = data; + binary.len = len; + + *out = g_scan_literal_expression_new(LVT_STRING, &binary); + + g_object_unref(G_OBJECT(content)); + break; + + case SHT_START: + *out = g_scan_literal_expression_new(LVT_UNSIGNED_INTEGER, (unsigned long long []){ start }); + break; + + case SHT_LENGTH: + *out = g_scan_literal_expression_new(LVT_UNSIGNED_INTEGER, (unsigned long long []){ len }); + break; + + case SHT_END: + *out = g_scan_literal_expression_new(LVT_UNSIGNED_INTEGER, (unsigned long long []){ end }); + break; + + } + + done: + + return result; + +} diff --git a/src/analysis/scan/exprs/handler.h b/src/analysis/scan/exprs/handler.h new file mode 100644 index 0000000..8ad700a --- /dev/null +++ b/src/analysis/scan/exprs/handler.h @@ -0,0 +1,66 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * handler.h - prototypes pour la manipulation des correspondances établies lors d'un scan + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_EXPRS_HANDLER_H +#define _ANALYSIS_SCAN_EXPRS_HANDLER_H + + +#include "../expr.h" + + + +#define G_TYPE_SCAN_PATTERN_HANDLER g_scan_pattern_handler_get_type() +#define G_SCAN_PATTERN_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_PATTERN_HANDLER, GScanPatternHandler)) +#define G_IS_SCAN_PATTERN_HANDLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_PATTERN_HANDLER)) +#define G_SCAN_PATTERN_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_PATTERN_HANDLER, GScanPatternHandlerClass)) +#define G_IS_SCAN_PATTERN_HANDLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_PATTERN_HANDLER)) +#define G_SCAN_PATTERN_HANDLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_PATTERN_HANDLER, GScanPatternHandlerClass)) + + +/* Manipulation des correspondances établies lors d'un scan de binaire (instance) */ +typedef struct _GScanPatternHandler GScanPatternHandler; + +/* Manipulation des correspondances établies lors d'un scan de binaire (classe) */ +typedef struct _GScanPatternHandlerClass GScanPatternHandlerClass; + + +/* Type de manipulation représentée */ +typedef enum _ScanHandlerType +{ + SHT_RAW, /* Correspondances brutes */ + SHT_START, /* Départs de correspondances */ + SHT_LENGTH, /* Taille de correspondances */ + SHT_END, /* Fins de correspondances */ + +} ScanHandlerType; + + +/* Indique le type défini pour une manipulation de correspondances établies lors d'un scan. */ +GType g_scan_pattern_handler_get_type(void); + +/* Met en place une manipulation de correspondances établies. */ +GScanExpression *g_scan_pattern_handler_new(GSearchPattern *, ScanHandlerType); + + + +#endif /* _ANALYSIS_SCAN_EXPRS_HANDLER_H */ diff --git a/src/analysis/scan/exprs/item-int.h b/src/analysis/scan/exprs/item-int.h new file mode 100644 index 0000000..56b159a --- /dev/null +++ b/src/analysis/scan/exprs/item-int.h @@ -0,0 +1,58 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * item-int.h - prototypes internes pour la récupération d'un élément à partir d'une série + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_EXPRS_ITEM_INT_H +#define _ANALYSIS_SCAN_EXPRS_ITEM_INT_H + + +#include "item.h" + + +#include "../expr-int.h" + + + +/* Accès à un élément donné d'une série établie (instance) */ +struct _GScanSetItem +{ + GScanExpression parent; /* A laisser en premier */ + + GScanExpression *set; /* Série d'éléments à consulter*/ + GScanExpression *index; /* Indice de l'élément visé */ + +}; + +/* Accès à un élément donné d'une série établie (classe) */ +struct _GScanSetItemClass +{ + GScanExpressionClass parent; /* A laisser en premier */ + +}; + + +/* Met en place un accès à un élément donné d'une série. */ +bool g_scan_set_item_create(GScanSetItem *, GScanExpression *, GScanExpression *); + + + +#endif /* _ANALYSIS_SCAN_EXPRS_ITEM_INT_H */ diff --git a/src/analysis/scan/exprs/item.c b/src/analysis/scan/exprs/item.c new file mode 100644 index 0000000..a6b22f0 --- /dev/null +++ b/src/analysis/scan/exprs/item.c @@ -0,0 +1,346 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * item.c - récupération d'un élément à partir d'une série + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "set.h" + + +#include <assert.h> + + +#include "literal.h" +#include "item-int.h" + + + +/* --------------------- INTRODUCTION D'UNE NOUVELLE EXPRESSION --------------------- */ + + +/* Initialise la classe des accès à un élément de série. */ +static void g_scan_set_item_class_init(GScanSetItemClass *); + +/* Initialise une instance d'accès à un élément de série. */ +static void g_scan_set_item_init(GScanSetItem *); + +/* Supprime toutes les références externes. */ +static void g_scan_set_item_dispose(GScanSetItem *); + +/* Procède à la libération totale de la mémoire. */ +static void g_scan_set_item_finalize(GScanSetItem *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Réduit une expression à une forme plus simple. */ +static ScanReductionState g_scan_set_item_reduce(GScanSetItem *, GScanContext *, GScanScope *, GScanExpression **); + + + +/* ---------------------------------------------------------------------------------- */ +/* INTRODUCTION D'UNE NOUVELLE EXPRESSION */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour la récupération d'un élément à partir d'une série. */ +G_DEFINE_TYPE(GScanSetItem, g_scan_set_item, G_TYPE_SCAN_EXPRESSION); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des accès à un élément de série. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_set_item_class_init(GScanSetItemClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GScanExpressionClass *expr; /* Version de classe parente */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_set_item_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_set_item_finalize; + + expr = G_SCAN_EXPRESSION_CLASS(klass); + + expr->reduce = (reduce_expr_fc)g_scan_set_item_reduce; + +} + + +/****************************************************************************** +* * +* Paramètres : item = instance à initialiser. * +* * +* Description : Initialise une instance d'accès à un élément de série. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_set_item_init(GScanSetItem *item) +{ + item->set = NULL; + item->index = NULL; + +} + + +/****************************************************************************** +* * +* Paramètres : item = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_set_item_dispose(GScanSetItem *item) +{ + g_clear_object(&item->set); + g_clear_object(&item->index); + + G_OBJECT_CLASS(g_scan_set_item_parent_class)->dispose(G_OBJECT(item)); + +} + + +/****************************************************************************** +* * +* Paramètres : item = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_set_item_finalize(GScanSetItem *item) +{ + G_OBJECT_CLASS(g_scan_set_item_parent_class)->finalize(G_OBJECT(item)); + +} + + +/****************************************************************************** +* * +* Paramètres : set = ensemble d'éléments à considérer. * +* index = indice de l'élément à viser. * +* * +* Description : Met en place un accès à un élément donné d'une série. * +* * +* Retour : Expression mise en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GScanExpression *g_scan_set_item_new(GScanExpression *set, GScanExpression *index) +{ + GScanExpression *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_SCAN_SET_ITEM, NULL); + + if (!g_scan_set_item_create(G_SCAN_SET_ITEM(result), set, index)) + g_clear_object(&result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : item = instance à initialiser pleinement. * +* set = ensemble d'éléments à considérer. * +* index = indice de l'élément à viser. * +* * +* Description : Met en place un accès à un élément donné d'une série. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_scan_set_item_create(GScanSetItem *item, GScanExpression *set, GScanExpression *index) +{ + bool result; /* Bilan à retourner */ + + result = true; + + item->set = set; + g_object_ref(G_OBJECT(set)); + + item->index = index; + g_object_ref(G_OBJECT(index)); + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : expr = expression à consulter. * +* ctx = contexte de suivi de l'analyse courante. * +* scope = portée courante des variables locales. * +* out = zone d'enregistrement de la réduction opérée. [OUT] * +* * +* Description : Réduit une expression à une forme plus simple. * +* * +* Retour : Bilan de l'opération : false en cas d'erreur irrécupérable. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static ScanReductionState g_scan_set_item_reduce(GScanSetItem *expr, GScanContext *ctx, GScanScope *scope, GScanExpression **out) +{ + ScanReductionState result; /* Etat synthétisé à retourner */ + GScanExpression *new_set; /* Expression réduite (série) */ + GScanExpression *new_index; /* Expression réduite (indice) */ + ScanReductionState state_set; /* Etat synthétisé #1 */ + ScanReductionState state_index; /* Etat synthétisé #2 */ + GScanLiteralExpression *op_index; /* Indice d'accès final */ + LiteralValueType vtype; /* Type de valeur portée */ + long long val_s; /* Valeur de l'indice (signée) */ + unsigned long long val_u; /* Valeur de l'indice (!signée)*/ + bool status; /* Statut final de récupération*/ + + /* Réduction des éléments considérés */ + + new_set = NULL; + new_index = NULL; + + state_set = g_scan_expression_reduce(expr->set, ctx, scope, &new_set); + if (state_set == SRS_UNRESOLVABLE) + { + result = SRS_UNRESOLVABLE; + goto exit; + } + + state_index = g_scan_expression_reduce(expr->index, ctx, scope, &new_index); + if (state_index == SRS_UNRESOLVABLE) + { + result = SRS_UNRESOLVABLE; + goto exit; + } + + /* Validation de la nature des éléments en jeu */ + + if (state_set == SRS_REDUCED && !g_scan_expression_handle_set_features(new_set)) + { + result = SRS_UNRESOLVABLE; + goto exit; + } + + if (state_index == SRS_REDUCED && !G_IS_SCAN_LITERAL_EXPRESSION(new_index)) + { + result = SRS_UNRESOLVABLE; + goto exit; + } + + /* Tentative d'accès à un élément de série */ + + if (state_set == SRS_REDUCED && state_index == SRS_REDUCED) + { + op_index = G_SCAN_LITERAL_EXPRESSION(new_index); + vtype = g_scan_literal_expression_get_value_type(op_index); + + if (vtype == LVT_SIGNED_INTEGER) + { + if (!g_scan_literal_expression_get_signed_integer_value(op_index, &val_s)) + { + result = SRS_UNRESOLVABLE; + goto exit; + } + + if (val_s < 0) + { + result = SRS_UNRESOLVABLE; + goto exit; + } + + status = g_scan_expression_get_item(expr->set, val_s, ctx, out); + + } + else if (vtype == LVT_UNSIGNED_INTEGER) + { + if (!g_scan_literal_expression_get_unsigned_integer_value(op_index, &val_u)) + { + result = SRS_UNRESOLVABLE; + goto exit; + } + + status = g_scan_expression_get_item(expr->set, val_u, ctx, out); + + } + + result = (status ? SRS_REDUCED : SRS_UNRESOLVABLE); + + } + + /* Mise à jour de la progression ? */ + + else + { + assert(state_set == SRS_WAIT_FOR_SCAN || state_index == SRS_WAIT_FOR_SCAN); + + if (new_set != expr->set || new_index != expr->index) + *out = g_scan_set_item_new(new_set, new_index); + + result = SRS_WAIT_FOR_SCAN; + + } + + /* Sortie propre */ + + exit: + + g_clear_object(&new_set); + g_clear_object(&new_index); + + return result; + +} diff --git a/src/analysis/scan/exprs/item.h b/src/analysis/scan/exprs/item.h new file mode 100644 index 0000000..9d3cdfb --- /dev/null +++ b/src/analysis/scan/exprs/item.h @@ -0,0 +1,55 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * item.h - prototypes pour la récupération d'un élément à partir d'une série + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_EXPRS_ITEM_H +#define _ANALYSIS_SCAN_EXPRS_ITEM_H + + +#include "../expr.h" + + + +#define G_TYPE_SCAN_SET_ITEM g_scan_set_item_get_type() +#define G_SCAN_SET_ITEM(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_SET_ITEM, GScanSetItem)) +#define G_IS_SCAN_SET_ITEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_SET_ITEM)) +#define G_SCAN_SET_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_SET_ITEM, GScanSetItemClass)) +#define G_IS_SCAN_SET_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_SET_ITEM)) +#define G_SCAN_SET_ITEM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_SET_ITEM, GScanSetItemClass)) + + +/* Accès à un élément donné d'une série établie (instance) */ +typedef struct _GScanSetItem GScanSetItem; + +/* Accès à un élément donné d'une série établie (classe) */ +typedef struct _GScanSetItemClass GScanSetItemClass; + + +/* Indique le type défini pour la récupération d'un élément à partir d'une série. */ +GType g_scan_set_item_get_type(void); + +/* Met en place un accès à un élément donné d'une série. */ +GScanExpression *g_scan_set_item_new(GScanExpression *, GScanExpression *); + + + +#endif /* _ANALYSIS_SCAN_EXPRS_ITEM_H */ diff --git a/src/analysis/scan/exprs/literal.c b/src/analysis/scan/exprs/literal.c index e468382..070c177 100644 --- a/src/analysis/scan/exprs/literal.c +++ b/src/analysis/scan/exprs/literal.c @@ -60,7 +60,7 @@ static bool g_scan_literal_expression_compare_rich(const GScanLiteralExpression static bool g_scan_literal_expression_reduce_to_boolean(GScanLiteralExpression *, GScanContext *, GScanScope *, GScanExpression **); /* Dénombre les éléments portés par une expression. */ -static bool g_scan_literal_expression_count(const GScanLiteralExpression *, size_t *); +static bool g_scan_literal_expression_count(const GScanLiteralExpression *, GScanContext *, size_t *); @@ -623,6 +623,7 @@ static bool g_scan_literal_expression_reduce_to_boolean(GScanLiteralExpression * /****************************************************************************** * * * Paramètres : expr = expression à consulter. * +* ctx = contexte de suivi de l'analyse courante. * * count = quantité d'éléments déterminée. [OUT] * * * * Description : Dénombre les éléments portés par une expression. * @@ -633,7 +634,7 @@ static bool g_scan_literal_expression_reduce_to_boolean(GScanLiteralExpression * * * ******************************************************************************/ -static bool g_scan_literal_expression_count(const GScanLiteralExpression *expr, size_t *count) +static bool g_scan_literal_expression_count(const GScanLiteralExpression *expr, GScanContext *ctx, size_t *count) { bool result; /* Bilan à retourner */ diff --git a/src/analysis/scan/exprs/set.c b/src/analysis/scan/exprs/set.c index 0a93ced..d76af4d 100644 --- a/src/analysis/scan/exprs/set.c +++ b/src/analysis/scan/exprs/set.c @@ -60,10 +60,10 @@ static ScanReductionState g_scan_generic_set_reduce(GScanGenericSet *, GScanCont static bool g_scan_generic_set_reduce_to_boolean(GScanGenericSet *, GScanContext *, GScanScope *, GScanExpression **); /* Dénombre les éléments portés par une expression. */ -static bool g_scan_generic_set_count_items(const GScanGenericSet *, size_t *); +static bool g_scan_generic_set_count_items(const GScanGenericSet *, GScanContext *, size_t *); /* Fournit un élément donné issu d'un ensemble constitué. */ -static bool g_scan_generic_set_get_item(const GScanGenericSet *, size_t, GScanExpression **); +static bool g_scan_generic_set_get_item(const GScanGenericSet *, size_t, GScanContext *, GScanExpression **); @@ -328,6 +328,7 @@ static bool g_scan_generic_set_reduce_to_boolean(GScanGenericSet *expr, GScanCon /****************************************************************************** * * * Paramètres : expr = expression à consulter. * +* ctx = contexte de suivi de l'analyse courante. * * count = quantité d'éléments déterminée. [OUT] * * * * Description : Dénombre les éléments portés par une expression. * @@ -338,7 +339,7 @@ static bool g_scan_generic_set_reduce_to_boolean(GScanGenericSet *expr, GScanCon * * ******************************************************************************/ -static bool g_scan_generic_set_count_items(const GScanGenericSet *expr, size_t *count) +static bool g_scan_generic_set_count_items(const GScanGenericSet *expr, GScanContext *ctx, size_t *count) { bool result; /* Bilan à retourner */ @@ -355,6 +356,7 @@ static bool g_scan_generic_set_count_items(const GScanGenericSet *expr, size_t * * * * Paramètres : expr = expression à consulter. * * index = indice de l'élément à transférer. * +* ctx = contexte de suivi de l'analyse courante. * * out = zone d'enregistrement de la réduction opérée. [OUT] * * * * Description : Fournit un élément donné issu d'un ensemble constitué. * @@ -365,7 +367,7 @@ static bool g_scan_generic_set_count_items(const GScanGenericSet *expr, size_t * * * ******************************************************************************/ -static bool g_scan_generic_set_get_item(const GScanGenericSet *expr, size_t index, GScanExpression **out) +static bool g_scan_generic_set_get_item(const GScanGenericSet *expr, size_t index, GScanContext *ctx, GScanExpression **out) { bool result; /* Bilan à retourner */ diff --git a/src/analysis/scan/grammar.y b/src/analysis/scan/grammar.y index 10e1d42..c0aa52d 100644 --- a/src/analysis/scan/grammar.y +++ b/src/analysis/scan/grammar.y @@ -6,7 +6,7 @@ /* Affiche un message d'erreur suite à l'analyse en échec. */ -static int yyerror(GContentScanner *, yyscan_t, GScanRule **, void/*GBytesPattern*/ **, char **, size_t *, size_t *, char *); +static int yyerror(GContentScanner *, yyscan_t, GScanRule **, sized_string_t *, sized_string_t *, void/*GBytesPattern*/ **, char **, size_t *, size_t *, char *); %} @@ -16,34 +16,26 @@ static int yyerror(GContentScanner *, yyscan_t, GScanRule **, void/*GBytesPatter #define YY_TYPEDEF_YY_SCANNER_T typedef void *yyscan_t; +#include "core.h" #include "scanner.h" #include "exprs/access.h" #include "exprs/arithmetic.h" #include "exprs/call.h" #include "exprs/counter.h" +#include "exprs/handler.h" #include "exprs/intersect.h" +#include "exprs/item.h" #include "exprs/literal.h" #include "exprs/logical.h" #include "exprs/set.h" #include "exprs/relational.h" #include "exprs/strop.h" +#include "patterns/modifier.h" +#include "patterns/modifiers/list.h" +#include "patterns/tokens/hex.h" #include "patterns/tokens/plain.h" - - -#if 0 /////////////////////////////////////////////////////////////////////////:: -#define handle_coder_conversions(c, r) \ - ({ \ - encoding_spec *__spec; \ - encoding_syntax *__syntax; \ - conv_list *__list; \ - bool __status; \ - __spec = get_current_encoding_spec(c); \ - __syntax = get_current_encoding_syntax(__spec); \ - __list = get_conversions_in_encoding_syntax(__syntax); \ - __status = load_convs_from_raw_block(__list, r); \ - if (!__status) YYABORT; \ - }) -#endif /////////////////////////////////////////////////////////////////////////// +#include "patterns/tokens/nodes/plain.h" +#include "../../core/logs.h" } @@ -58,9 +50,25 @@ typedef void *yyscan_t; + sized_string_t *tmp_cstring; /* Série d'octets reconstituée */ + + struct { + bin_t byte; /* Valeur partielle recherchée */ + uint8_t mask; /* Masque associé */ + } semi_mask; + + GScanRule *rule; /* Nouvelle règle à intégrer */ - void/*GBytesPattern*/ *pattern; /* Nouveau motif à considérer */ + + + + GScanTokenNode *node; /* Bribe de motif à intégrer */ + GSearchPattern *pattern; /* Nouveau motif à considérer */ + + GScanTokenModifier *modifier; + + GScanExpression *expr; /* Expression de condition */ struct { @@ -78,13 +86,13 @@ typedef void *yyscan_t; %define api.pure full -%parse-param { GContentScanner *scanner } { yyscan_t yyscanner } { GScanRule **built_rule } { void /*GBytesPattern*/ **built_pattern } { char **buf } { size_t *allocated } { size_t *used } -%lex-param { yyscan_t yyscanner } { void/*GBytesPattern*/ **built_pattern } { char **buf } { size_t *allocated } { size_t *used } +%parse-param { GContentScanner *scanner } { yyscan_t yyscanner } { GScanRule **built_rule } { sized_string_t *tmp_0} { sized_string_t *tmp_1} { void /*GBytesPattern*/ **built_pattern } { char **buf } { size_t *allocated } { size_t *used } +%lex-param { yyscan_t yyscanner } { sized_string_t *tmp_0} { sized_string_t *tmp_1} { void/*GBytesPattern*/ **built_pattern } { char **buf } { size_t *allocated } { size_t *used } %code provides { #define YY_DECL \ - int rost_lex(YYSTYPE *yylval_param, yyscan_t yyscanner, void/*GBytesPattern*/ **built_pattern, char **buf, size_t *allocated, size_t *used) + int rost_lex(YYSTYPE *yylval_param, yyscan_t yyscanner, sized_string_t *tmp_0, sized_string_t *tmp_1, void/*GBytesPattern*/ **built_pattern, char **buf, size_t *allocated, size_t *used) YY_DECL; @@ -97,13 +105,26 @@ YY_DECL; %token RULE_NAME %token STRINGS CONDITION -%token IDENTIFIER + %token BYTES_ID %token BYTES_ID_COUNTER -%token BYTES_ID_LOCATION +%token BYTES_ID_START %token BYTES_ID_LENGTH +%token BYTES_ID_END %token NAME + +%token HEX_BYTES +%token FULL_MASK +%token SEMI_MASK + + +%token REGEX_BYTES +%token REGEX_CLASSES +%token REGEX_RANGE + + + %token BRACE_IN BRACE_OUT ASSIGN COLON @@ -143,11 +164,20 @@ YY_DECL; %token MUL "*" %token DIV "/" %token MOD "%" +%token TILDE "~" + +%token HOOK_O "[" +%token HOOK_C "]" + +%token BRACKET_O "{" +%token BRACKET_C "}" +%token QUESTION "?" %token PAREN_O "(" %token PAREN_C ")" %token COMMA "," %token DOT "." +%token PIPE "|" %token NONE "none" %token ANY "any" @@ -160,7 +190,11 @@ YY_DECL; %type <sized_cstring> RULE_NAME -%type <sized_cstring> IDENTIFIER BYTES_ID_COUNTER +%type <sized_cstring> BYTES_ID +%type <sized_cstring> BYTES_ID_COUNTER +%type <sized_cstring> BYTES_ID_START +%type <sized_cstring> BYTES_ID_LENGTH +%type <sized_cstring> BYTES_ID_END %type <sized_cstring> NAME @@ -173,8 +207,27 @@ YY_DECL; %type <sized_cstring> PLAIN_STRING %type <pattern> MASKED_STRING +%type <tmp_cstring> HEX_BYTES +%type <unsigned_integer> FULL_MASK +%type <semi_mask> SEMI_MASK + +%type <tmp_cstring> REGEX_BYTES + + +%type <modifier> modifiers +%type <modifier> _modifiers +%type <modifier> chained_modifiers +%type <modifier> mod_stage +%type <modifier> modifier + +%type <pattern> hex_pattern +%type <node> hex_tokens +%type <node> hex_token + + + %type <expr> cexpression _cexpression -%type <expr> pattern_match + %type <expr> literal %type <expr> item_chain %type <args_list> call_args @@ -185,7 +238,16 @@ YY_DECL; %type <expr> set_counter %type <expr> set %type <expr> set_items +%type <expr> set_access %type <expr> intersection +%type <expr> pattern_handler + + + + + +%left PIPE + %left OR @@ -200,6 +262,11 @@ YY_DECL; +%left HOOK_O HOOK_C + + + + %destructor { printf("-------- Discarding symbol %p.\n", $$); } <rule> @@ -257,14 +324,28 @@ strings : /* empty */ ; -string_decls : string_decl - | string_decls string_decl - ; + string_decls : string_decl + | hex_pattern + { + if ($1 == NULL) YYERROR; + g_scan_rule_add_local_variable(*built_rule, $1); + g_object_unref(G_OBJECT($1)); + } + | regex_pattern + | string_decls string_decl + | string_decls hex_pattern + { + if ($2 == NULL) YYERROR; + g_scan_rule_add_local_variable(*built_rule, $2); + g_object_unref(G_OBJECT($2)); + } + | string_decls regex_pattern + ; -string_decl : IDENTIFIER ASSIGN PLAIN_STRING +string_decl : BYTES_ID ASSIGN PLAIN_STRING modifiers { GSearchPattern *__pat; - __pat = g_plain_bytes_new((uint8_t *)$3.data, $3.len); + __pat = g_scan_plain_bytes_new(&$3, NULL, SPBF_NONE); g_search_pattern_set_name(__pat, $1.data, $1.len); g_scan_rule_add_local_variable(*built_rule, __pat); g_object_unref(G_OBJECT(__pat)); @@ -281,7 +362,7 @@ string_decl : IDENTIFIER ASSIGN PLAIN_STRING g_object_unref(G_OBJECT(__pat)); */ } - | IDENTIFIER ASSIGN MASKED_STRING + | BYTES_ID ASSIGN MASKED_STRING { printf("built %p\n", $3); /* @@ -301,6 +382,267 @@ string_decl : IDENTIFIER ASSIGN PLAIN_STRING } ; + +/** + * Prise en charge des modificateurs. + */ + + modifiers : /* empty */ + { + $$ = NULL; + } + | _modifiers + { + + // if (...) useless + + } + ; + + _modifiers : mod_stage + { + $$ = $1; + } + | chained_modifiers + { + $$ = $1; + } + ; + + chained_modifiers : _modifiers "|" _modifiers + ; + + mod_stage : modifier + { + $$ = $1; + } + | mod_stage modifier + { + bool status; + + if (G_IS_SCAN_MODIFIER_LIST($1)) + $$ = $1; + else + { + $$ = g_scan_modifier_list_new(); + g_scan_modifier_list_add(G_SCAN_MODIFIER_LIST($$), $1); + } + + status = g_scan_modifier_list_add(G_SCAN_MODIFIER_LIST($$), $2); + if (!status) + { + if (1) + log_simple_message(LMT_WARNING, "modifier already taken into account!"); + g_object_unref(G_OBJECT($2)); + } + + } + ; + + modifier : NAME + { + $$ = find_scan_token_modifiers_for_name($1.data); + if ($$ == NULL) YYERROR; + } + | "(" chained_modifiers ")" + { + $$ = $2; + } + ; + +/** + * Définition de motif en hexadécimal. + */ + + hex_pattern : BYTES_ID ASSIGN hex_tokens + { + $$ = g_scan_hex_bytes_new($3); + g_search_pattern_set_name($$, $1.data, $1.len); + } + ; + + hex_tokens : hex_token + { + $$ = $1; + } + | hex_tokens hex_token + { + + } + ; + + hex_token : HEX_BYTES + { + $$ = g_scan_token_node_plain_new($1, NULL, SPNF_NONE); + } + | FULL_MASK + { + printf("mask len: %llu\n", $1); + } + | SEMI_MASK + { + printf("semi mask: %hhx / %hhx \n", $1.byte, $1.mask); + } + | hex_range + { + printf("...range...\n"); + } + | "~" hex_token + { + + printf("hex -- NOT --\n"); + + } + | "(" hex_token "|" hex_token ")" + { + + printf("hex -- OR --\n"); + + } + ; + + hex_range : "[" "-" "]" + { + + printf("got inf range\n"); + + } + | "[" UNSIGNED_INTEGER "]" + { + + printf("got range [%llu]\n", $2); + + } + | "[" UNSIGNED_INTEGER "-" "]" + { + + printf("got range [%llu -> ]\n", $2); + + } + | "[" "-" UNSIGNED_INTEGER "]" + { + + printf("got range [ -> %llu]\n", $3); + + } + | "[" UNSIGNED_INTEGER "-" UNSIGNED_INTEGER "]" + { + + printf("got range [%llu -> %llu]\n", $2, $4); + + } + ; + +/** + * Définition de motif sous forme d'expression régulière + */ + + regex_pattern : BYTES_ID ASSIGN regex_tokens + { + + } + ; + + regex_tokens : regex_token + { + + } + | regex_tokens regex_token + { + + } + | "(" regex_tokens_list ")" + { + + printf("regex -- OR --\n"); + + } + | regex_tokens "(" regex_tokens_list ")" + { + + printf("regex -- OR --\n"); + + } + ; + + + regex_tokens_list : regex_tokens + | regex_tokens_list "|" regex_tokens + ; + + + regex_token : _regex_token + { + + } + | _regex_token regex_repeat + { + + } + ; + + _regex_token : DOT + { + printf("reg dot!\n"); + } + | REGEX_BYTES + { + printf("reg bytes: '%s' (l=%zu)\n", $1->data, $1->len); + } + | REGEX_CLASSES + { + printf("reg class!\n"); + } + | "[" REGEX_RANGE "]" + { + printf("reg range!\n"); + } + ; + + regex_repeat : "*" + { + printf(" .. repeat: *\n"); + } + | "+" + { + printf(" .. repeat: +\n"); + } + | "?" + { + printf(" .. repeat: ?\n"); + } + | "{" UNSIGNED_INTEGER "}" + { + + printf(" .. repeat {%llu}\n", $2); + + } + | "{" UNSIGNED_INTEGER "," "}" + { + + printf(" .. repeat {%llu,}\n", $2); + + } + | "{" "," UNSIGNED_INTEGER "}" + { + + printf(" .. repeat {,%llu}\n", $3); + + } + | "{" UNSIGNED_INTEGER "," UNSIGNED_INTEGER "}" + { + + printf(" .. repeat {%llu,%llu}\n", $2, $4); + + } + ; + + + +/** + * Définition des conditions. + */ + condition : CONDITION COLON cexpression { g_scan_rule_set_match_condition(*built_rule, $3); @@ -310,49 +652,19 @@ string_decl : IDENTIFIER ASSIGN PLAIN_STRING cexpression : _cexpression { $$ = $1; if ($$ == NULL) { printf("ERROR !!!\n"); YYERROR; } } - _cexpression : IDENTIFIER - { - printf("named var: %s\n", "$1"); - $$ = NULL; - /* - GSearchPattern *__pat; - GMatchCounter *__counter; - __pat = g_scan_rule_get_local_variable(*built_rule, $1); - if (__pat != NULL) - { - __counter = g_match_counter_new(__pat); - g_scan_rule_add_condition(*built_rule, G_MATCH_CONDITION(__counter)); - g_object_unref(G_OBJECT(__counter)); - g_object_unref(G_OBJECT(__pat)); - } - */ - } - | literal { $$ = $1; } - | pattern_match { $$ = $1; } - | item_chain { $$ = $1; } - | logical_expr { $$ = $1; } - | relational_expr { $$ = $1; } - | string_op { $$ = $1; } - | arithm_expr { $$ = $1; } - | set_counter { $$ = $1; } - | set { $$ = $1; } - | intersection { $$ = $1; } - | "(" cexpression ")" { $$ = $2; } - ; - - pattern_match : BYTES_ID_COUNTER - { - GSearchPattern *__pat; - __pat = g_scan_rule_get_local_variable(*built_rule, $1.data); - if (__pat == NULL) - $$ = NULL; - else - { - $$ = g_scan_match_counter_new(__pat); - g_object_unref(G_OBJECT(__pat)); - } - } - ; + _cexpression : literal { $$ = $1; } + | item_chain { $$ = $1; } + | logical_expr { $$ = $1; } + | relational_expr { $$ = $1; } + | string_op { $$ = $1; } + | arithm_expr { $$ = $1; } + | set_counter { $$ = $1; } + | set { $$ = $1; } + | set_access { $$ = $1; } + | intersection { $$ = $1; } + | pattern_handler { $$ = $1; } + | "(" cexpression ")" { $$ = $2; } + ; literal : "true" { @@ -538,16 +850,83 @@ set_counter : "none" "of" "them" { $$ = g_scan_literal_expression_new(LVT_BOOLEA } ; - intersection : cexpression "in" cexpression - { - $$ = g_scan_sets_intersection_new($1, $3); - g_object_unref(G_OBJECT($1)); - g_object_unref(G_OBJECT($3)); - } - ; - + set_access : cexpression "[" cexpression "]" + { + $$ = g_scan_set_item_new($1, $3); + g_object_unref(G_OBJECT($1)); + g_object_unref(G_OBJECT($3)); + } + ; + intersection : cexpression "in" cexpression + { + $$ = g_scan_sets_intersection_new($1, $3); + g_object_unref(G_OBJECT($1)); + g_object_unref(G_OBJECT($3)); + } + ; + pattern_handler : BYTES_ID + { + GSearchPattern *__pat; + __pat = g_scan_rule_get_local_variable(*built_rule, $1.data); + if (__pat == NULL) + $$ = NULL; + else + { + $$ = g_scan_pattern_handler_new(__pat, SHT_RAW); + g_object_unref(G_OBJECT(__pat)); + } + } + | BYTES_ID_COUNTER + { + GSearchPattern *__pat; + __pat = g_scan_rule_get_local_variable(*built_rule, $1.data); + if (__pat == NULL) + $$ = NULL; + else + { + $$ = g_scan_match_counter_new(__pat); + g_object_unref(G_OBJECT(__pat)); + } + } + | BYTES_ID_START + { + GSearchPattern *__pat; + __pat = g_scan_rule_get_local_variable(*built_rule, $1.data); + if (__pat == NULL) + $$ = NULL; + else + { + $$ = g_scan_pattern_handler_new(__pat, SHT_START); + g_object_unref(G_OBJECT(__pat)); + } + } + | BYTES_ID_LENGTH + { + GSearchPattern *__pat; + __pat = g_scan_rule_get_local_variable(*built_rule, $1.data); + if (__pat == NULL) + $$ = NULL; + else + { + $$ = g_scan_pattern_handler_new(__pat, SHT_LENGTH); + g_object_unref(G_OBJECT(__pat)); + } + } + | BYTES_ID_END + { + GSearchPattern *__pat; + __pat = g_scan_rule_get_local_variable(*built_rule, $1.data); + if (__pat == NULL) + $$ = NULL; + else + { + $$ = g_scan_pattern_handler_new(__pat, SHT_END); + g_object_unref(G_OBJECT(__pat)); + } + } + ; %% @@ -566,7 +945,7 @@ set_counter : "none" "of" "them" { $$ = g_scan_literal_expression_new(LVT_BOOLEA * * ******************************************************************************/ -static int yyerror(GContentScanner *scanner, yyscan_t yyscanner, GScanRule **built_rule, void/*GBytesPattern*/ **built_pattern, char **buf, size_t *allocated, size_t *used, char *msg) +static int yyerror(GContentScanner *scanner, yyscan_t yyscanner, GScanRule **built_rule, sized_string_t *tmp_0, sized_string_t *tmp_1, void/*GBytesPattern*/ **built_pattern, char **buf, size_t *allocated, size_t *used, char *msg) { printf("YYERROR line %d: %s\n", yyget_lineno(yyscanner), msg); @@ -593,6 +972,8 @@ bool process_rules_definitions(GContentScanner *scanner, const char *text, size_ { bool result; /* Bilan à renvoyer */ GScanRule *built_rule; /* Règle en construction */ + sized_string_t tmp_0; /* Zone tampon #1 */ + sized_string_t tmp_1; /* Zone tampon #2 */ void /*GBytesPattern*/ *built_pattern; /* Motif en construction */ char *buf; /* Zone de travail temporaire */ size_t allocated; /* Taille de mémoire allouée */ @@ -604,6 +985,13 @@ bool process_rules_definitions(GContentScanner *scanner, const char *text, size_ result = false; built_rule = NULL; + + tmp_0.data = malloc((length + 1) * sizeof(bin_t)); + tmp_0.len = 0; + + tmp_1.data = malloc((length + 1) * sizeof(bin_t)); + tmp_1.len = 0; + built_pattern = NULL; allocated = 256; @@ -616,7 +1004,7 @@ bool process_rules_definitions(GContentScanner *scanner, const char *text, size_ state = rost__scan_bytes(text, length, lexstate); - status = yyparse(scanner, lexstate, &built_rule, &built_pattern, &buf, &allocated, &used); + status = yyparse(scanner, lexstate, &built_rule, &tmp_0, &tmp_1, &built_pattern, &buf, &allocated, &used); result = (status == EXIT_SUCCESS); @@ -624,6 +1012,9 @@ bool process_rules_definitions(GContentScanner *scanner, const char *text, size_ rost_lex_destroy(lexstate); + exit_szstr(&tmp_0); + exit_szstr(&tmp_1); + free(buf); return result; diff --git a/src/analysis/scan/items/count.c b/src/analysis/scan/items/count.c index d87d33b..9040ec4 100644 --- a/src/analysis/scan/items/count.c +++ b/src/analysis/scan/items/count.c @@ -232,7 +232,7 @@ static bool g_scan_count_function_run_call(GScanCountFunction *item, GScanExpres else { - result = g_scan_expression_count_items(args[0], &value); + result = g_scan_expression_count_items(args[0], ctx, &value); if (result) *out = G_OBJECT(g_scan_literal_expression_new(LVT_UNSIGNED_INTEGER, (unsigned long long []){ value })); diff --git a/src/analysis/scan/match-int.h b/src/analysis/scan/match-int.h index 9030d75..cf774c4 100644 --- a/src/analysis/scan/match-int.h +++ b/src/analysis/scan/match-int.h @@ -29,8 +29,11 @@ -/* Affiche une correspondance sur la sortie standard. */ -typedef void (* display_scan_match_fc) (const GScanMatch *); +/* Affiche une correspondance au format texte. */ +typedef void (* output_scan_match_to_text_fc) (const GScanMatch *, int); + +/* Affiche une correspondance au format JSON. */ +typedef void (* output_scan_match_to_json_fc) (const GScanMatch *, const sized_string_t *, unsigned int, int); /* Correspondance trouvée avec un motif (instance) */ @@ -47,7 +50,8 @@ struct _GScanMatchClass { GObjectClass parent; /* A laisser en premier */ - display_scan_match_fc display; /* Impression des résultats */ + output_scan_match_to_text_fc to_text; /* Impression au format texte */ + output_scan_match_to_json_fc to_json; /* Impression au format JSON */ }; diff --git a/src/analysis/scan/match.c b/src/analysis/scan/match.c index c7e2a78..b0b4320 100644 --- a/src/analysis/scan/match.c +++ b/src/analysis/scan/match.c @@ -157,8 +157,9 @@ GSearchPattern *g_scan_match_get_source(const GScanMatch *match) /****************************************************************************** * * * Paramètres : match = définition de correspondance à manipuler. * +* fd = canal d'écriture. * * * -* Description : Affiche une correspondance sur la sortie standard. * +* Description : Affiche une correspondance au format texte. * * * * Retour : - * * * @@ -166,12 +167,97 @@ GSearchPattern *g_scan_match_get_source(const GScanMatch *match) * * ******************************************************************************/ -void g_scan_match_display(const GScanMatch *match) +void g_scan_match_output_to_text(const GScanMatch *match, int fd) { GScanMatchClass *class; /* Classe à activer */ class = G_SCAN_MATCH_GET_CLASS(match); - class->display(match); + class->to_text(match, fd); + +} + + +/****************************************************************************** +* * +* Paramètres : match = définition de correspondance à manipuler. * +* * +* Description : Convertit une correspondance en texte. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_scan_match_convert_as_text(const GScanMatch *match) +{ + /* TODO */ + +} + + +/****************************************************************************** +* * +* Paramètres : match = définition de correspondance à manipuler. * +* padding = éventuel bourrage initial à placer ou NULL. * +* level = profondeur actuelle. * +* fd = canal d'écriture. * +* trailing = impose une virgule finale ? * +* * +* Description : Affiche une correspondance au format JSON. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_scan_match_output_to_json(const GScanMatch *match, const sized_string_t *padding, unsigned int level, int fd, bool trailing) +{ + unsigned int i; /* Boucle de parcours */ + GScanMatchClass *class; /* Classe à activer */ + + /* Introduction */ + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + write(fd, "{\n", 2); + + /* Affichage du contenu */ + + class = G_SCAN_MATCH_GET_CLASS(match); + + class->to_json(match, padding, level + 1, fd); + + /* Conclusion */ + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + if (trailing) + write(fd, "},\n", 3); + else + write(fd, "}\n", 2); + +} + + +/****************************************************************************** +* * +* Paramètres : match = définition de correspondance à manipuler. * +* * +* Description : Convertit une correspondance en JSON. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_scan_match_convert_as_json(const GScanMatch *match) +{ + /* TODO */ } diff --git a/src/analysis/scan/match.h b/src/analysis/scan/match.h index 0990ae0..e713b5d 100644 --- a/src/analysis/scan/match.h +++ b/src/analysis/scan/match.h @@ -29,6 +29,7 @@ #include "pattern.h" +#include "../../common/szstr.h" @@ -53,8 +54,17 @@ GType g_scan_match_get_type(void); /* Indique la source du motif d'origine recherché. */ GSearchPattern *g_scan_match_get_source(const GScanMatch *); -/* Affiche une correspondance sur la sortie standard. */ -void g_scan_match_display(const GScanMatch *); +/* Affiche une correspondance au format texte. */ +void g_scan_match_output_to_text(const GScanMatch *, int); + +/* Convertit une correspondance en texte. */ +void g_scan_match_convert_as_text(const GScanMatch *); + +/* Affiche une correspondance au format JSON. */ +void g_scan_match_output_to_json(const GScanMatch *, const sized_string_t *, unsigned int, int, bool); + +/* Convertit une correspondance en JSON. */ +void g_scan_match_convert_as_json(const GScanMatch *); diff --git a/src/analysis/scan/matches/bytes-int.h b/src/analysis/scan/matches/bytes-int.h index c983aa3..6f7e60b 100644 --- a/src/analysis/scan/matches/bytes-int.h +++ b/src/analysis/scan/matches/bytes-int.h @@ -33,7 +33,7 @@ /* Correspondance trouvée avec une chaîne (instance) */ -struct _GBytesMatch +struct _GScanBytesMatch { GScanMatch parent; /* A laisser en premier */ @@ -45,7 +45,7 @@ struct _GBytesMatch }; /* Correspondance trouvée avec une chaîne (classe) */ -struct _GBytesMatchClass +struct _GScanBytesMatchClass { GScanMatchClass parent; /* A laisser en premier */ @@ -53,7 +53,7 @@ struct _GBytesMatchClass /* Met en place une correspondance trouvée avec un motif. */ -bool g_bytes_match_create(GBytesMatch *, GSearchPattern *, GBinContent *, phys_t, phys_t); +bool g_scan_bytes_match_create(GScanBytesMatch *, GSearchPattern *, GBinContent *, phys_t, phys_t); diff --git a/src/analysis/scan/matches/bytes.c b/src/analysis/scan/matches/bytes.c index 90fa27d..043170e 100644 --- a/src/analysis/scan/matches/bytes.c +++ b/src/analysis/scan/matches/bytes.c @@ -24,10 +24,14 @@ #include "bytes.h" +#include <assert.h> #include <ctype.h> +#include <stdio.h> #include "bytes-int.h" +#include "../../../common/cpp.h" +#include "../../../core/logs.h" @@ -35,24 +39,27 @@ /* Initialise la classe des correspondances de chaînes. */ -static void g_bytes_match_class_init(GBytesMatchClass *); +static void g_scan_bytes_match_class_init(GScanBytesMatchClass *); /* Initialise une instance de correspondance de chaîne trouvée. */ -static void g_bytes_match_init(GBytesMatch *); +static void g_scan_bytes_match_init(GScanBytesMatch *); /* Supprime toutes les références externes. */ -static void g_bytes_match_dispose(GBytesMatch *); +static void g_scan_bytes_match_dispose(GScanBytesMatch *); /* Procède à la libération totale de la mémoire. */ -static void g_bytes_match_finalize(GBytesMatch *); +static void g_scan_bytes_match_finalize(GScanBytesMatch *); /* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ -/* Affiche une correspondance sur la sortie standard. */ -static void g_bytes_match_display(const GBytesMatch *); +/* Affiche une correspondance au format texte. */ +static void g_scan_bytes_match_output_to_text(const GScanBytesMatch *, int); + +/* Affiche une correspondance au format JSON. */ +static void g_scan_bytes_match_output_to_json(const GScanBytesMatch *, const sized_string_t *, unsigned int, int); @@ -62,7 +69,7 @@ static void g_bytes_match_display(const GBytesMatch *); /* Indique le type défini pour un correspondance de chaîne identifiée. */ -G_DEFINE_TYPE(GBytesMatch, g_bytes_match, G_TYPE_SCAN_MATCH); +G_DEFINE_TYPE(GScanBytesMatch, g_scan_bytes_match, G_TYPE_SCAN_MATCH); /****************************************************************************** @@ -77,19 +84,20 @@ G_DEFINE_TYPE(GBytesMatch, g_bytes_match, G_TYPE_SCAN_MATCH); * * ******************************************************************************/ -static void g_bytes_match_class_init(GBytesMatchClass *klass) +static void g_scan_bytes_match_class_init(GScanBytesMatchClass *klass) { GObjectClass *object; /* Autre version de la classe */ GScanMatchClass *match; /* Version parente de la classe*/ object = G_OBJECT_CLASS(klass); - object->dispose = (GObjectFinalizeFunc/* ! */)g_bytes_match_dispose; - object->finalize = (GObjectFinalizeFunc)g_bytes_match_finalize; + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_bytes_match_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_bytes_match_finalize; match = G_SCAN_MATCH_CLASS(klass); - match->display = (display_scan_match_fc)g_bytes_match_display; + match->to_text = (output_scan_match_to_text_fc)g_scan_bytes_match_output_to_text; + match->to_json = (output_scan_match_to_json_fc)g_scan_bytes_match_output_to_json; } @@ -106,7 +114,7 @@ static void g_bytes_match_class_init(GBytesMatchClass *klass) * * ******************************************************************************/ -static void g_bytes_match_init(GBytesMatch *match) +static void g_scan_bytes_match_init(GScanBytesMatch *match) { match->content = NULL; @@ -128,11 +136,11 @@ static void g_bytes_match_init(GBytesMatch *match) * * ******************************************************************************/ -static void g_bytes_match_dispose(GBytesMatch *match) +static void g_scan_bytes_match_dispose(GScanBytesMatch *match) { g_clear_object(&match->content); - G_OBJECT_CLASS(g_bytes_match_parent_class)->dispose(G_OBJECT(match)); + G_OBJECT_CLASS(g_scan_bytes_match_parent_class)->dispose(G_OBJECT(match)); } @@ -149,9 +157,9 @@ static void g_bytes_match_dispose(GBytesMatch *match) * * ******************************************************************************/ -static void g_bytes_match_finalize(GBytesMatch *match) +static void g_scan_bytes_match_finalize(GScanBytesMatch *match) { - G_OBJECT_CLASS(g_bytes_match_parent_class)->finalize(G_OBJECT(match)); + G_OBJECT_CLASS(g_scan_bytes_match_parent_class)->finalize(G_OBJECT(match)); } @@ -171,13 +179,13 @@ static void g_bytes_match_finalize(GBytesMatch *match) * * ******************************************************************************/ -GScanMatch *g_bytes_match_new(GSearchPattern *source, GBinContent *content, phys_t start, phys_t len) +GScanMatch *g_scan_bytes_match_new(GSearchPattern *source, GBinContent *content, phys_t start, phys_t len) { GScanMatch *result; /* Structure à retourner */ - result = g_object_new(G_TYPE_BYTES_MATCH, NULL); + result = g_object_new(G_TYPE_SCAN_BYTES_MATCH, NULL); - if (!g_bytes_match_create(G_BYTES_MATCH(result), source, content, start, len)) + if (!g_scan_bytes_match_create(G_SCAN_BYTES_MATCH(result), source, content, start, len)) g_clear_object(&result); return result; @@ -201,7 +209,7 @@ GScanMatch *g_bytes_match_new(GSearchPattern *source, GBinContent *content, phys * * ******************************************************************************/ -bool g_bytes_match_create(GBytesMatch *match, GSearchPattern *source, GBinContent *content, phys_t start, phys_t len) +bool g_scan_bytes_match_create(GScanBytesMatch *match, GSearchPattern *source, GBinContent *content, phys_t start, phys_t len) { bool result; /* Bilan à retourner */ GScanMatch *base; /* Lien vers les infos de base */ @@ -224,6 +232,58 @@ bool g_bytes_match_create(GBytesMatch *match, GSearchPattern *source, GBinConten } +/****************************************************************************** +* * +* Paramètres : match = informations de correspondance à consulter. * +* * +* Description : Fournit une référence au contenu lié à la correspondance. * +* * +* Retour : Content binaire associé au context. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GBinContent *g_scan_bytes_match_get_content(const GScanBytesMatch *match) +{ + GBinContent *result; /* Instance à retourner */ + + result = match->content; + + g_object_ref(G_OBJECT(result)); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : match = informations de correspondance à consulter. * +* start = position de départ d'un motif détecté. [OUT] * +* end = position d'arrivée d'un motif détecté. [OUT] * +* * +* Description : Indique la localisation d'une correspondance établie. * +* * +* Retour : Taille mesurée de la correspondance. * +* * +* Remarques : - * +* * +******************************************************************************/ + +phys_t g_scan_bytes_match_get_location(const GScanBytesMatch *match, phys_t *start, phys_t *end) +{ + phys_t result; /* Taille à retourner */ + + result = match->len; + + *start = match->start; + *end = match->start + result; + + return result; + +} + /* ---------------------------------------------------------------------------------- */ /* IMPLEMENTATION DES FONCTIONS DE CLASSE */ @@ -233,8 +293,9 @@ bool g_bytes_match_create(GBytesMatch *match, GSearchPattern *source, GBinConten /****************************************************************************** * * * Paramètres : match = définition de correspondance à manipuler. * +* fd = canal d'écriture. * * * -* Description : Affiche une correspondance sur la sortie standard. * +* Description : Affiche une correspondance au format texte. * * * * Retour : - * * * @@ -242,15 +303,34 @@ bool g_bytes_match_create(GBytesMatch *match, GSearchPattern *source, GBinConten * * ******************************************************************************/ -static void g_bytes_match_display(const GBytesMatch *match) +static void g_scan_bytes_match_output_to_text(const GScanBytesMatch *match, int fd) { + char value[2 + ULLONG_MAXLEN]; /* Impression de la position */ + int ret; /* Bilan d'une conversion */ GScanMatch *base; /* Lien vers les infos de base */ const char *name; /* Désignation du motif ciblé */ vmpa2t pos; /* Tête de lecture */ const bin_t *data; /* Accès aux données brutes */ - phys_t i; /* Boucle de parcours */ + phys_t k; /* Boucle de parcours #2 */ + + /* Position dans le binaire (hexadécimal) */ + + ret = snprintf(value, ULLONG_MAXLEN, "0x%llx", (unsigned long long)match->start); + + if (ret > 0) + write(fd, value, ret); - /* Affichage d'un repère */ + else + { + log_simple_message(LMT_EXT_ERROR, "Error while converting offset to hex!"); + write(fd, "\"<error>\"", 9); + } + + write(fd, ":", 1); + + /* Affichage de la désignation */ + + write(fd, "$", 1); base = G_SCAN_MATCH(match); @@ -262,25 +342,151 @@ static void g_bytes_match_display(const GBytesMatch *match) * Cette absence de nom est supportée ici. */ - if (name == NULL) - name = ""; + if (name != NULL) + write(fd, name, strlen(name)); + + write(fd, ": ", 2); + + /* Affichage du contenu */ + + init_vmpa(&pos, match->start, VMPA_NO_VIRTUAL); + + data = g_binary_content_get_raw_access(match->content, &pos, match->len); + + for (k = 0; k < match->len; k++) + { + if (isprint(data[k])) + write(fd, &data[k], 1); + + else + { + write(fd, "\\x", 2); + + ret = snprintf(value, ULLONG_MAXLEN, "%02hhx", data[k]); + + if (ret > 0) + { + assert(ret == 2); + write(fd, value, ret); + } + + else + { + log_simple_message(LMT_EXT_ERROR, "Error while converting data!"); + write(fd, "??", 2); + } + + } + + } + + write(fd, "\n", 1); + +} + + +/****************************************************************************** +* * +* Paramètres : match = définition de correspondance à manipuler. * +* padding = éventuel bourrage initial à placer ou NULL. * +* level = profondeur actuelle. * +* fd = canal d'écriture. * +* * +* Description : Affiche une correspondance au format JSON. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_bytes_match_output_to_json(const GScanBytesMatch *match, const sized_string_t *padding, unsigned int level, int fd) +{ + unsigned int i; /* Boucle de parcours #1 */ + vmpa2t pos; /* Tête de lecture */ + char value[4 + ULLONG_MAXLEN]; /* Impression de la position */ + int ret; /* Bilan d'une conversion */ + const bin_t *data; /* Accès aux données brutes */ + phys_t k; /* Boucle de parcours #2 */ + + /* Position dans le binaire (décimal) */ + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + write(fd, "\"offset\": ", 10); + + ret = snprintf(value, ULLONG_MAXLEN, "%llu", (unsigned long long)match->start); + + if (ret > 0) + write(fd, value, ret); + + else + { + log_simple_message(LMT_EXT_ERROR, "Error while converting offset!"); + write(fd, "null", 4); + } + + write(fd, ",\n", 2); + + /* Position dans le binaire (hexadécimal) */ + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + write(fd, "\"offset_hex\": ", 14); - printf("0x%llx:$%s: ", (unsigned long long)match->start, name); + ret = snprintf(value, ULLONG_MAXLEN, "\"0x%llx\"", (unsigned long long)match->start); + + if (ret > 0) + write(fd, value, ret); + + else + { + log_simple_message(LMT_EXT_ERROR, "Error while converting offset to hex!"); + write(fd, "null", 4); + } + + write(fd, ",\n", 2); /* Affichage du contenu */ + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + write(fd, "\"content\": \"", 12); + init_vmpa(&pos, match->start, VMPA_NO_VIRTUAL); data = g_binary_content_get_raw_access(match->content, &pos, match->len); - for (i = 0; i < match->len; i++) + for (k = 0; k < match->len; k++) { - if (isprint(data[i])) - printf("%c", data[i]); + if (isprint(data[k])) + write(fd, &data[k], 1); + else - printf("\\x%02hhx", data[i]); + { + write(fd, "\\x", 2); + + ret = snprintf(value, ULLONG_MAXLEN, "%02hhx", data[k]); + + if (ret > 0) + { + assert(ret == 2); + write(fd, value, ret); + } + + else + { + log_simple_message(LMT_EXT_ERROR, "Error while converting data!"); + write(fd, "??", 2); + } + + } + } - printf("\n"); + write(fd, "\"\n", 2); } diff --git a/src/analysis/scan/matches/bytes.h b/src/analysis/scan/matches/bytes.h index 22e76a6..e599ee4 100644 --- a/src/analysis/scan/matches/bytes.h +++ b/src/analysis/scan/matches/bytes.h @@ -33,26 +33,32 @@ -#define G_TYPE_BYTES_MATCH g_bytes_match_get_type() -#define G_BYTES_MATCH(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_BYTES_MATCH, GBytesMatch)) -#define G_IS_BYTES_MATCH(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_BYTES_MATCH)) -#define G_BYTES_MATCH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_BYTES_MATCH, GBytesMatchClass)) -#define G_IS_BYTES_MATCH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_BYTES_MATCH)) -#define G_BYTES_MATCH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_BYTES_MATCH, GBytesMatchClass)) +#define G_TYPE_SCAN_BYTES_MATCH g_scan_bytes_match_get_type() +#define G_SCAN_BYTES_MATCH(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_BYTES_MATCH, GScanBytesMatch)) +#define G_IS_SCAN_BYTES_MATCH(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_BYTES_MATCH)) +#define G_SCAN_BYTES_MATCH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_BYTES_MATCH, GScanBytesMatchClass)) +#define G_IS_SCAN_BYTES_MATCH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_BYTES_MATCH)) +#define G_SCAN_BYTES_MATCH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_BYTES_MATCH, GScanBytesMatchClass)) /* Correspondance trouvée avec une chaîne (instance) */ -typedef struct _GBytesMatch GBytesMatch; +typedef struct _GScanBytesMatch GScanBytesMatch; /* Correspondance trouvée avec une chaîne (classe) */ -typedef struct _GBytesMatchClass GBytesMatchClass; +typedef struct _GScanBytesMatchClass GScanBytesMatchClass; /* Indique le type défini pour un correspondance de chaîne identifiée. */ -GType g_bytes_match_get_type(void); +GType g_scan_bytes_match_get_type(void); /* Prend note d'une correspondance trouvée avec un motif. */ -GScanMatch *g_bytes_match_new(GSearchPattern *, GBinContent *, phys_t, phys_t); +GScanMatch *g_scan_bytes_match_new(GSearchPattern *, GBinContent *, phys_t, phys_t); + +/* Fournit une référence au contenu lié à la correspondance. */ +GBinContent *g_scan_bytes_match_get_content(const GScanBytesMatch *); + +/* Indique la localisation d'une correspondance établie. */ +phys_t g_scan_bytes_match_get_location(const GScanBytesMatch *, phys_t *, phys_t *); diff --git a/src/analysis/scan/matches/pending.c b/src/analysis/scan/matches/pending.c index 73b7a06..9d1037d 100644 --- a/src/analysis/scan/matches/pending.c +++ b/src/analysis/scan/matches/pending.c @@ -79,46 +79,52 @@ void exit_pending_matches(pending_matches_t *matches) /****************************************************************************** * * * Paramètres : matches = suivi de correspondances à consulter. * -* start = point de départ d'une suite pour de correspondance.* -* mindex = indice de départ et d'arrivée. [OUT] * * * -* Description : Détermine la zone de correspondance idéale pour complément. * +* Description : Dénombre les correspondances établies jusque là. * * * -* Retour : Bilan de l'opération : true en cas de succès des recherches. * +* Retour : Quantité de correspondances complètes jusqu'à présent. * * * * Remarques : - * * * ******************************************************************************/ -bool find_target_in_pending_matches(pending_matches_t *matches, phys_t start, size_t *target) +size_t count_pending_matches(const pending_matches_t *matches) { - bool result; /* Bilan à retourner */ - size_t i; /* Boucle de parcours */ - match_area_t *area; /* Zone à initialiser */ + size_t result; /* Quantité à renvoyer */ - assert(*target <= matches->used); + result = matches->used; - result = false; + return result; - for (i = *target; i < matches->used; i++) - { - area = &matches->areas[i]; +} - if ((area->start + area->length) == start) - { - *target = i; - result = true; - break; - } - } +/****************************************************************************** +* * +* Paramètres : matches = suivi de correspondances à consulter. * +* count = nombre de correspondances en attente. [OUT] * +* * +* Description : Fournit la liste des correspondances établies à présent. * +* * +* Retour : Liste de correspondances en lecture seule. * +* * +* Remarques : - * +* * +******************************************************************************/ + +const match_area_t *get_all_pending_matches(const pending_matches_t *matches, size_t *count) +{ + match_area_t *result; /* Série à renvoyer */ + + result = matches->areas; + + *count = matches->used; return result; } - /****************************************************************************** * * * Paramètres : matches = suivi de correspondances à compléter. * @@ -133,7 +139,7 @@ bool find_target_in_pending_matches(pending_matches_t *matches, phys_t start, si * * ******************************************************************************/ -void add_pending_matches(pending_matches_t *matches, phys_t start, phys_t length) +void add_pending_match(pending_matches_t *matches, phys_t start, phys_t length) { match_area_t *area; /* Zone à initialiser */ @@ -148,7 +154,9 @@ void add_pending_matches(pending_matches_t *matches, phys_t start, phys_t length area = &matches->areas[matches->used++]; area->start = start; - area->length = length; + area->end = start + length; + + area->ttl = 1; } @@ -167,21 +175,71 @@ void add_pending_matches(pending_matches_t *matches, phys_t start, phys_t length * * ******************************************************************************/ -void extend_pending_matches(pending_matches_t *matches, size_t target, phys_t length) +void extend_pending_match(pending_matches_t *matches, size_t target, phys_t end) +{ + match_area_t *area; /* Zone à actualiser */ + + assert(target < matches->used); + + area = &matches->areas[matches->used++]; + + if (area->ttl == 0) + { + area->end = end; + + area->ttl = 1; + + } + else + { + assert(area->ttl == 1); + + add_pending_match(matches, area->start, end - area->start); + + } + +} + + +/****************************************************************************** +* * +* Paramètres : matches = suivi de correspondances à consulter. * +* target = indice de la zone de correspondance concernée. * +* pos = position à tester. * +* * +* Description : Détermine si une correspondance se termine à une position. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool has_pending_match_ending_at(const pending_matches_t *matches, size_t target, phys_t pos) { + bool result; /* Statut à retourner */ + match_area_t *area; /* Couverture visée */ + assert(target < matches->used); - matches->areas[target].length += length; + area = &matches->areas[target]; + + result = (area->end == pos); + + return result; } /****************************************************************************** * * -* Paramètres : matches = suivi de correspondances à modifier. * +* Paramètres : matches = suivi de correspondances à consulter. * * target = indice de la zone de correspondance concernée. * +* pos = position à tester. * +* min = borne inférieure de l'espace à considérer. * +* max = borne supérieure de l'espace à considérer. * * * -* Description : Retire une correspondance finalement non établie du suivi. * +* Description : Détermine si une correspondance se situe dans une plage. * * * * Retour : - * * * @@ -189,14 +247,135 @@ void extend_pending_matches(pending_matches_t *matches, size_t target, phys_t le * * ******************************************************************************/ -void remove_pending_matches(pending_matches_t *matches, size_t target) +bool has_pending_match_ending_between(const pending_matches_t *matches, size_t target, phys_t pos, phys_t min, phys_t max) { + bool result; /* Statut à retourner */ + match_area_t *area; /* Couverture visée */ + assert(target < matches->used); - if ((target + 1) < matches->used) - memmove(&matches->areas[target], &matches->areas[target + 1], - (matches->used - target - 1) * sizeof(match_area_t)); + area = &matches->areas[target]; + + result = ((area->end + min) <= pos && pos <= (area->end + max)); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : matches = suivi de correspondances à modifier. * +* * +* Description : Réinitialisation à 0 tous les TTL de correspondances. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void reset_pending_matches_ttl(pending_matches_t *matches) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < matches->used; i++) + matches->areas[i].ttl = 0; + +} + + +/****************************************************************************** +* * +* Paramètres : matches = suivi de correspondances à modifier. * +* * +* Description : Retire toutes les correspondances sans issue pour l'analyse. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void purge_pending_matches(pending_matches_t *matches) +{ + match_area_t *del_start; /* Départ d'une zone morte */ + match_area_t *del_end; /* Fin d'une zone morte */ + size_t del_remaining; /* Nombre de valides ensuite */ + size_t del_count; /* Nombre d'éléments à effacer */ + size_t i; /* Boucle de parcours */ + + /** + * Note : le code original était le suivant : + * + + * for (i = matches->used; i > 0; i--) + * if (matches->areas[i - 1].ttl == 0) + * { + * memmove(&matches->areas[i - 1], &matches->areas[i], (matches->used - i) * sizeof(match_area_t)); + * matches->used--; + * } + * + * Pour éviter les appels à memmove(), un déplacement par blocs est désormais visée. + */ + + del_start = NULL; + del_end = NULL; + del_count = 0; + del_remaining = 0; - matches->used--; + /* Suppression en bloc si possible */ + + for (i = matches->used; i > 0; i--) + { + if (matches->areas[i - 1].ttl == 0) + { + del_start = &matches->areas[i - 1]; + + if (del_end == NULL) + { + del_end = del_start; + del_remaining = matches->used - i; + } + + del_count++; + + } + else + { + if (del_start != NULL) + { + assert(&matches->areas[i] == del_start); + + if (del_remaining > 0) + memmove(del_start, del_end + 1, del_remaining * sizeof(match_area_t)); + + assert(matches->used > del_count); + matches->used -= del_count; + + del_start = NULL; + del_end = NULL; + del_count = 0; + del_remaining = 0; + + } + + } + + } + + /* Dernier traitement au besoin */ + + if (del_start != NULL) + { + assert(&matches->areas[0] == del_start); + + if (del_remaining > 0) + memmove(del_start, del_end + 1, del_remaining * sizeof(match_area_t)); + + assert(matches->used >= del_count); + matches->used -= del_count; + + } } diff --git a/src/analysis/scan/matches/pending.h b/src/analysis/scan/matches/pending.h index de2fd5f..0a1fe5c 100644 --- a/src/analysis/scan/matches/pending.h +++ b/src/analysis/scan/matches/pending.h @@ -25,6 +25,9 @@ #define _ANALYSIS_SCAN_MATCHES_PENDING_H +#include <stdbool.h> + + #include "../../content.h" @@ -33,7 +36,9 @@ typedef struct _match_area_t { phys_t start; /* Point de départ */ - phys_t length; /* Taille de la zone couverte */ + phys_t end; /* Point d'arrivée (exclus) */ + + unsigned long ttl; /* Durée de vie pour analyse */ } match_area_t; @@ -55,21 +60,34 @@ void init_pending_matches(pending_matches_t *); /* Libère la mémoire utilisée par une consolidation. */ void exit_pending_matches(pending_matches_t *); +// TODO ajouter un assert(used == 0) si !initialized */ #define are_pending_matches_initialized(pm) pm->initialized #define set_pending_matches_initialized(pm) pm->initialized = true -/* Détermine la zone de correspondance idéale pour complément. */ -bool find_target_in_pending_matches(pending_matches_t *, phys_t, size_t *); +/* Dénombre les correspondances établies jusque là. */ +size_t count_pending_matches(const pending_matches_t *); + +/* Fournit la liste des correspondances établies à présent. */ +const match_area_t *get_all_pending_matches(const pending_matches_t *, size_t *); /* Ajoute au suivi la définition d'une nouvelle correspondance. */ -void add_pending_matches(pending_matches_t *, phys_t, phys_t); +void add_pending_match(pending_matches_t *, phys_t, phys_t); /* Etend une zone couverte dans le suivi des correspondances. */ -void extend_pending_matches(pending_matches_t *, size_t, phys_t); +void extend_pending_match(pending_matches_t *, size_t, phys_t); + +/* Détermine si une correspondance se situe dans une plage. */ +bool has_pending_match_ending_between(const pending_matches_t *, size_t, phys_t, phys_t, phys_t); + +/* Détermine si une correspondance se termine à une position. */ +bool has_pending_match_ending_at(const pending_matches_t *, size_t, phys_t); + +/* Réinitialisation à 0 tous les TTL de correspondances. */ +void reset_pending_matches_ttl(pending_matches_t *); -/* Retire une correspondance finalement non établie du suivi. */ -void remove_pending_matches(pending_matches_t *, size_t); +/* Retire toutes les correspondances sans issue pour l'analyse. */ +void purge_pending_matches(pending_matches_t *); diff --git a/src/analysis/scan/options-int.h b/src/analysis/scan/options-int.h index a7772ed..4e85974 100644 --- a/src/analysis/scan/options-int.h +++ b/src/analysis/scan/options-int.h @@ -36,6 +36,8 @@ struct _GScanOptions GType data_backend; /* Choix du moteur d'analyse */ + bool print_json; /* Sortie au format json ? */ + bool print_strings; /* Affichage de correspondances*/ bool print_stats; /* Affichage de statistiques ? */ }; diff --git a/src/analysis/scan/options.c b/src/analysis/scan/options.c index 89e411e..cb56c2b 100644 --- a/src/analysis/scan/options.c +++ b/src/analysis/scan/options.c @@ -199,6 +199,92 @@ void g_scan_options_set_backend_for_data(GScanOptions *options, GType backend) * * * Paramètres : options = ensemble d'options d'analyses à consulter. * * * +* Description : Impose le format JSON comme type de sortie. * +* * +* Retour : Etat de l'option visée à conservé. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_scan_options_get_print_json(const GScanOptions *options) +{ + bool result; /* Statut à retourner */ + + result = options->print_json; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : options = ensemble d'options d'analyses à modifier. * +* state = état de l'option visée à conserver. * +* * +* Description : Mémorise le format JSON comme type de sortie. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_scan_options_set_print_json(GScanOptions *options, bool state) +{ + options->print_json = state; + +} + + +/****************************************************************************** +* * +* Paramètres : options = ensemble d'options d'analyses à consulter. * +* * +* Description : Indique un besoin d'affichage des correspondances finales. * +* * +* Retour : Etat de l'option visée à conservé. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_scan_options_get_print_strings(const GScanOptions *options) +{ + bool result; /* Statut à retourner */ + + result = options->print_strings; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : options = ensemble d'options d'analyses à modifier. * +* state = état de l'option visée à conserver. * +* * +* Description : Mémorise un besoin d'affichage des correspondances finales. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_scan_options_set_print_strings(GScanOptions *options, bool state) +{ + options->print_strings = state; + +} + + +/****************************************************************************** +* * +* Paramètres : options = ensemble d'options d'analyses à consulter. * +* * * Description : Indique un besoin de statistiques en fin de compilation. * * * * Retour : Etat de l'option visée à conservé. * diff --git a/src/analysis/scan/options.h b/src/analysis/scan/options.h index a7931c5..6b027e3 100644 --- a/src/analysis/scan/options.h +++ b/src/analysis/scan/options.h @@ -57,6 +57,18 @@ GType g_scan_options_get_backend_for_data(const GScanOptions *); /* Sélectionne un type de moteur d'analyse pour données brutes. */ void g_scan_options_set_backend_for_data(GScanOptions *, GType); +/* Impose le format JSON comme type de sortie. */ +bool g_scan_options_get_print_json(const GScanOptions *); + +/* Mémorise le format JSON comme type de sortie. */ +void g_scan_options_set_print_json(GScanOptions *, bool); + +/* Indique un besoin d'affichage des correspondances finales. */ +bool g_scan_options_get_print_strings(const GScanOptions *); + +/* Mémorise un besoin d'affichage des correspondances finales. */ +void g_scan_options_set_print_strings(GScanOptions *, bool); + /* Indique un besoin de statistiques en fin de compilation. */ bool g_scan_options_get_print_stats(const GScanOptions *); diff --git a/src/analysis/scan/pattern-int.h b/src/analysis/scan/pattern-int.h index 03af30f..b510c75 100644 --- a/src/analysis/scan/pattern-int.h +++ b/src/analysis/scan/pattern-int.h @@ -28,9 +28,15 @@ #include "pattern.h" +#include "context.h" -/* Décompte le nombre de correspondances identifiées. */ -typedef size_t (* count_pattern_matchs_fc) (const GSearchPattern *); + + +/* Affiche un motif de recherche au format texte. */ +typedef void (* output_pattern_to_text_fc) (const GSearchPattern *, GScanContext *, int); + +/* Affiche un motif de recherche au format JSON. */ +typedef void (* output_pattern_to_json_fc) (const GSearchPattern *, GScanContext *, const sized_string_t *, unsigned int, int); /* Motif à rechercher au sein d'un contenu (instance) */ @@ -47,7 +53,8 @@ struct _GSearchPatternClass { GObjectClass parent; /* A laisser en premier */ - count_pattern_matchs_fc count; /* Décompte des résultats */ + output_pattern_to_text_fc to_text; /* Impression au format texte */ + output_pattern_to_json_fc to_json; /* Impression au format JSON */ }; diff --git a/src/analysis/scan/pattern.c b/src/analysis/scan/pattern.c index 53a2662..5b966d2 100644 --- a/src/analysis/scan/pattern.c +++ b/src/analysis/scan/pattern.c @@ -186,25 +186,122 @@ void g_search_pattern_set_name(GSearchPattern *pattern, const char *name, size_t /****************************************************************************** * * -* Paramètres : pattern = définition de motif à consulter. * +* Paramètres : pattern = définition de motif à considérer. * +* context = contexte de l'analyse à mener. * +* fd = canal d'écriture. * * * -* Description : Décompte le nombre de correspondances identifiées. * +* Description : Affiche un motif de recherche au format texte. * * * -* Retour : Quantité d'identifications réalisées. * +* Retour : - * * * * Remarques : - * * * ******************************************************************************/ -size_t g_search_pattern_count_matchs(const GSearchPattern *pattern) +void g_search_pattern_output_to_text(const GSearchPattern *pattern, GScanContext *context, int fd) { - size_t result; /* Décompte à retourner */ GSearchPatternClass *class; /* Classe à activer */ class = G_SEARCH_PATTERN_GET_CLASS(pattern); - result = 0;//class->count(pattern); + class->to_text(pattern, context, fd); - return result; +} + + +/****************************************************************************** +* * +* Paramètres : pattern = définition de motif à considérer. * +* context = contexte de l'analyse à mener. * +* * +* Description : Convertit un motif de recherche en texte. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_search_pattern_convert_as_text(const GSearchPattern *pattern, GScanContext *context) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : pattern = définition de motif à considérer. * +* context = contexte de l'analyse à mener. * +* padding = éventuel bourrage initial à placer ou NULL. * +* level = profondeur actuelle. * +* fd = canal d'écriture. * +* trailing = impose une virgule finale ? * +* * +* Description : Affiche un motif de recherche au format JSON. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_search_pattern_output_to_json(const GSearchPattern *pattern, GScanContext *context, const sized_string_t *padding, unsigned int level, int fd, bool trailing) +{ + unsigned int i; /* Boucle de parcours */ + GSearchPatternClass *class; /* Classe à activer */ + + /* Introduction */ + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + write(fd, "{\n", 2); + + /* Désignation du motif */ + + for (i = 0; i < (level + 1); i++) + write(fd, padding->data, padding->len); + + write(fd, "\"name\": \"$", 10); + + write(fd, pattern->name, strlen(pattern->name)); + + write(fd, "\",\n", 3); + + /* Affichage du contenu */ + + class = G_SEARCH_PATTERN_GET_CLASS(pattern); + + class->to_json(pattern, context, padding, level + 1, fd); + + /* Conclusion */ + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + if (trailing) + write(fd, "},\n", 3); + else + write(fd, "}\n", 2); + +} + + +/****************************************************************************** +* * +* Paramètres : pattern = définition de motif à considérer. * +* context = contexte de l'analyse à mener. * +* * +* Description : Convertit un motif de recherche en JSON. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_search_pattern_convert_as_json(const GSearchPattern *pattern, GScanContext *context) +{ + /* TODO */ } diff --git a/src/analysis/scan/pattern.h b/src/analysis/scan/pattern.h index 9ea66d3..0e4327d 100644 --- a/src/analysis/scan/pattern.h +++ b/src/analysis/scan/pattern.h @@ -30,9 +30,14 @@ #include "../../arch/archbase.h" #include "../../arch/vmpa.h" +#include "../../common/szstr.h" +/* Depuis context.h: contexte de suivi d'une analyse en cours (instance) */ +typedef struct _GScanContext GScanContext; +; + #define G_TYPE_SEARCH_PATTERN g_search_pattern_get_type() #define G_SEARCH_PATTERN(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SEARCH_PATTERN, GSearchPattern)) #define G_IS_SEARCH_PATTERN(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SEARCH_PATTERN)) @@ -57,8 +62,17 @@ const char *g_search_pattern_get_name(const GSearchPattern *); /* Inscrit la désignation attribuée à un motif de recherche. */ void g_search_pattern_set_name(GSearchPattern *, const char *, size_t); -/* Décompte le nombre de correspondances identifiées. */ -size_t g_search_pattern_count_matchs(const GSearchPattern *); +/* Affiche un motif de recherche au format texte. */ +void g_search_pattern_output_to_text(const GSearchPattern *, GScanContext *, int); + +/* Convertit un motif de recherche en texte. */ +void g_search_pattern_convert_as_text(const GSearchPattern *, GScanContext *); + +/* Affiche un motif de recherche au format JSON. */ +void g_search_pattern_output_to_json(const GSearchPattern *, GScanContext *, const sized_string_t *, unsigned int, int, bool); + +/* Convertit un motif de recherche en JSON. */ +void g_search_pattern_convert_as_json(const GSearchPattern *, GScanContext *); diff --git a/src/analysis/scan/patterns/Makefile.am b/src/analysis/scan/patterns/Makefile.am index 4082275..c3d0994 100644 --- a/src/analysis/scan/patterns/Makefile.am +++ b/src/analysis/scan/patterns/Makefile.am @@ -5,14 +5,17 @@ noinst_LTLIBRARIES = libanalysisscanpatterns.la libanalysisscanpatterns_la_SOURCES = \ backend-int.h \ backend.h backend.c \ + modifier-int.h \ + modifier.h modifier.c \ token-int.h \ token.h token.c libanalysisscanpatterns_la_LIBADD = \ backends/libanalysisscanpatternsbackends.la \ + modifiers/libanalysisscanpatternsmodifiers.la \ tokens/libanalysisscanpatternstokens.la -libanalysisscanpatterns_la_CFLAGS = $(LIBGOBJ_CFLAGS) +libanalysisscanpatterns_la_CFLAGS = $(LIBGOBJ_CFLAGS) $(LIBPYTHON_INTERPRETER_CFLAGS) devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%) @@ -20,4 +23,4 @@ devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%) dev_HEADERS = $(libanalysisscanpatterns_la_SOURCES:%c=) -SUBDIRS = backends tokens +SUBDIRS = backends modifiers tokens diff --git a/src/analysis/scan/patterns/modifier-int.h b/src/analysis/scan/patterns/modifier-int.h new file mode 100644 index 0000000..246c139 --- /dev/null +++ b/src/analysis/scan/patterns/modifier-int.h @@ -0,0 +1,59 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * modifier-int.h - prototypes internes pour la modification d'une séquence d'octets pour un motif recherché + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_MODIFIER_INT_H +#define _ANALYSIS_SCAN_MODIFIER_INT_H + + +#include "modifier.h" + + + +/* Fournit le nom d'appel d'un modificateur pour motif. */ +typedef char * (* get_scan_modifier_name_fc) (const GScanTokenModifier *); + +/* Transforme une séquence d'octets pour motif de recherche. */ +typedef bool (* transform_scan_token_fc) (const GScanTokenModifier *, const sized_binary_t *, sized_binary_t **, size_t *); + + +/* Transformation d'une séquence d'octets en une ou plusieurs autres formes (instance) */ +struct _GScanTokenModifier +{ + GObject parent; /* A laisser en premier */ + +}; + +/* Transformation d'une séquence d'octets en une ou plusieurs autres formes (classe) */ +struct _GScanTokenModifierClass +{ + GObjectClass parent; /* A laisser en premier */ + + get_scan_modifier_name_fc get_name; /* Fourniture du nom d'appel */ + + transform_scan_token_fc transform; /* Opération de transformation */ + +}; + + + +#endif /* _ANALYSIS_SCAN_MODIFIER_INT_H */ diff --git a/src/analysis/scan/patterns/modifier.c b/src/analysis/scan/patterns/modifier.c new file mode 100644 index 0000000..77d8bfd --- /dev/null +++ b/src/analysis/scan/patterns/modifier.c @@ -0,0 +1,181 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * modifier.c - modification d'une séquence d'octets pour un motif recherché + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "modifier.h" + + +#include "modifier-int.h" + + + +/* Initialise la classe des transformations d'octets. */ +static void g_scan_token_modifier_class_init(GScanTokenModifierClass *); + +/* Initialise une instance de transformation d'octets. */ +static void g_scan_token_modifier_init(GScanTokenModifier *); + +/* Supprime toutes les références externes. */ +static void g_scan_token_modifier_dispose(GScanTokenModifier *); + +/* Procède à la libération totale de la mémoire. */ +static void g_scan_token_modifier_finalize(GScanTokenModifier *); + + + +/* Indique le type défini pour une transformation d'une séquence d'octets. */ +G_DEFINE_TYPE(GScanTokenModifier, g_scan_token_modifier, G_TYPE_OBJECT); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des transformations d'octets. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_modifier_class_init(GScanTokenModifierClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_token_modifier_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_token_modifier_finalize; + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = instance à initialiser. * +* * +* Description : Initialise une instance de transformation d'octets. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_modifier_init(GScanTokenModifier *modifier) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_modifier_dispose(GScanTokenModifier *modifier) +{ + G_OBJECT_CLASS(g_scan_token_modifier_parent_class)->dispose(G_OBJECT(modifier)); + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_modifier_finalize(GScanTokenModifier *modifier) +{ + G_OBJECT_CLASS(g_scan_token_modifier_parent_class)->finalize(G_OBJECT(modifier)); + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = modificateur à consulter. * +* * +* Description : Fournit le nom d'appel d'un modificateur pour motif. * +* * +* Retour : Désignation humaine. * +* * +* Remarques : - * +* * +******************************************************************************/ + +char *g_scan_token_modifier_get_name(const GScanTokenModifier *modifier) +{ + char *result; /* Désignation à retourner */ + GScanTokenModifierClass *class; /* Classe à activer */ + + class = G_SCAN_TOKEN_MODIFIER_GET_CLASS(modifier); + + result = class->get_name(modifier); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = modificateur à solliciter. * +* src = séquence d'octets à traiter. * +* dest = nouvelle(s) séquence(s) d'octets obtenue(s) [OUT] * +* count = quantité de ces séquences. * +* * +* Description : Transforme une séquence d'octets pour motif de recherche. * +* * +* Retour : Bilan de l'opération : succès ou échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_scan_token_modifier_transform(const GScanTokenModifier *modifier, const sized_binary_t *src, sized_binary_t **dest, size_t *count) +{ + bool result; /* Bilan d'opération à renvoyer*/ + GScanTokenModifierClass *class; /* Classe à activer */ + + class = G_SCAN_TOKEN_MODIFIER_GET_CLASS(modifier); + + result = class->transform(modifier, src, dest, count); + + return result; + +} diff --git a/src/analysis/scan/patterns/modifier.h b/src/analysis/scan/patterns/modifier.h new file mode 100644 index 0000000..a195ca8 --- /dev/null +++ b/src/analysis/scan/patterns/modifier.h @@ -0,0 +1,62 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * modifier.h - prototypes pour la modification d'une séquence d'octets pour un motif recherché + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_MODIFIER_H +#define _ANALYSIS_SCAN_MODIFIER_H + + +#include <glib-object.h> +#include <stdbool.h> + + +#include "../../../common/szstr.h" + + + +#define G_TYPE_SCAN_TOKEN_MODIFIER g_scan_token_modifier_get_type() +#define G_SCAN_TOKEN_MODIFIER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_TOKEN_MODIFIER, GScanTokenModifier)) +#define G_IS_SCAN_TOKEN_MODIFIER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_TOKEN_MODIFIER)) +#define G_SCAN_TOKEN_MODIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_TOKEN_MODIFIER, GScanTokenModifierClass)) +#define G_IS_SCAN_TOKEN_MODIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_TOKEN_MODIFIER)) +#define G_SCAN_TOKEN_MODIFIER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_TOKEN_MODIFIER, GScanTokenModifierClass)) + + +/* Transformation d'une séquence d'octets en une ou plusieurs autres formes (instance) */ +typedef struct _GScanTokenModifier GScanTokenModifier; + +/* Transformation d'une séquence d'octets en une ou plusieurs autres formes (classe) */ +typedef struct _GScanTokenModifierClass GScanTokenModifierClass; + + +/* Indique le type défini pour une transformation d'une séquence d'octets. */ +GType g_scan_token_modifier_get_type(void); + +/* Fournit le nom d'appel d'un modificateur pour motif. */ +char *g_scan_token_modifier_get_name(const GScanTokenModifier *); + +/* Transforme une séquence d'octets pour motif de recherche. */ +bool g_scan_token_modifier_transform(const GScanTokenModifier *, const sized_binary_t *, sized_binary_t **, size_t *); + + + +#endif /* _ANALYSIS_SCAN_MODIFIER_H */ diff --git a/src/analysis/scan/patterns/modifiers/Makefile.am b/src/analysis/scan/patterns/modifiers/Makefile.am new file mode 100644 index 0000000..fe5263c --- /dev/null +++ b/src/analysis/scan/patterns/modifiers/Makefile.am @@ -0,0 +1,17 @@ + +noinst_LTLIBRARIES = libanalysisscanpatternsmodifiers.la + + +libanalysisscanpatternsmodifiers_la_SOURCES = \ + hex.h hex.c \ + list-int.h \ + list.h list.c \ + plain.h plain.c \ + rev.h rev.c + +libanalysisscanpatternsmodifiers_la_CFLAGS = $(LIBGOBJ_CFLAGS) + + +devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%) + +dev_HEADERS = $(libanalysisscanpatternsmodifiers_la_SOURCES:%c=) diff --git a/src/analysis/scan/patterns/modifiers/hex.c b/src/analysis/scan/patterns/modifiers/hex.c new file mode 100644 index 0000000..cf1583c --- /dev/null +++ b/src/analysis/scan/patterns/modifiers/hex.c @@ -0,0 +1,252 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * hex.c - transformation en version hexadécimale d'une séquence d'octets + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "hex.h" + + +#include <malloc.h> +#include <string.h> + + +#include "../modifier-int.h" + + + +/* ----------------------- RECHERCHE D'UN MOTIF DE TEXTE BRUT ----------------------- */ + + +/* Initialise la classe des transformations en hexadécimal. */ +static void g_scan_hex_modifier_class_init(GScanHexModifierClass *klass); + +/* Initialise une instance de transformation en hexadécimal. */ +static void g_scan_hex_modifier_init(GScanHexModifier *); + +/* Supprime toutes les références externes. */ +static void g_scan_hex_modifier_dispose(GScanHexModifier *); + +/* Procède à la libération totale de la mémoire. */ +static void g_scan_hex_modifier_finalize(GScanHexModifier *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Fournit le nom d'appel d'un modificateur pour motif. */ +static char *g_scan_hex_modifier_get_name(const GScanHexModifier *); + +/* Transforme une séquence d'octets pour motif de recherche. */ +static bool g_scan_hex_modifier_transform(const GScanHexModifier *, const sized_binary_t *, sized_binary_t **, size_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* RECHERCHE D'UN MOTIF DE TEXTE BRUT */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour une transformation d'une séquence d'octets dans sa version hexadécimale. */ +G_DEFINE_TYPE(GScanHexModifier, g_scan_hex_modifier, G_TYPE_SCAN_TOKEN_MODIFIER); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des transformations en hexadécimal. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_hex_modifier_class_init(GScanHexModifierClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GScanTokenModifierClass *modifier; /* Version de classe parente */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_hex_modifier_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_hex_modifier_finalize; + + modifier = G_SCAN_TOKEN_MODIFIER_CLASS(klass); + + modifier->get_name = (get_scan_modifier_name_fc)g_scan_hex_modifier_get_name; + + modifier->transform = (transform_scan_token_fc)g_scan_hex_modifier_transform; + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = instance à initialiser. * +* * +* Description : Initialise une instance de transformation en hexadécimal. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_hex_modifier_init(GScanHexModifier *modifier) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_hex_modifier_dispose(GScanHexModifier *modifier) +{ + G_OBJECT_CLASS(g_scan_hex_modifier_parent_class)->dispose(G_OBJECT(modifier)); + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_hex_modifier_finalize(GScanHexModifier *modifier) +{ + G_OBJECT_CLASS(g_scan_hex_modifier_parent_class)->finalize(G_OBJECT(modifier)); + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Construit un modificateur fournistant une vue hexadécimale. * +* * +* Retour : Mécanisme mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GScanTokenModifier *g_scan_hex_modifier_new(void) +{ + GScanTokenModifier *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_SCAN_HEX_MODIFIER, NULL); + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : modifier = modificateur à consulter. * +* * +* Description : Fournit le nom d'appel d'un modificateur pour motif. * +* * +* Retour : Désignation humaine. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static char *g_scan_hex_modifier_get_name(const GScanHexModifier *modifier) +{ + char *result; /* Désignation à retourner */ + + result = strdup("hex"); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = modificateur à solliciter. * +* src = séquence d'octets à traiter. * +* dest = nouvelle(s) séquence(s) d'octets obtenue(s) [OUT] * +* count = quantité de ces séquences. * +* * +* Description : Transforme une séquence d'octets pour motif de recherche. * +* * +* Retour : Bilan de l'opération : succès ou échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_scan_hex_modifier_transform(const GScanHexModifier *modifier, const sized_binary_t *src, sized_binary_t **dest, size_t *count) +{ + bool result; /* Bilan d'opération à renvoyer*/ + sized_binary_t *binary; /* Raccourci vers le stockage */ + size_t i; /* Boucle de parcours */ + + static char *alphabet = "0123456789abcdef"; + + result = true; + + *dest = malloc(1 * sizeof(sized_binary_t)); + *count = 1; + + binary = &(*dest)[0]; + + binary->len = src->len * 2; + binary->data = malloc(binary->len); + + for (i = 0; i < src->len; i++) + { + binary->data[i * 2 + 0] = alphabet[src->data[i] >> 4]; + binary->data[i * 2 + 1] = alphabet[src->data[i] & 0xf]; + } + + return result; + +} diff --git a/src/analysis/scan/patterns/modifiers/hex.h b/src/analysis/scan/patterns/modifiers/hex.h new file mode 100644 index 0000000..1a9b410 --- /dev/null +++ b/src/analysis/scan/patterns/modifiers/hex.h @@ -0,0 +1,58 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * hex.h - prototypes pour la transformation en version hexadécimale d'une séquence d'octets + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_MODIFIERS_HEX_H +#define _ANALYSIS_SCAN_PATTERNS_MODIFIERS_HEX_H + + +#include <glib-object.h> + + +#include "../modifier.h" + + + +#define G_TYPE_SCAN_HEX_MODIFIER g_scan_hex_modifier_get_type() +#define G_SCAN_HEX_MODIFIER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_HEX_MODIFIER, GScanHexModifier)) +#define G_IS_SCAN_HEX_MODIFIER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_HEX_MODIFIER)) +#define G_SCAN_HEX_MODIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_HEX_MODIFIER, GScanHexModifierClass)) +#define G_IS_SCAN_HEX_MODIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_HEX_MODIFIER)) +#define G_SCAN_HEX_MODIFIER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_HEX_MODIFIER, GScanHexModifierClass)) + + +/* Transformation d'une séquence d'octets dans sa version hexadécimale (instance) */ +typedef GScanTokenModifier GScanHexModifier; + +/* Transformation d'une séquence d'octets dans sa version hexadécimale (classe) */ +typedef GScanTokenModifierClass GScanHexModifierClass; + + +/* Indique le type défini pour une transformation d'une séquence d'octets dans sa version hexadécimale. */ +GType g_scan_hex_modifier_get_type(void); + +/* Construit un modificateur fournistant une vue hexadécimale. */ +GScanTokenModifier *g_scan_hex_modifier_new(void); + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_MODIFIERS_HEX_H */ diff --git a/src/analysis/scan/patterns/modifiers/list-int.h b/src/analysis/scan/patterns/modifiers/list-int.h new file mode 100644 index 0000000..c8ed64b --- /dev/null +++ b/src/analysis/scan/patterns/modifiers/list-int.h @@ -0,0 +1,54 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * list-int.h - prototypes internes pour la gestion d'une liste de transformateurs + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_MODIFIERS_LIST_INT_H +#define _ANALYSIS_SCAN_MODIFIERS_LIST_INT_H + + +#include "list.h" + + +#include "../modifier-int.h" + + + +/* Liste de transformations d'une séquence d'octets (instance) */ +struct _GScanModifierList +{ + GObject parent; /* A laisser en premier */ + + GScanTokenModifier **modifiers; /* Liste de transformateurs */ + size_t count; /* Taille de cette liste */ + +}; + +/* Liste de transformations d'une séquence d'octets (classe) */ +struct _GScanModifierListClass +{ + GObjectClass parent; /* A laisser en premier */ + +}; + + + +#endif /* _ANALYSIS_SCAN_MODIFIERS_LIST_INT_H */ diff --git a/src/analysis/scan/patterns/modifiers/list.c b/src/analysis/scan/patterns/modifiers/list.c new file mode 100644 index 0000000..e08d509 --- /dev/null +++ b/src/analysis/scan/patterns/modifiers/list.c @@ -0,0 +1,405 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * list.c - gestion d'une liste de transformateurs + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "list.h" + + +#include <assert.h> +#include <malloc.h> + + +#include "list-int.h" + + + +/* ----------------------- RECHERCHE D'UN MOTIF DE TEXTE BRUT ----------------------- */ + + +/* Initialise la classe des liste de transformations d'octets. */ +static void g_scan_modifier_list_class_init(GScanModifierListClass *); + +/* Initialise une instance de liste de transformations d'octets. */ +static void g_scan_modifier_list_init(GScanModifierList *); + +/* Supprime toutes les références externes. */ +static void g_scan_modifier_list_dispose(GScanModifierList *); + +/* Procède à la libération totale de la mémoire. */ +static void g_scan_modifier_list_finalize(GScanModifierList *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Fournit le nom d'appel d'un modificateur pour motif. */ +static char *g_scan_modifier_list_get_name(const GScanModifierList *); + +/* Transforme une séquence d'octets pour motif de recherche. */ +static bool g_scan_modifier_list_transform(const GScanModifierList *, const sized_binary_t *, sized_binary_t **, size_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* RECHERCHE D'UN MOTIF DE TEXTE BRUT */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour une série de transformations d'octets. */ +G_DEFINE_TYPE(GScanModifierList, g_scan_modifier_list, G_TYPE_OBJECT); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des liste de transformations d'octets. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_modifier_list_class_init(GScanModifierListClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GScanTokenModifierClass *modifier; /* Version de classe parente */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_modifier_list_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_modifier_list_finalize; + + modifier = G_SCAN_TOKEN_MODIFIER_CLASS(klass); + + modifier->get_name = (get_scan_modifier_name_fc)g_scan_modifier_list_get_name; + + modifier->transform = (transform_scan_token_fc)g_scan_modifier_list_transform; + +} + + +/****************************************************************************** +* * +* Paramètres : list = instance à initialiser. * +* * +* Description : Initialise une instance de liste de transformations d'octets.* +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_modifier_list_init(GScanModifierList *list) +{ + list->modifiers = NULL; + list->count = 0; + +} + + +/****************************************************************************** +* * +* Paramètres : list = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_modifier_list_dispose(GScanModifierList *list) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < list->count; i++) + g_clear_object(&list->modifiers[i]); + + G_OBJECT_CLASS(g_scan_modifier_list_parent_class)->dispose(G_OBJECT(list)); + +} + + +/****************************************************************************** +* * +* Paramètres : list = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_modifier_list_finalize(GScanModifierList *list) +{ + if (list->modifiers != NULL) + free(list->modifiers); + + G_OBJECT_CLASS(g_scan_modifier_list_parent_class)->finalize(G_OBJECT(list)); + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Construit une liste de modificateurs d'octets. * +* * +* Retour : Mécanisme mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GScanTokenModifier *g_scan_modifier_list_new(void) +{ + GScanTokenModifier *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_SCAN_MODIFIER_LIST, NULL); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : list = liste de modificateurs à étendre. * +* modifier = modificateur à intégrer. * +* * +* Description : Intègre un nouveau transformateur dans une liste. * +* * +* Retour : Bilan de l'ajout : false si un élément similaire est déjà là.* +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_scan_modifier_list_add(GScanModifierList *list, GScanTokenModifier *modifier) +{ + bool result; /* Bilan à retourner */ + char *name; /* Désignation du modificateur */ + size_t i; /* Boucle de parcours */ + char *other; /* Désignation de ses collègues*/ + + /* Recherche d'une redondance */ + + /** + * Note : deux listes identiques passent sans soucis. + * TODO : comparer les transformateurs ? + */ + + result = true; + + if (!G_IS_SCAN_MODIFIER_LIST(modifier)) + { + name = g_scan_token_modifier_get_name(modifier); + + for (i = 0; i < list->count && result; i++) + { + if (G_IS_SCAN_MODIFIER_LIST(list->modifiers[i])) + continue; + + other = g_scan_token_modifier_get_name(list->modifiers[i]); + + result = (strcmp(name, other) != 0); + + free(other); + + } + + } + + free(name); + + if (!result) + goto done; + + /* Inclusion dans la liste */ + + list->modifiers = realloc(list->modifiers, ++list->count * sizeof(GScanTokenModifier *)); + + list->modifiers[list->count - 1] = modifier; + g_object_ref(G_OBJECT(modifier)); + + done: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : list = série à consulter. * +* * +* Description : Indique le nombre de transformateurs intégrés dans la liste. * +* * +* Retour : Nombre de modificateurs représentés. * +* * +* Remarques : - * +* * +******************************************************************************/ + +size_t g_scan_modifier_list_count(const GScanModifierList *list) +{ + size_t result; /* Quantité à retourner */ + + result = list->count; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : list = série à consulter. * +* index = indice du paramètre à retourner. * +* * +* Description : Fournit un transformateur donné de la liste. * +* * +* Retour : Modificateur inclus dans la liste ou NULL si mauvais indice. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GScanTokenModifier *g_scan_modifier_list_get(const GScanModifierList *list, size_t index) +{ + GScanTokenModifier *result; /* Instance à retourner */ + + assert(index < list->count); + + if (index < list->count) + { + result = list->modifiers[index]; + g_object_ref(G_OBJECT(result)); + } + + else + result = NULL; + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : modifier = modificateur à consulter. * +* * +* Description : Fournit le nom d'appel d'un modificateur pour motif. * +* * +* Retour : Désignation humaine. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static char *g_scan_modifier_list_get_name(const GScanModifierList *modifier) +{ + char *result; /* Désignation à retourner */ + + result = strdup("(list)"); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = modificateur à solliciter. * +* src = séquence d'octets à traiter. * +* dest = nouvelle(s) séquence(s) d'octets obtenue(s) [OUT] * +* count = quantité de ces séquences. * +* * +* Description : Transforme une séquence d'octets pour motif de recherche. * +* * +* Retour : Bilan de l'opération : succès ou échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_scan_modifier_list_transform(const GScanModifierList *modifier, const sized_binary_t *src, sized_binary_t **dest, size_t *count) +{ + bool result; /* Bilan d'opération à renvoyer*/ + size_t i; /* Boucle de parcours #1 */ + sized_binary_t *extra; /* Motifs supplémentaires */ + size_t extra_count; /* Quantité de ces motifs */ + sized_binary_t *new; /* Nouvel emplacement libre */ + size_t k; /* Boucle de parcours #2 */ + + *dest = NULL; + *count = 0; + + for (i = 0; i < modifier->count; i++) + { + result = g_scan_token_modifier_transform(modifier->modifiers[i], src, &extra, &extra_count); + if (!result) goto exit; + + new = (*dest) + *count; + + *count += extra_count; + *dest = realloc(*dest, *count * sizeof(sized_binary_t)); + + for (k = 0; k < extra_count; k++, new++) + copy_szstr(*new, extra[k]); + + free(extra); + + } + + exit: + + if (!result) + { + for (i = 0; i < *count; i++) + exit_szstr(dest[i]); + + if (*dest != NULL) + free(*dest); + + *dest = NULL; + *count = 0; + + } + + return result; + +} diff --git a/src/analysis/scan/patterns/modifiers/list.h b/src/analysis/scan/patterns/modifiers/list.h new file mode 100644 index 0000000..abd1eae --- /dev/null +++ b/src/analysis/scan/patterns/modifiers/list.h @@ -0,0 +1,68 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * list.h - prototypes pour la gestion d'une liste de transformateurs + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_MODIFIERS_LIST_H +#define _ANALYSIS_SCAN_MODIFIERS_LIST_H + + +#include <glib-object.h> +#include <stdbool.h> + + +#include "../modifier.h" + + + +#define G_TYPE_SCAN_MODIFIER_LIST g_scan_modifier_list_get_type() +#define G_SCAN_MODIFIER_LIST(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_MODIFIER_LIST, GScanModifierList)) +#define G_IS_SCAN_MODIFIER_LIST(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_MODIFIER_LIST)) +#define G_SCAN_MODIFIER_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_MODIFIER_LIST, GScanModifierListClass)) +#define G_IS_SCAN_MODIFIER_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_MODIFIER_LIST)) +#define G_SCAN_MODIFIER_LIST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_MODIFIER_LIST, GScanModifierListClass)) + + +/* Liste de transformations d'une séquence d'octets (instance) */ +typedef struct _GScanModifierList GScanModifierList; + +/* Liste de transformations d'une séquence d'octets (classe) */ +typedef struct _GScanModifierListClass GScanModifierListClass; + + +/* Indique le type défini pour une série de transformations d'octets. */ +GType g_scan_modifier_list_get_type(void); + +/* Construit une liste de modificateurs d'octets. */ +GScanTokenModifier *g_scan_modifier_list_new(void); + +/* Intègre un nouveau transformateur dans une liste. */ +bool g_scan_modifier_list_add(GScanModifierList *, GScanTokenModifier *); + +/* Indique le nombre de transformateurs intégrés dans la liste. */ +size_t g_scan_modifier_list_count(const GScanModifierList *); + +/* Fournit un transformateur donné de la liste. */ +GScanTokenModifier *g_scan_modifier_list_get(const GScanModifierList *, size_t); + + + +#endif /* _ANALYSIS_SCAN_MODIFIERS_LIST_H */ diff --git a/src/analysis/scan/patterns/modifiers/plain.c b/src/analysis/scan/patterns/modifiers/plain.c new file mode 100644 index 0000000..5837d46 --- /dev/null +++ b/src/analysis/scan/patterns/modifiers/plain.c @@ -0,0 +1,245 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * plain.c - transmission à l'identique d'une séquence d'octets + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "plain.h" + + +#include <malloc.h> +#include <string.h> + + +#include "../modifier-int.h" + + + +/* ----------------------- RECHERCHE D'UN MOTIF DE TEXTE BRUT ----------------------- */ + + +/* Initialise la classe des transmissions à l'identique. */ +static void g_scan_plain_modifier_class_init(GScanPlainModifierClass *klass); + +/* Initialise une instance de transmission à l'identique. */ +static void g_scan_plain_modifier_init(GScanPlainModifier *); + +/* Supprime toutes les références externes. */ +static void g_scan_plain_modifier_dispose(GScanPlainModifier *); + +/* Procède à la libération totale de la mémoire. */ +static void g_scan_plain_modifier_finalize(GScanPlainModifier *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Fournit le nom d'appel d'un modificateur pour motif. */ +static char *g_scan_plain_modifier_get_name(const GScanPlainModifier *); + +/* Transforme une séquence d'octets pour motif de recherche. */ +static bool g_scan_plain_modifier_transform(const GScanPlainModifier *, const sized_binary_t *, sized_binary_t **, size_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* RECHERCHE D'UN MOTIF DE TEXTE BRUT */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour une transmission à l'identique d'une séquence d'octets. */ +G_DEFINE_TYPE(GScanPlainModifier, g_scan_plain_modifier, G_TYPE_SCAN_TOKEN_MODIFIER); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des transmissions à l'identique. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_plain_modifier_class_init(GScanPlainModifierClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GScanTokenModifierClass *modifier; /* Version de classe parente */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_plain_modifier_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_plain_modifier_finalize; + + modifier = G_SCAN_TOKEN_MODIFIER_CLASS(klass); + + modifier->get_name = (get_scan_modifier_name_fc)g_scan_plain_modifier_get_name; + + modifier->transform = (transform_scan_token_fc)g_scan_plain_modifier_transform; + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = instance à initialiser. * +* * +* Description : Initialise une instance de transmission à l'identique. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_plain_modifier_init(GScanPlainModifier *modifier) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_plain_modifier_dispose(GScanPlainModifier *modifier) +{ + G_OBJECT_CLASS(g_scan_plain_modifier_parent_class)->dispose(G_OBJECT(modifier)); + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_plain_modifier_finalize(GScanPlainModifier *modifier) +{ + G_OBJECT_CLASS(g_scan_plain_modifier_parent_class)->finalize(G_OBJECT(modifier)); + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Construit un modificateur livrant des octets à l'identique. * +* * +* Retour : Mécanisme mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GScanTokenModifier *g_scan_plain_modifier_new(void) +{ + GScanTokenModifier *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_SCAN_PLAIN_MODIFIER, NULL); + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : modifier = modificateur à consulter. * +* * +* Description : Fournit le nom d'appel d'un modificateur pour motif. * +* * +* Retour : Désignation humaine. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static char *g_scan_plain_modifier_get_name(const GScanPlainModifier *modifier) +{ + char *result; /* Désignation à retourner */ + + result = strdup("plain"); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = modificateur à solliciter. * +* src = séquence d'octets à traiter. * +* dest = nouvelle(s) séquence(s) d'octets obtenue(s) [OUT] * +* count = quantité de ces séquences. * +* * +* Description : Transforme une séquence d'octets pour motif de recherche. * +* * +* Retour : Bilan de l'opération : succès ou échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_scan_plain_modifier_transform(const GScanPlainModifier *modifier, const sized_binary_t *src, sized_binary_t **dest, size_t *count) +{ + bool result; /* Bilan d'opération à renvoyer*/ + sized_binary_t *binary; /* Raccourci vers le stockage */ + + result = true; + + *dest = malloc(1 * sizeof(sized_binary_t)); + *count = 1; + + binary = &(*dest)[0]; + + binary->len = src->len; + binary->data = malloc(binary->len); + + memcpy(binary->data, src->data, src->len); + + return result; + +} diff --git a/src/analysis/scan/patterns/modifiers/plain.h b/src/analysis/scan/patterns/modifiers/plain.h new file mode 100644 index 0000000..ecabefd --- /dev/null +++ b/src/analysis/scan/patterns/modifiers/plain.h @@ -0,0 +1,58 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * plain.h - prototypes pour la transmission à l'identique d'une séquence d'octets + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_MODIFIERS_PLAIN_H +#define _ANALYSIS_SCAN_PATTERNS_MODIFIERS_PLAIN_H + + +#include <glib-object.h> + + +#include "../modifier.h" + + + +#define G_TYPE_SCAN_PLAIN_MODIFIER g_scan_plain_modifier_get_type() +#define G_SCAN_PLAIN_MODIFIER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_PLAIN_MODIFIER, GScanPlainModifier)) +#define G_IS_SCAN_PLAIN_MODIFIER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_PLAIN_MODIFIER)) +#define G_SCAN_PLAIN_MODIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_PLAIN_MODIFIER, GScanPlainModifierClass)) +#define G_IS_SCAN_PLAIN_MODIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_PLAIN_MODIFIER)) +#define G_SCAN_PLAIN_MODIFIER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_PLAIN_MODIFIER, GScanPlainModifierClass)) + + +/* Transmission à l'identique d'une séquence d'octets (instance) */ +typedef GScanTokenModifier GScanPlainModifier; + +/* Transmission à l'identique d'une séquence d'octets (classe) */ +typedef GScanTokenModifierClass GScanPlainModifierClass; + + +/* Indique le type défini pour une transmission à l'identique d'une séquence d'octets. */ +GType g_scan_plain_modifier_get_type(void); + +/* Construit un modificateur livrant des octets à l'identique. */ +GScanTokenModifier *g_scan_plain_modifier_new(void); + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_MODIFIERS_PLAIN_H */ diff --git a/src/analysis/scan/patterns/modifiers/rev.c b/src/analysis/scan/patterns/modifiers/rev.c new file mode 100644 index 0000000..d22b549 --- /dev/null +++ b/src/analysis/scan/patterns/modifiers/rev.c @@ -0,0 +1,247 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * rev.c - transormation via inversement d'une séquence d'octets + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "rev.h" + + +#include <malloc.h> +#include <string.h> + + +#include "../modifier-int.h" + + + +/* ----------------------- RECHERCHE D'UN MOTIF DE TEXTE BRUT ----------------------- */ + + +/* Initialise la classe des transmissions via inversement. */ +static void g_scan_reverse_modifier_class_init(GScanReverseModifierClass *klass); + +/* Initialise une instance de transmission via inversement. */ +static void g_scan_reverse_modifier_init(GScanReverseModifier *); + +/* Supprime toutes les références externes. */ +static void g_scan_reverse_modifier_dispose(GScanReverseModifier *); + +/* Procède à la libération totale de la mémoire. */ +static void g_scan_reverse_modifier_finalize(GScanReverseModifier *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Fournit le nom d'appel d'un modificateur pour motif. */ +static char *g_scan_reverse_modifier_get_name(const GScanReverseModifier *); + +/* Transforme une séquence d'octets pour motif de recherche. */ +static bool g_scan_reverse_modifier_transform(const GScanReverseModifier *, const sized_binary_t *, sized_binary_t **, size_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* RECHERCHE D'UN MOTIF DE TEXTE BRUT */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour une transormation via inversement d'une séquence d'octets. */ +G_DEFINE_TYPE(GScanReverseModifier, g_scan_reverse_modifier, G_TYPE_SCAN_TOKEN_MODIFIER); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des transmissions via inversement. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_reverse_modifier_class_init(GScanReverseModifierClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GScanTokenModifierClass *modifier; /* Version de classe parente */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_reverse_modifier_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_reverse_modifier_finalize; + + modifier = G_SCAN_TOKEN_MODIFIER_CLASS(klass); + + modifier->get_name = (get_scan_modifier_name_fc)g_scan_reverse_modifier_get_name; + + modifier->transform = (transform_scan_token_fc)g_scan_reverse_modifier_transform; + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = instance à initialiser. * +* * +* Description : Initialise une instance de transmission via inversement. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_reverse_modifier_init(GScanReverseModifier *modifier) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_reverse_modifier_dispose(GScanReverseModifier *modifier) +{ + G_OBJECT_CLASS(g_scan_reverse_modifier_parent_class)->dispose(G_OBJECT(modifier)); + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_reverse_modifier_finalize(GScanReverseModifier *modifier) +{ + G_OBJECT_CLASS(g_scan_reverse_modifier_parent_class)->finalize(G_OBJECT(modifier)); + +} + + +/****************************************************************************** +* * +* Paramètres : - * +* * +* Description : Construit un modificateur livrant des octets inversés. * +* * +* Retour : Mécanisme mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GScanTokenModifier *g_scan_reverse_modifier_new(void) +{ + GScanTokenModifier *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_SCAN_REVERSE_MODIFIER, NULL); + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : modifier = modificateur à consulter. * +* * +* Description : Fournit le nom d'appel d'un modificateur pour motif. * +* * +* Retour : Désignation humaine. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static char *g_scan_reverse_modifier_get_name(const GScanReverseModifier *modifier) +{ + char *result; /* Désignation à retourner */ + + result = strdup("rev"); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : modifier = modificateur à solliciter. * +* src = séquence d'octets à traiter. * +* dest = nouvelle(s) séquence(s) d'octets obtenue(s) [OUT] * +* count = quantité de ces séquences. * +* * +* Description : Transforme une séquence d'octets pour motif de recherche. * +* * +* Retour : Bilan de l'opération : succès ou échec. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_scan_reverse_modifier_transform(const GScanReverseModifier *modifier, const sized_binary_t *src, sized_binary_t **dest, size_t *count) +{ + bool result; /* Bilan d'opération à renvoyer*/ + sized_binary_t *binary; /* Raccourci vers le stockage */ + size_t i; /* Boucle de parcours */ + + result = true; + + *dest = malloc(1 * sizeof(sized_binary_t)); + *count = 1; + + binary = &(*dest)[0]; + + binary->len = src->len; + binary->data = malloc(binary->len); + + for (i = 0; i < src->len; i++) + binary->data[src->len - i - 1] = src->data[i]; + + return result; + +} diff --git a/src/analysis/scan/patterns/modifiers/rev.h b/src/analysis/scan/patterns/modifiers/rev.h new file mode 100644 index 0000000..5b4e398 --- /dev/null +++ b/src/analysis/scan/patterns/modifiers/rev.h @@ -0,0 +1,58 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * rev.h - prototypes pour la transormation via inversement d'une séquence d'octets + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_MODIFIERS_REV_H +#define _ANALYSIS_SCAN_PATTERNS_MODIFIERS_REV_H + + +#include <glib-object.h> + + +#include "../modifier.h" + + + +#define G_TYPE_SCAN_REVERSE_MODIFIER g_scan_reverse_modifier_get_type() +#define G_SCAN_REVERSE_MODIFIER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_REVERSE_MODIFIER, GScanReverseModifier)) +#define G_IS_SCAN_REVERSE_MODIFIER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_REVERSE_MODIFIER)) +#define G_SCAN_REVERSE_MODIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_REVERSE_MODIFIER, GScanReverseModifierClass)) +#define G_IS_SCAN_REVERSE_MODIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_REVERSE_MODIFIER)) +#define G_SCAN_REVERSE_MODIFIER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_REVERSE_MODIFIER, GScanReverseModifierClass)) + + +/* Transormation via inversement d'une séquence d'octets (instance) */ +typedef GScanTokenModifier GScanReverseModifier; + +/* Transormation via inversement d'une séquence d'octets (classe) */ +typedef GScanTokenModifierClass GScanReverseModifierClass; + + +/* Indique le type défini pour une transormation via inversement d'une séquence d'octets. */ +GType g_scan_reverse_modifier_get_type(void); + +/* Construit un modificateur livrant des octets inversés. */ +GScanTokenModifier *g_scan_reverse_modifier_new(void); + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_MODIFIERS_REV_H */ diff --git a/src/analysis/scan/patterns/token-int.h b/src/analysis/scan/patterns/token-int.h index a9667c9..294a3b1 100644 --- a/src/analysis/scan/patterns/token-int.h +++ b/src/analysis/scan/patterns/token-int.h @@ -44,6 +44,8 @@ struct _GStringToken { GSearchPattern parent; /* A laisser en premier */ + GScanTokenNode *root; /* Motif à rechercher */ + }; /* Encadrement d'une bribe de recherche textuelle (classe) */ @@ -57,5 +59,9 @@ struct _GStringTokenClass }; +/* Met en place un gestionnaire de recherche de binaire. */ +bool g_string_token_create(GStringToken *, GScanTokenNode *); + + #endif /* _ANALYSIS_SCAN_PATTERNS_TOKEN_INT_H */ diff --git a/src/analysis/scan/patterns/token.c b/src/analysis/scan/patterns/token.c index d8a5cbc..cc2d87a 100644 --- a/src/analysis/scan/patterns/token.c +++ b/src/analysis/scan/patterns/token.c @@ -25,12 +25,18 @@ #include <assert.h> +#include <stdio.h> #include "token-int.h" +#include "../../../common/cpp.h" +#include "../../../core/logs.h" +/* ------------------------- CIBLAGE DES SEQUENCES D'OCTETS ------------------------- */ + + /* Initialise la classe des bribes de recherche textuelle. */ static void g_string_token_class_init(GStringTokenClass *); @@ -45,6 +51,22 @@ static void g_string_token_finalize(GStringToken *); +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Affiche un motif de recherche au format texte. */ +static void g_string_token_output_to_text(const GStringToken *, GScanContext *, int); + +/* Affiche un motif de recherche au format JSON. */ +static void g_string_token_output_to_json(const GStringToken *, GScanContext *, const sized_string_t *, unsigned int, int); + + + +/* ---------------------------------------------------------------------------------- */ +/* CIBLAGE DES SEQUENCES D'OCTETS */ +/* ---------------------------------------------------------------------------------- */ + + /* Indique le type défini pour une bribe de recherche textuelle. */ G_DEFINE_TYPE(GStringToken, g_string_token, G_TYPE_SEARCH_PATTERN); @@ -73,9 +95,8 @@ static void g_string_token_class_init(GStringTokenClass *klass) pattern = G_SEARCH_PATTERN_CLASS(klass); - //pattern->prepare = (prepare_pattern_fc)g_string_token_prepare; - //pattern->analyze = (analyze_pattern_fc)g_string_token_analyze; - //pattern->count = (count_pattern_matchs_fc); + pattern->to_text = (output_pattern_to_text_fc)g_string_token_output_to_text; + pattern->to_json = (output_pattern_to_json_fc)g_string_token_output_to_json; } @@ -94,6 +115,7 @@ static void g_string_token_class_init(GStringTokenClass *klass) static void g_string_token_init(GStringToken *token) { + token->root = NULL; } @@ -138,6 +160,33 @@ static void g_string_token_finalize(GStringToken *token) /****************************************************************************** * * +* Paramètres : token = encadrement de motif à initialiser pleinement. * +* root = représentation du motif à recherche. * +* * +* Description : Met en place un gestionnaire de recherche de binaire. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_string_token_create(GStringToken *token, GScanTokenNode *root) +{ + bool result; /* Bilan à retourner */ + + result = true; + + token->root = root; + g_object_ref(G_OBJECT(root)); + + return result; + +} + + +/****************************************************************************** +* * * Paramètres : token = définition de la bribe à enregistrer. * * context = contexte de l'analyse à mener. * * backend = moteur de recherche à préchauffer. * @@ -151,7 +200,7 @@ static void g_string_token_finalize(GStringToken *token) * * ******************************************************************************/ -bool g_string_token_enroll(GStringToken *token, GScanContext *context, GEngineBackend *backend, size_t maxsize) +bool g_string_token_enroll__old(GStringToken *token, GScanContext *context, GEngineBackend *backend, size_t maxsize) { bool result; /* Statut à retourner */ GStringTokenClass *class; /* Classe de l'instance */ @@ -166,6 +215,16 @@ bool g_string_token_enroll(GStringToken *token, GScanContext *context, GEngineBa } +bool g_string_token_enroll(GStringToken *token, GScanContext *context, GEngineBackend *backend, size_t maxsize) +{ + bool result; /* Statut à retourner */ + + result = g_scan_token_node_enroll(token->root, context, backend, maxsize); + + return result; + +} + /****************************************************************************** * * @@ -182,7 +241,7 @@ bool g_string_token_enroll(GStringToken *token, GScanContext *context, GEngineBa * * ******************************************************************************/ -void g_string_token_check(const GStringToken *token, GScanContext *context, GBinContent *content, pending_matches_t *matches) +void g_string_token_check__old(const GStringToken *token, GScanContext *context, GBinContent *content, pending_matches_t *matches) { GStringTokenClass *class; /* Classe de l'instance */ @@ -191,3 +250,114 @@ void g_string_token_check(const GStringToken *token, GScanContext *context, GBin class->check(token, context, content, matches); } + +void g_string_token_check(const GStringToken *token, GScanContext *context, GBinContent *content, pending_matches_t *matches) +{ + g_scan_token_node_check(token->root, context, content, matches, NULL); + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : pattern = définition de motif à considérer. * +* context = contexte de l'analyse à mener. * +* fd = canal d'écriture. * +* * +* Description : Affiche un motif de recherche au format texte. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_string_token_output_to_text(const GStringToken *pattern, GScanContext *context, int fd) +{ + const GScanMatch **matches; /* Correspondances établies */ + size_t count; /* Quantité de cette liste */ + size_t i; /* Boucle de parcours */ + + matches = g_scan_context_get_full_matches(context, G_SEARCH_PATTERN(pattern), &count); + + for (i = 0; i < count; i++) + g_scan_match_output_to_text(matches[i], fd); + +} + + +/****************************************************************************** +* * +* Paramètres : pattern = définition de motif à considérer. * +* context = contexte de l'analyse à mener. * +* padding = éventuel bourrage initial à placer ou NULL. * +* level = profondeur actuelle. * +* fd = canal d'écriture. * +* * +* Description : Affiche un motif de recherche au format JSON. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_string_token_output_to_json(const GStringToken *pattern, GScanContext *context, const sized_string_t *padding, unsigned int level, int fd) +{ + unsigned int i; /* Boucle de parcours #1 */ + const GScanMatch **matches; /* Correspondances établies */ + size_t count; /* Quantité de cette liste */ + char value[ULLONG_MAXLEN]; /* Impression de la position */ + int ret; /* Bilan d'une conversion */ + size_t k; /* Boucle de parcours #2 */ + bool trailing; /* Virgule finale */ + + matches = g_scan_context_get_full_matches(context, G_SEARCH_PATTERN(pattern), &count); + + /* Nombre de correspondances */ + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + write(fd, "\"match_count\": ", 15); + + ret = snprintf(value, ULLONG_MAXLEN, "%zu", count); + + if (ret > 0) + write(fd, value, ret); + + else + { + log_simple_message(LMT_EXT_ERROR, "Error while converting value!"); + write(fd, "null", 4); + } + + write(fd, ",\n", 2); + + /* Détail des correspondances */ + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + write(fd, "\"matches\": [\n", 13); + + for (k = 0; k < count; k++) + { + trailing = ((k + 1) < count); + + g_scan_match_output_to_json(matches[k], padding, level + 1, fd, trailing); + + } + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + write(fd, "]\n", 2); + +} diff --git a/src/analysis/scan/patterns/token.h b/src/analysis/scan/patterns/token.h index c1cb173..879d912 100644 --- a/src/analysis/scan/patterns/token.h +++ b/src/analysis/scan/patterns/token.h @@ -29,6 +29,7 @@ #include "backend.h" +#include "tokens/node.h" #include "../matches/pending.h" diff --git a/src/analysis/scan/patterns/tokens/Makefile.am b/src/analysis/scan/patterns/tokens/Makefile.am index 00cff2a..7fb515f 100644 --- a/src/analysis/scan/patterns/tokens/Makefile.am +++ b/src/analysis/scan/patterns/tokens/Makefile.am @@ -3,11 +3,23 @@ noinst_LTLIBRARIES = libanalysisscanpatternstokens.la libanalysisscanpatternstokens_la_SOURCES = \ + atom.h atom.c \ + hex-int.h \ + hex.h hex.c \ + node-int.h \ + node.h node.c \ + plain-int.h \ plain.h plain.c +libanalysisscanpatternstokens_la_LIBADD = \ + nodes/libanalysisscanpatternstokensnodes.la + libanalysisscanpatternstokens_la_CFLAGS = $(LIBGOBJ_CFLAGS) devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%) dev_HEADERS = $(libanalysisscanpatternstokens_la_SOURCES:%c=) + + +SUBDIRS = nodes diff --git a/src/analysis/scan/patterns/tokens/atom.c b/src/analysis/scan/patterns/tokens/atom.c new file mode 100644 index 0000000..fcb585d --- /dev/null +++ b/src/analysis/scan/patterns/tokens/atom.c @@ -0,0 +1,364 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * atom.c - détermination d'atomes à partir de motifs + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "atom.h" + + +#include <assert.h> +#include <malloc.h> + + + +/** + * Remplacement des fonctions de <ctypes.h> dans support des locales. + */ + +#define IS_CH_LETTER(ch) (('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z')) + +#define MAKE_CH_UPPER(ch) (ch & 0xdf) +#define MAKE_CH_LOWER(ch) (ch | 0x20) + + + +/****************************************************************************** +* * +* Paramètres : ch = octet dont la valeur est à analyser. * +* seen = suivi des octets déjà rencontrés. [OUT] * +* letters = nombre de lettres rencontrées. [OUT] * +* * +* Description : Note l'intêret de rechercher un octet particulier. * +* * +* Retour : Note positive ou négative. * +* * +* Remarques : - * +* * +******************************************************************************/ + +int rate_byte_quality(bin_t ch, bitfield_t *seen, size_t *letters) +{ + int result; /* Note à retourner */ + + switch (ch) + { + case 0x00: + case 0x20: + case 0x90: + case 0xcc: + case 0xff: + result = 12; + break; + + case 'A' ... 'Z': + case 'z' ... 'z': + if (letters == NULL) + result = 20; + else + { + result = 18; + (*letters)++; + } + break; + + default: + result = 20; + break; + + } + + set_in_bit_field(seen, ch, 1); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : seen = suivi des octets déjà rencontrés. * +* max = nombre d'octets considérés à la base. * +* * +* Description : Termine la notation d'un ensemble d'octets. * +* * +* Retour : Note positive ou négative. * +* * +* Remarques : - * +* * +******************************************************************************/ + +int finish_quality_rating(const bitfield_t *seen, size_t max) +{ + int result; /* Note à retourner */ + size_t uniq; /* Quantié d'octets uniques */ + bool bad; /* Indice de mauvaise qualité */ + + uniq = popcount_for_bit_field(seen); + + if (uniq == 1) + { + bad = test_in_bit_field(seen, 0x00) + || test_in_bit_field(seen, 0x20) + || test_in_bit_field(seen, 0x90) + || test_in_bit_field(seen, 0xcc) + || test_in_bit_field(seen, 0xff); + + result = (bad ? -10 * max : 2); + + } + + else + result = uniq * 2; + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : raw = définition de la bribe à enregistrer. * +* maxsize = taille max. des atomes (mise en commun optimisée). * +* atom = informations de suivi constituées. [OUT] * +* letters = nombre de lettres rencontrées. [OUT] * +* * +* Description : Détermine la portion idéale de recherche. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void find_best_atom(const sized_binary_t *raw, size_t maxsize, tracked_scan_atom_t *atom, size_t *letters) +{ + size_t i; /* Boucle de parcours #1 */ + bin_t ch; /* Octets à étudier */ + size_t best_letters; /* Mémorisation de décompte */ + size_t *ptr_letters; /* Pointeur vers le décompte */ + int best_rating; /* Meilleur notation obtenue */ + bitfield_t *seen; /* Mémorise les octets déjà vus*/ + size_t max_loop; /* Limitation des itérations */ + size_t k; /* Boucle de parcours #2 */ + size_t local_letters; /* Décompte courant des lettres*/ + int local_rating; /* Notation courante */ + + /* Si la chaîne fournie est plus petite que la taille d'un atome... */ + if (raw->len <= maxsize) + { + atom->pos = 0; + atom->len = raw->len; + atom->rem = 0; + + if (letters != NULL) + { + *letters = 0; + + for (i = 0; i < raw->len; i++) + { + ch = raw->data[i]; + + if (IS_CH_LETTER(ch)) + (*letters)++; + + } + + } + + } + + /* ... ou si une sélection doit s'opérer */ + else + { + /* Etablissement d'une mesure de référence à la position 0 */ + + atom->pos = 0; + atom->len = maxsize; + + ptr_letters = (letters != NULL ? &best_letters : NULL); + + best_letters = 0; + best_rating = 0; + + seen = create_bit_field(256, false); + + for (k = 0; k < maxsize; k++) + best_rating += rate_byte_quality(raw->data[k], seen, ptr_letters); + + best_rating += finish_quality_rating(seen, maxsize); + + /* Parcours du reste du contenu */ + + max_loop = (raw->len - maxsize); + + ptr_letters = (letters != NULL ? &local_letters : NULL); + + for (i = 1; i < max_loop; i++) + { + local_letters = 0; + local_rating = 0; + + reset_all_in_bit_field(seen); + + for (k = 0; k < maxsize; k++) + local_rating += rate_byte_quality(raw->data[i + k], seen, ptr_letters); + + local_rating += finish_quality_rating(seen, maxsize); + + if (local_rating > best_rating) + { + atom->pos = i; + + best_letters = local_letters; + best_rating = local_rating; + + } + + } + + /* Conclusion */ + + delete_bit_field(seen); + + atom->rem = raw->len - atom->pos - maxsize; + + if (letters != NULL) + *letters = best_letters; + + } + +} + + +/****************************************************************************** +* * +* Paramètres : src = chaîne ed référence à dupliquer. * +* count = nombre de lettres présentes. * +* * +* Description : Etablit la liste des cas de figures ignorant la casse. * +* * +* Retour : Liste de toutes les combinaisons possibles. * +* * +* Remarques : - * +* * +******************************************************************************/ + +sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *src, size_t count) +{ + sized_binary_t *result; /* Liste à retourner */ + size_t i; /* Boucle de parcours #1 */ + size_t replaced; /* 2^(alternatives créées) */ +#ifndef NDEBUG + size_t check; /* Validation du compte max. */ +#endif + bin_t ch; /* Octet à recopier */ + size_t k; /* Boucle de parcours #2 */ + size_t divisor; /* Taille de la découpe */ + size_t quotient; /* Reste de la position */ + + count *= 2; + + /* Création du réceptacle */ + + result = malloc(count * sizeof(tracked_scan_atom_t)); + + for (i = 0; i < count; i++) + { + result[i].data = malloc(src->len); + result[i].len = src->len; + } + + /* Remplissage */ + + replaced = 2; + +#ifndef NDEBUG + check = 1; +#endif + + for (i = 0; i < src->len; i++) + { + ch = src->data[i]; + + if (IS_CH_LETTER(ch)) + { + for (k = 0; k < count; k++) + { + divisor = count / replaced; + quotient = k / divisor; + + if ((quotient % 2) == 0) + result[k].data[i] = MAKE_CH_UPPER(ch); + else + result[k].data[i] = MAKE_CH_LOWER(ch); + + } + + replaced *= 2; + +#ifndef NDEBUG + check++; + assert((check - 1) <= count); +#endif + + } + else + for (k = 0; k < count; k++) + result[k].data[i] = ch; + + } + + assert((check - 1) == count); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : raw = définition de la bribe à enregistrer. * +* context = contexte de l'analyse à mener. * +* backend = moteur de recherche à préchauffer. * +* atom = informations de suivi constituées. [OUT] * +* * +* Description : Enregistre l'atome déterminé d'une série d'octets. * +* * +* Retour : Bilan de l'opération à renvoyer. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool enroll_prepared_atom(const sized_binary_t *raw, GScanContext *context, GEngineBackend *backend, tracked_scan_atom_t *atom) +{ + bool result; /* Statut à retourner */ + const bin_t *data; /* Données à rechercher */ + + data = raw->data + atom->pos; + + atom->pid = g_engine_backend_enroll_plain_pattern(backend, context, data, atom->len); + + result = (atom->pid != INVALID_PATTERN_ID); + + return result; + +} diff --git a/src/analysis/scan/patterns/tokens/atom.h b/src/analysis/scan/patterns/tokens/atom.h new file mode 100644 index 0000000..daa1f16 --- /dev/null +++ b/src/analysis/scan/patterns/tokens/atom.h @@ -0,0 +1,68 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * atom.h - prototypes pour la détermination d'atomes à partir de motifs + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_TOKENS_ATOM_H +#define _ANALYSIS_SCAN_PATTERNS_TOKENS_ATOM_H + + +#include <stdbool.h> + + +#include "../backend.h" +#include "../../context.h" +#include "../../../../arch/vmpa.h" +#include "../../../../common/bits.h" +#include "../../../../common/szstr.h" + + + +/* Suivi des motifs réellement recherchés */ +typedef struct _tracked_scan_atom_t +{ + phys_t pos; /* Début de sélection atomique */ + phys_t len; /* Taille de ladite sélection */ + phys_t rem; /* Reste après l'atome */ + + patid_t pid; /* Identifiant de la bribe */ + +} tracked_scan_atom_t; + + +/* Note l'intêret de rechercher un octet particulier. */ +int rate_byte_quality(bin_t, bitfield_t *, size_t *); + +/* Termine la notation d'un ensemble d'octets. */ +int finish_quality_rating(const bitfield_t *, size_t); + +/* Détermine la portion idéale de recherche. */ +void find_best_atom(const sized_binary_t *, size_t , tracked_scan_atom_t *, size_t *); + +/* Etablit la liste des cas de figures ignorant la casse. */ +sized_binary_t *make_atoms_case_insensitive(const sized_binary_t *, size_t); + +/* Enregistre l'atome déterminé d'une série d'octets. */ +bool enroll_prepared_atom(const sized_binary_t *, GScanContext *, GEngineBackend *, tracked_scan_atom_t *); + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_TOKENS_ATOM_H */ diff --git a/src/analysis/scan/patterns/tokens/hex-int.h b/src/analysis/scan/patterns/tokens/hex-int.h new file mode 100644 index 0000000..f0460c8 --- /dev/null +++ b/src/analysis/scan/patterns/tokens/hex-int.h @@ -0,0 +1,56 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * hex-int.h - prototypes internes pour la recherche de morceaux de binaire + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_TOKENS_HEX_INT_H +#define _ANALYSIS_SCAN_PATTERNS_TOKENS_HEX_INT_H + + +#include "hex.h" + + +#include "atom.h" +#include "../token-int.h" + + + +/* Encadrement d'une recherche de morceaux de binaire (instance) */ +struct _GScanHexBytes +{ + GStringToken parent; /* A laisser en premier */ + +}; + +/* Encadrement d'une recherche de morceaux de binaire (classe) */ +struct _GScanHexBytesClass +{ + GStringTokenClass parent; /* A laisser en premier */ + +}; + + +/* Met en place un gestionnaire de recherche de binaire. */ +bool g_scan_hex_bytes_create(GScanHexBytes *, GScanTokenNode *); + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_TOKENS_HEX_INT_H */ diff --git a/src/analysis/scan/patterns/tokens/hex.c b/src/analysis/scan/patterns/tokens/hex.c new file mode 100644 index 0000000..c1cdbdf --- /dev/null +++ b/src/analysis/scan/patterns/tokens/hex.c @@ -0,0 +1,457 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * hex.c - recherche de morceaux de binaire + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "hex.h" + + +#include <malloc.h> +#include <string.h> + + +#include "hex-int.h" + + + +/* ----------------------- RECHERCHE D'UN MOTIF DE TEXTE BRUT ----------------------- */ + + +/* Initialise la classe des recherches de texte brut. */ +static void g_scan_hex_bytes_class_init(GScanHexBytesClass *klass); + +/* Initialise une instance de recherche de texte brut. */ +static void g_scan_hex_bytes_init(GScanHexBytes *); + +/* Supprime toutes les références externes. */ +static void g_scan_hex_bytes_dispose(GScanHexBytes *); + +/* Procède à la libération totale de la mémoire. */ +static void g_scan_hex_bytes_finalize(GScanHexBytes *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Affiche un motif de recherche au format texte. */ +static void g_scan_hex_bytes_output_to_text(const GScanHexBytes *, GScanContext *, int); + +/* Affiche un motif de recherche au format JSON. */ +static void g_scan_hex_bytes_output_to_json(const GScanHexBytes *, GScanContext *, const sized_string_t *, unsigned int, int); + +/* Inscrit la définition d'un motif dans un moteur de recherche. */ +//static bool g_scan_hex_bytes_enroll(GScanHexBytes *, GScanContext *, GEngineBackend *, size_t); + +/* Transforme les correspondances locales en trouvailles. */ +//static void g_scan_hex_bytes_check(const GScanHexBytes *, GScanContext *, GBinContent *, pending_matches_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* RECHERCHE D'UN MOTIF DE TEXTE BRUT */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour une suite d'octets à retrouver dans un binaire. */ +G_DEFINE_TYPE(GScanHexBytes, g_scan_hex_bytes, G_TYPE_STRING_TOKEN); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des recherches de texte brut. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_hex_bytes_class_init(GScanHexBytesClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GSearchPatternClass *pattern; /* Version de classe ancêtre */ + GStringTokenClass *token; /* Version de classe parente */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_hex_bytes_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_hex_bytes_finalize; + + pattern = G_SEARCH_PATTERN_CLASS(klass); + + pattern->to_text = (output_pattern_to_text_fc)g_scan_hex_bytes_output_to_text; + pattern->to_json = (output_pattern_to_json_fc)g_scan_hex_bytes_output_to_json; + + token = G_STRING_TOKEN_CLASS(klass); + + //token->enroll = (enroll_token_fc)g_scan_hex_bytes_enroll; + //token->check = (check_token_fc)g_scan_hex_bytes_check; + +} + + +/****************************************************************************** +* * +* Paramètres : bytes = instance à initialiser. * +* * +* Description : Initialise une instance de recherche de texte brut. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_hex_bytes_init(GScanHexBytes *bytes) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : bytes = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_hex_bytes_dispose(GScanHexBytes *bytes) +{ + G_OBJECT_CLASS(g_scan_hex_bytes_parent_class)->dispose(G_OBJECT(bytes)); + +} + + +/****************************************************************************** +* * +* Paramètres : bytes = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_hex_bytes_finalize(GScanHexBytes *bytes) +{ + G_OBJECT_CLASS(g_scan_hex_bytes_parent_class)->finalize(G_OBJECT(bytes)); + +} + + +/****************************************************************************** +* * +* Paramètres : root = représentation du motif à recherche. * +* * +* Description : Construit un gestionnaire de recherche de texte brut. * +* * +* Retour : Mécanismes mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GSearchPattern *g_scan_hex_bytes_new(GScanTokenNode *root) +{ + GSearchPattern *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_SCAN_HEX_BYTES, NULL); + + if (!g_scan_hex_bytes_create(G_SCAN_HEX_BYTES(result), root)) + g_clear_object(&result); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : bytes = encadrement de motif à initialiser pleinement. * +* root = représentation du motif à recherche. * +* * +* Description : Met en place un gestionnaire de recherche de binaire. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_scan_hex_bytes_create(GScanHexBytes *bytes, GScanTokenNode *root) +{ + bool result; /* Bilan à retourner */ + + result = g_string_token_create(G_STRING_TOKEN(bytes), root); + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : pattern = définition de motif à considérer. * +* context = contexte de l'analyse à mener. * +* fd = canal d'écriture. * +* * +* Description : Affiche un motif de recherche au format texte. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_hex_bytes_output_to_text(const GScanHexBytes *pattern, GScanContext *context, int fd) +{ + G_SEARCH_PATTERN_CLASS(g_scan_hex_bytes_parent_class)->to_text(G_SEARCH_PATTERN(pattern), context, fd); + +} + + +/****************************************************************************** +* * +* Paramètres : pattern = définition de motif à considérer. * +* context = contexte de l'analyse à mener. * +* padding = éventuel bourrage initial à placer ou NULL. * +* level = profondeur actuelle. * +* fd = canal d'écriture. * +* * +* Description : Affiche un motif de recherche au format JSON. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_hex_bytes_output_to_json(const GScanHexBytes *pattern, GScanContext *context, const sized_string_t *padding, unsigned int level, int fd) +{ + G_SEARCH_PATTERN_CLASS(g_scan_hex_bytes_parent_class)->to_json(G_SEARCH_PATTERN(pattern), context, padding, level, fd); + + /* TODO */ + +} + +#if 0 + +/****************************************************************************** +* * +* Paramètres : bytes = définition de la bribe à enregistrer. * +* context = contexte de l'analyse à mener. * +* backend = moteur de recherche à préchauffer. * +* maxsize = taille max. des atomes (mise en commun optimisée). * +* * +* Description : Inscrit la définition d'un motif dans un moteur de recherche.* +* * +* Retour : Bilan de l'opération à renvoyer. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_scan_hex_bytes_enroll(GScanHexBytes *bytes, GScanContext *context, GEngineBackend *backend, size_t maxsize) +{ + bool result; /* Statut à retourner */ + size_t i; /* Boucle de parcours #1 */ + tracked_scan_atom_t atom; /* Atome identifié */ + size_t letters; /* Nombre de lettres présentes */ + size_t k; /* Boucle de parcours #2 */ + size_t extra_count; /* Quantité pour l'exhaustivité*/ + sized_binary_t *extra; /* Couverture supplémntaire */ + size_t remaining; /* Quantité restant à traiter */ + + /* Génération d'une base de chaînes à couvrir */ + + if (bytes->modifier == NULL) + { + bytes->raw = malloc(sizeof(sized_binary_t)); + bytes->count = 1; + + szstrdup(&bytes[0].raw[0], &bytes->orig); + + result = true; + + } + else + result = g_scan_token_modifier_transform(bytes->modifier, &bytes->orig, &bytes->raw, &bytes->count); + + if (!result) + goto exit; + + /* Préparation pour la mémorisation des atomes */ + + bytes->atoms = malloc(bytes->count * sizeof(tracked_scan_atom_t)); + + /* Recherche des atomes */ + + for (i = 0; i < bytes->count; i++) + { + if (bytes->flags & SPBF_CASE_INSENSITIVE) + { + find_best_atom(&bytes->raw[i], maxsize, &atom, &letters); + + if (letters == 0) + bytes->atoms[i] = atom; + + /* Insertion des combinaisons pour couvrir toutes les casses */ + else + { + for (k = 0, extra_count = 1; k < letters; k++, extra_count *= 2) + ; + + extra = make_atoms_case_insensitive(&bytes->raw[i], extra_count); + + remaining = bytes->count - i - 1; + + bytes->count += (extra_count - 1); + + bytes->raw = realloc(bytes->raw, bytes->count * sizeof(sized_binary_t)); + + memmove(&bytes->raw[i + extra_count], &bytes->raw[i + 1], remaining * sizeof(sized_binary_t)); + + for (k = 0; k < extra_count; k++) + bytes->raw[i + k] = extra[k]; + + free(extra); + + bytes->atoms = realloc(bytes->raw, bytes->count * sizeof(tracked_scan_atom_t)); + + for (k = 0; k < extra_count; k++) + bytes->atoms[i + k] = atom; + + i += extra_count - 1; + + } + + } + + else + find_best_atom(&bytes->raw[i], maxsize, &bytes->atoms[i], &letters); + + } + + /* Enregistrements en masse */ + + + for (i = 0; i < bytes->count && result; i++) + result = enroll_prepared_atom(&bytes->raw[i], context, backend, &bytes->atoms[i]); + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : bytes = définition de la bribe à manipuler. * +* context = contexte de l'analyse à mener. * +* content = accès au contenu brut pour vérifications (optim.) * +* matches = suivi des correspondances à consolider. * +* * +* Description : Transforme les correspondances locales en trouvailles. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_hex_bytes_check(const GScanHexBytes *bytes, GScanContext *context, GBinContent *content, pending_matches_t *matches) +{ + size_t i; /* Boucle de parcours #1 */ + const sized_binary_t *raw; /* Données brutes d'origine */ + const tracked_scan_atom_t *atom; /* Atome correspondant */ + size_t count; /* Quantité de bribes trouvées */ + const phys_t *found; /* Localisations des bribes */ + size_t k; /* Boucle de parcours #2 */ + phys_t start; /* Point de départ */ + vmpa2t pos; /* Position dans les données */ + const bin_t *ptr; /* Accès aux données brutes */ + int ret; /* Bilan d'une comparaison */ + + for (i = 0; i < bytes->count; i++) + { + raw = &bytes->raw[i]; + atom = &bytes->atoms[i]; + + found = g_scan_context_get_atom_matches(context, atom->pid, &count); + + for (k = 0; k < count; k++) + { + start = found[k] - atom->pos; + + init_vmpa(&pos, start, VMPA_NO_VIRTUAL); + + /* Validation du contenu avant l'atome */ + + if (atom->pos > 0) + { + ptr = g_binary_content_get_raw_access(content, &pos, atom->pos); + + ret = memcmp(raw->data, ptr, atom->pos); + if (ret != 0) continue; + + } + + /* Validation du contenu après l'atome */ + + if (atom->rem > 0) + { + advance_vmpa(&pos, atom->len); + + ptr = g_binary_content_get_raw_access(content, &pos, atom->rem); + + ret = memcmp(raw->data + atom->pos + atom->len, ptr, atom->rem); + if (ret != 0) continue; + + } + + /* Mémorisation de la correspondance */ + + add_pending_matches(matches, start, raw->len); + + } + + } + +} + +#endif diff --git a/src/analysis/scan/patterns/tokens/hex.h b/src/analysis/scan/patterns/tokens/hex.h new file mode 100644 index 0000000..1db8eb6 --- /dev/null +++ b/src/analysis/scan/patterns/tokens/hex.h @@ -0,0 +1,59 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * hex.h - prototypes pour la recherche de morceaux de binaire + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_TOKENS_HEX_H +#define _ANALYSIS_SCAN_PATTERNS_TOKENS_HEX_H + + +#include <glib-object.h> + + +#include "node.h" +#include "../../pattern.h" + + + +#define G_TYPE_SCAN_HEX_BYTES g_scan_hex_bytes_get_type() +#define G_SCAN_HEX_BYTES(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_HEX_BYTES, GScanHexBytes)) +#define G_IS_SCAN_HEX_BYTES(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_HEX_BYTES)) +#define G_SCAN_HEX_BYTES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_HEX_BYTES, GScanHexBytesClass)) +#define G_IS_SCAN_HEX_BYTES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_HEX_BYTES)) +#define G_SCAN_HEX_BYTES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_HEX_BYTES, GScanHexBytesClass)) + + +/* Encadrement d'une recherche de morceaux de binaire (instance) */ +typedef struct _GScanHexBytes GScanHexBytes; + +/* Encadrement d'une recherche de morceaux de binaire (classe) */ +typedef struct _GScanHexBytesClass GScanHexBytesClass; + + +/* Indique le type défini pour une suite d'octets à retrouver dans un binaire. */ +GType g_scan_hex_bytes_get_type(void); + +/* Construit un gestionnaire de recherche de texte brut. */ +GSearchPattern *g_scan_hex_bytes_new(GScanTokenNode *); + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_TOKENS_HEX_H */ diff --git a/src/analysis/scan/patterns/tokens/node-int.h b/src/analysis/scan/patterns/tokens/node-int.h new file mode 100644 index 0000000..c543cbf --- /dev/null +++ b/src/analysis/scan/patterns/tokens/node-int.h @@ -0,0 +1,58 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * node-int.h - prototypes internes pour la décomposition d'un motif de recherche en atomes assemblés + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_TOKENS_NODE_INT_H +#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODE_INT_H + + +#include "node.h" + + + +/* Inscrit la définition d'un motif dans un moteur de recherche. */ +typedef bool (* enroll_scan_token_node_fc) (GScanTokenNode *, GScanContext *, GEngineBackend *, size_t); + +/* Transforme les correspondances locales en trouvailles. */ +typedef void (* check_scan_token_node_fc) (const GScanTokenNode *, GScanContext *, GBinContent *, pending_matches_t *, const node_search_offset_t *); + + +/* Décomposition d'un motif de recherche en atomes (instance) */ +struct _GScanTokenNode +{ + GObject parent; /* A laisser en premier */ + +}; + +/* Décomposition d'un motif de recherche en atomes (classe) */ +struct _GScanTokenNodeClass +{ + GObjectClass parent; /* A laisser en premier */ + + enroll_scan_token_node_fc enroll; /* Inscription d'un motif */ + check_scan_token_node_fc check; /* Conversion en trouvailles */ + +}; + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODE_INT_H */ diff --git a/src/analysis/scan/patterns/tokens/node.c b/src/analysis/scan/patterns/tokens/node.c new file mode 100644 index 0000000..224328a --- /dev/null +++ b/src/analysis/scan/patterns/tokens/node.c @@ -0,0 +1,195 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * node.c - décomposition d'un motif de recherche en atomes assemblés + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "node.h" + + +#include <assert.h> + + +#include "node-int.h" + + + +/* ------------------------ DECOMPOSITION DE MOTIF RECHERCHE ------------------------ */ + + +/* Initialise la classe des éléments de décomposition. */ +static void g_scan_token_node_class_init(GScanTokenNodeClass *klass); + +/* Initialise une instance d'élément décomposant un motif. */ +static void g_scan_token_node_init(GScanTokenNode *); + +/* Supprime toutes les références externes. */ +static void g_scan_token_node_dispose(GScanTokenNode *); + +/* Procède à la libération totale de la mémoire. */ +static void g_scan_token_node_finalize(GScanTokenNode *); + + + +/* ---------------------------------------------------------------------------------- */ +/* DECOMPOSITION DE MOTIF RECHERCHE */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour un élément décomposant un motif d'octets à rechercher. */ +G_DEFINE_TYPE(GScanTokenNode, g_scan_token_node, G_TYPE_OBJECT); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des éléments de décomposition. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_node_class_init(GScanTokenNodeClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_token_node_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_token_node_finalize; + +} + + +/****************************************************************************** +* * +* Paramètres : node = instance à initialiser. * +* * +* Description : Initialise une instance d'élément décomposant un motif. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_node_init(GScanTokenNode *node) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : node = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_node_dispose(GScanTokenNode *node) +{ + G_OBJECT_CLASS(g_scan_token_node_parent_class)->dispose(G_OBJECT(node)); + +} + + +/****************************************************************************** +* * +* Paramètres : node = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_node_finalize(GScanTokenNode *node) +{ + G_OBJECT_CLASS(g_scan_token_node_parent_class)->finalize(G_OBJECT(node)); + +} + + +/****************************************************************************** +* * +* Paramètres : node = définition de la bribe à enregistrer. * +* context = contexte de l'analyse à mener. * +* backend = moteur de recherche à préchauffer. * +* maxsize = taille max. des atomes (mise en commun optimisée). * +* * +* Description : Inscrit la définition d'un motif dans un moteur de recherche.* +* * +* Retour : Bilan de l'opération à renvoyer. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_scan_token_node_enroll(GScanTokenNode *node, GScanContext *context, GEngineBackend *backend, size_t maxsize) +{ + bool result; /* Statut à retourner */ + GScanTokenNodeClass *class; /* Classe de l'instance */ + + assert(g_engine_backend_get_atom_max_size(backend) == maxsize); + + class = G_SCAN_TOKEN_NODE_GET_CLASS(node); + + result = class->enroll(node, context, backend, maxsize); + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : node = définition de la bribe à manipuler. * +* context = contexte de l'analyse à mener. * +* content = accès au contenu brut pour vérifications (optim.) * +* matches = suivi des correspondances à consolider. * +* offset = tolérance dans les positions à appliquer. * +* * +* Description : Transforme les correspondances locales en trouvailles. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_scan_token_node_check(const GScanTokenNode *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, const node_search_offset_t *offset) +{ + GScanTokenNodeClass *class; /* Classe de l'instance */ + + class = G_SCAN_TOKEN_NODE_GET_CLASS(node); + + class->check(node, context, content, matches, offset); + +} diff --git a/src/analysis/scan/patterns/tokens/node.h b/src/analysis/scan/patterns/tokens/node.h new file mode 100644 index 0000000..4c9eb48 --- /dev/null +++ b/src/analysis/scan/patterns/tokens/node.h @@ -0,0 +1,77 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * node.h - prototypes pour la décomposition d'un motif de recherche en atomes assemblés + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_TOKENS_NODE_H +#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODE_H + + +#include <glib-object.h> +#include <stdbool.h> + + +#include "../backend.h" +#include "../../context.h" +#include "../../matches/pending.h" + + +#define G_TYPE_SCAN_TOKEN_NODE g_scan_token_node_get_type() +#define G_SCAN_TOKEN_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_TOKEN_NODE, GScanTokenNode)) +#define G_IS_SCAN_TOKEN_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_TOKEN_NODE)) +#define G_SCAN_TOKEN_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_TOKEN_NODE, GScanTokenNodeClass)) +#define G_IS_SCAN_TOKEN_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_TOKEN_NODE)) +#define G_SCAN_TOKEN_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_TOKEN_NODE, GScanTokenNodeClass)) + + +/* Décomposition d'un motif de recherche en atomes (instance) */ +typedef struct _GScanTokenNode GScanTokenNode; + +/* Décomposition d'un motif de recherche en atomes (classe) */ +typedef struct _GScanTokenNodeClass GScanTokenNodeClass; + + +/* Indique le type défini pour un élément décomposant un motif d'octets à rechercher. */ +GType g_scan_token_node_get_type(void); + + +// TODO +// validate +// force_plain_registration // set begin/end + + +/* Inscrit la définition d'un motif dans un moteur de recherche. */ +bool g_scan_token_node_enroll(GScanTokenNode *, GScanContext *, GEngineBackend *, size_t); + +/* Mémorisation d'une souplesse dans les positions visées */ +typedef struct _node_search_offset_t +{ + phys_t min; /* Position minimale */ + phys_t max; /* Position maxnimale */ + +} node_search_offset_t; + +/* Transforme les correspondances locales en trouvailles. */ +void g_scan_token_node_check(const GScanTokenNode *, GScanContext *, GBinContent *, pending_matches_t *, const node_search_offset_t *); + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODE_H */ diff --git a/src/analysis/scan/patterns/tokens/nodes/Makefile.am b/src/analysis/scan/patterns/tokens/nodes/Makefile.am new file mode 100644 index 0000000..c20beaf --- /dev/null +++ b/src/analysis/scan/patterns/tokens/nodes/Makefile.am @@ -0,0 +1,16 @@ + +noinst_LTLIBRARIES = libanalysisscanpatternstokensnodes.la + + +libanalysisscanpatternstokensnodes_la_SOURCES = \ + hub-int.h \ + hub.h hub.c \ + plain-int.h \ + plain.h plain.c + +libanalysisscanpatternstokensnodes_la_CFLAGS = $(LIBGOBJ_CFLAGS) + + +devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%) + +dev_HEADERS = $(libanalysisscanpatternstokensnodes_la_SOURCES:%c=) diff --git a/src/analysis/scan/patterns/tokens/nodes/hub-int.h b/src/analysis/scan/patterns/tokens/nodes/hub-int.h new file mode 100644 index 0000000..df05112 --- /dev/null +++ b/src/analysis/scan/patterns/tokens/nodes/hub-int.h @@ -0,0 +1,51 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * hub-int.h - prototypes internes pour un groupe de décompositions de motif de recherche en atomes assemblés + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_HUB_INT_H +#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_HUB_INT_H + + +#include "hub.h" + + +#include "../node-int.h" + + + +/* Groupe de décompositions de motif de recherche en atomes (instance) */ +struct _GScanTokenNodeHub +{ + GScanTokenNode parent; /* A laisser en premier */ + +}; + +/* Groupe de décompositions de motif de recherche en atomes (classe) */ +struct _GScanTokenNodeHubClass +{ + GScanTokenNodeClass parent; /* A laisser en premier */ + +}; + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_HUB_INT_H */ diff --git a/src/analysis/scan/patterns/tokens/nodes/hub.c b/src/analysis/scan/patterns/tokens/nodes/hub.c new file mode 100644 index 0000000..a11531d --- /dev/null +++ b/src/analysis/scan/patterns/tokens/nodes/hub.c @@ -0,0 +1,150 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * hub.c - groupe de décompositions de motif de recherche en atomes assemblés + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "hub.h" + + +#include "hub-int.h" + + + +/* ------------------------ DECOMPOSITION DE MOTIF RECHERCHE ------------------------ */ + + +/* Initialise la classe des groupes de décompositions. */ +static void g_scan_token_node_hub_class_init(GScanTokenNodeHubClass *klass); + +/* Initialise une instance de groupe de décompositions. */ +static void g_scan_token_node_hub_init(GScanTokenNodeHub *); + +/* Supprime toutes les références externes. */ +static void g_scan_token_node_hub_dispose(GScanTokenNodeHub *); + +/* Procède à la libération totale de la mémoire. */ +static void g_scan_token_node_hub_finalize(GScanTokenNodeHub *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + + + + +/* ---------------------------------------------------------------------------------- */ +/* DECOMPOSITION DE MOTIF RECHERCHE */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour un groupe de décompositions de motif d'octets à rechercher. */ +G_DEFINE_TYPE(GScanTokenNodeHub, g_scan_token_node_hub, G_TYPE_SCAN_TOKEN_NODE); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des groupes de décompositions. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_node_hub_class_init(GScanTokenNodeHubClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_token_node_hub_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_token_node_hub_finalize; + +} + + +/****************************************************************************** +* * +* Paramètres : hub = instance à initialiser. * +* * +* Description : Initialise une instance de groupe de décompositions. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_node_hub_init(GScanTokenNodeHub *hub) +{ + +} + + +/****************************************************************************** +* * +* Paramètres : hub = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_node_hub_dispose(GScanTokenNodeHub *hub) +{ + G_OBJECT_CLASS(g_scan_token_node_hub_parent_class)->dispose(G_OBJECT(hub)); + +} + + +/****************************************************************************** +* * +* Paramètres : hub = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_node_hub_finalize(GScanTokenNodeHub *hub) +{ + G_OBJECT_CLASS(g_scan_token_node_hub_parent_class)->finalize(G_OBJECT(hub)); + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + + + diff --git a/src/analysis/scan/patterns/tokens/nodes/hub.h b/src/analysis/scan/patterns/tokens/nodes/hub.h new file mode 100644 index 0000000..b2cb0fc --- /dev/null +++ b/src/analysis/scan/patterns/tokens/nodes/hub.h @@ -0,0 +1,55 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * hub.h - prototypes pour un groupe de décompositions de motif de recherche en atomes assemblés + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_HUB_H +#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_HUB_H + + +#include <glib-object.h> + + +#include "../node.h" + + + +#define G_TYPE_SCAN_TOKEN_NODE_HUB g_scan_token_node_hub_get_type() +#define G_SCAN_TOKEN_NODE_HUB(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_TOKEN_NODE_HUB, GScanTokenNodeHub)) +#define G_IS_SCAN_TOKEN_NODE_HUB(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_TOKEN_NODE_HUB)) +#define G_SCAN_TOKEN_NODE_HUB_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_TOKEN_NODE_HUB, GScanTokenNodeHubClass)) +#define G_IS_SCAN_TOKEN_NODE_HUB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_TOKEN_NODE_HUB)) +#define G_SCAN_TOKEN_NODE_HUB_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_TOKEN_NODE_HUB, GScanTokenNodeHubClass)) + + +/* Groupe de décompositions de motif de recherche en atomes (instance) */ +typedef struct _GScanTokenNodeHub GScanTokenNodeHub; + +/* Groupe de décompositions de motif de recherche en atomes (classe) */ +typedef struct _GScanTokenNodeHubClass GScanTokenNodeHubClass; + + +/* Indique le type défini pour un groupe de décompositions de motif d'octets à rechercher. */ +GType g_scan_token_node_hub_get_type(void); + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_HUB_H */ diff --git a/src/analysis/scan/patterns/tokens/nodes/plain-int.h b/src/analysis/scan/patterns/tokens/nodes/plain-int.h new file mode 100644 index 0000000..a38359d --- /dev/null +++ b/src/analysis/scan/patterns/tokens/nodes/plain-int.h @@ -0,0 +1,64 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * plain-int.h - prototypes internes pour la gestion d'une recherche de motif textuel + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_PLAIN_INT_H +#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_PLAIN_INT_H + + +#include "plain.h" + + +#include "../node-int.h" +#include "../atom.h" + + + +/* Bribe de motif textuelle pour recherches (instance) */ +struct _GScanTokenNodePlain +{ + GScanTokenNode parent; /* A laisser en premier */ + + sized_binary_t orig; /* Motif d'origine avant modifs*/ + GScanTokenModifier *modifier; /* Transformateur pour le motif*/ + ScanPlainNodeFlags flags; /* Fanions associés au motif */ + + sized_binary_t *raw; /* Liste de motifs à couvrir */ + tracked_scan_atom_t *atoms; /* Atomes correspondants */ + size_t count; /* Taille de cette liste */ + +}; + +/* Bribe de motif textuelle pour recherches (instance) */ +struct _GScanTokenNodePlainClass +{ + GScanTokenNodeClass parent; /* A laisser en premier */ + +}; + + +/* Met en place un un noeud représentant un motif textuel. */ +bool g_scan_token_node_plain_create(GScanTokenNodePlain *, const sized_binary_t *, GScanTokenModifier *, ScanPlainNodeFlags); + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_PLAIN_INT_H */ diff --git a/src/analysis/scan/patterns/tokens/nodes/plain.c b/src/analysis/scan/patterns/tokens/nodes/plain.c new file mode 100644 index 0000000..ee87c73 --- /dev/null +++ b/src/analysis/scan/patterns/tokens/nodes/plain.c @@ -0,0 +1,582 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * plain.c - gestion d'une recherche de motif textuel + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#include "plain.h" + + +#include "plain-int.h" + + + +/* ------------------------ DECOMPOSITION DE MOTIF RECHERCHE ------------------------ */ + + +/* Initialise la classe des noeuds pour motif textuel. */ +static void g_scan_token_node_plain_class_init(GScanTokenNodePlainClass *klass); + +/* Initialise une instance de noeud pour motif textuel. */ +static void g_scan_token_node_plain_init(GScanTokenNodePlain *); + +/* Supprime toutes les références externes. */ +static void g_scan_token_node_plain_dispose(GScanTokenNodePlain *); + +/* Procède à la libération totale de la mémoire. */ +static void g_scan_token_node_plain_finalize(GScanTokenNodePlain *); + + + +/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ + + +/* Inscrit la définition d'un motif dans un moteur de recherche. */ +static bool g_scan_token_node_plain_enroll(GScanTokenNodePlain *, GScanContext *, GEngineBackend *, size_t ); + +/* Détermine si un contenu d'intérêt est présent à une position. */ +static bool check_scan_token_node_plain_content(const sized_binary_t *, const tracked_scan_atom_t *, phys_t, GBinContent *); + +/* Transforme les correspondances locales en trouvailles. */ +static void g_scan_plain_bytes_check(const GScanTokenNodePlain *, GScanContext *, GBinContent *, pending_matches_t *, const node_search_offset_t *); + + + +/* ---------------------------------------------------------------------------------- */ +/* DECOMPOSITION DE MOTIF RECHERCHE */ +/* ---------------------------------------------------------------------------------- */ + + +/* Indique le type défini pour un noeud représentant une bribe de texte à retrouver. */ +G_DEFINE_TYPE(GScanTokenNodePlain, g_scan_token_node_plain, G_TYPE_SCAN_TOKEN_NODE); + + +/****************************************************************************** +* * +* Paramètres : klass = classe à initialiser. * +* * +* Description : Initialise la classe des noeuds pour motif textuel. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_node_plain_class_init(GScanTokenNodePlainClass *klass) +{ + GObjectClass *object; /* Autre version de la classe */ + GScanTokenNodeClass *node; /* Version de classe parente */ + + object = G_OBJECT_CLASS(klass); + + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_token_node_plain_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_token_node_plain_finalize; + + node = G_SCAN_TOKEN_NODE_CLASS(klass); + + node->enroll = (enroll_scan_token_node_fc)g_scan_token_node_plain_enroll; + node->check = (check_scan_token_node_fc)g_scan_plain_bytes_check; + +} + + +/****************************************************************************** +* * +* Paramètres : plain = instance à initialiser. * +* * +* Description : Initialise une instance de noeud pour motif textuel. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_node_plain_init(GScanTokenNodePlain *plain) +{ + init_szstr(&plain->orig); + plain->modifier = NULL; + plain->flags = SPNF_NONE; + + plain->raw = NULL; + plain->atoms = NULL; + plain->count = 0; + +} + + +/****************************************************************************** +* * +* Paramètres : plain = instance d'objet GLib à traiter. * +* * +* Description : Supprime toutes les références externes. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_node_plain_dispose(GScanTokenNodePlain *plain) +{ + g_clear_object(&plain->modifier); + + G_OBJECT_CLASS(g_scan_token_node_plain_parent_class)->dispose(G_OBJECT(plain)); + +} + + +/****************************************************************************** +* * +* Paramètres : plain = instance d'objet GLib à traiter. * +* * +* Description : Procède à la libération totale de la mémoire. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_token_node_plain_finalize(GScanTokenNodePlain *plain) +{ + size_t i; /* Boucle de parcours */ + + exit_szstr(&plain->orig); + + for (i = 0; i < plain->count; i++) + exit_szstr(&plain->raw[i]); + + if (plain->raw != NULL) + free(plain->raw); + + if (plain->atoms != NULL) + free(plain->atoms); + + G_OBJECT_CLASS(g_scan_token_node_plain_parent_class)->finalize(G_OBJECT(plain)); + +} + + +/****************************************************************************** +* * +* Paramètres : text = texte brut à rechercher. * +* modifier = transformateur éventuel à solliciter. * +* flags = particularités à prendre en considération. * +* * +* Description : Construit un noeud représentant un motif textuel. * +* * +* Retour : Mécanismes mis en place. * +* * +* Remarques : - * +* * +******************************************************************************/ + +GScanTokenNode *g_scan_token_node_plain_new(const sized_binary_t *text, GScanTokenModifier *modifier, ScanPlainNodeFlags flags) +{ + GScanTokenNode *result; /* Structure à retourner */ + + result = g_object_new(G_TYPE_SCAN_TOKEN_NODE_PLAIN, NULL); + + if (!g_scan_token_node_plain_create(G_SCAN_TOKEN_NODE_PLAIN(result), text, modifier, flags)) + g_clear_object(&result); + + return result; + +} + +/****************************************************************************** +* * +* Paramètres : plain = encadrement de motif à initialiser pleinement. * +* text = texte brut à rechercher. * +* modifier = transformateur éventuel à solliciter. * +* flags = particularités à prendre en considération. * +* * +* Description : Met en place un un noeud représentant un motif textuel. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_scan_token_node_plain_create(GScanTokenNodePlain *plain, const sized_binary_t *text, GScanTokenModifier *modifier, ScanPlainNodeFlags flags) +{ + bool result; /* Bilan à retourner */ + + result = true; + + szstrdup(&plain->orig, text); + + if (modifier != NULL) + { + plain->modifier = modifier; + g_object_ref(G_OBJECT(modifier)); + } + + plain->flags = flags; + + return result; + +} + + + +/* ---------------------------------------------------------------------------------- */ +/* IMPLEMENTATION DES FONCTIONS DE CLASSE */ +/* ---------------------------------------------------------------------------------- */ + + +/****************************************************************************** +* * +* Paramètres : node = définition de la bribe à enregistrer. * +* context = contexte de l'analyse à mener. * +* backend = moteur de recherche à préchauffer. * +* maxsize = taille max. des atomes (mise en commun optimisée). * +* * +* Description : Inscrit la définition d'un motif dans un moteur de recherche.* +* * +* Retour : Bilan de l'opération à renvoyer. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool g_scan_token_node_plain_enroll(GScanTokenNodePlain *node, GScanContext *context, GEngineBackend *backend, size_t maxsize) +{ + bool result; /* Statut à retourner */ + size_t i; /* Boucle de parcours #1 */ + tracked_scan_atom_t atom; /* Atome identifié */ + size_t letters; /* Nombre de lettres présentes */ + size_t k; /* Boucle de parcours #2 */ + size_t extra_count; /* Quantité pour l'exhaustivité*/ + sized_binary_t *extra; /* Couverture supplémntaire */ + size_t remaining; /* Quantité restant à traiter */ + + /* Génération d'une base de chaînes à couvrir */ + + if (node->modifier == NULL) + { + node->raw = malloc(sizeof(sized_binary_t)); + node->count = 1; + + szstrdup(&node->raw[0], &node->orig); + + result = true; + + } + else + result = g_scan_token_modifier_transform(node->modifier, &node->orig, &node->raw, &node->count); + + if (!result) + goto exit; + + /* Préparation pour la mémorisation des atomes */ + + node->atoms = malloc(node->count * sizeof(tracked_scan_atom_t)); + + /* Validation du besoin effectif dans les cas extrèmes */ + + + + // TODO : if (orig.len < ...) + + + + /* Recherche des atomes */ + + for (i = 0; i < node->count; i++) + { + if (node->flags & SPNF_CASE_INSENSITIVE) + { + find_best_atom(&node->raw[i], maxsize, &atom, &letters); + + if (letters == 0) + node->atoms[i] = atom; + + /* Insertion des combinaisons pour couvrir toutes les casses */ + else + { + for (k = 0, extra_count = 1; k < letters; k++, extra_count *= 2) + ; + + extra = make_atoms_case_insensitive(&node->raw[i], extra_count); + + remaining = node->count - i - 1; + + node->count += (extra_count - 1); + + node->raw = realloc(node->raw, node->count * sizeof(sized_binary_t)); + + memmove(&node->raw[i + extra_count], &node->raw[i + 1], remaining * sizeof(sized_binary_t)); + + for (k = 0; k < extra_count; k++) + node->raw[i + k] = extra[k]; + + free(extra); + + node->atoms = realloc(node->raw, node->count * sizeof(tracked_scan_atom_t)); + + for (k = 0; k < extra_count; k++) + node->atoms[i + k] = atom; + + i += extra_count - 1; + + } + + } + + else + find_best_atom(&node->raw[i], maxsize, &node->atoms[i], &letters); + + } + + /* Enregistrements en masse */ + + for (i = 0; i < node->count && result; i++) + result = enroll_prepared_atom(&node->raw[i], context, backend, &node->atoms[i]); + + exit: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : raw = contneu brut à retrouver idéalement. * +* atom = contenu brut représentatif ciblé. * +* start = point d'analyse à respecter. * +* content = accès au contenu brut pour vérifications (optim.) * +* * +* Description : Détermine si un contenu d'intérêt est présent à une position.* +* * +* Retour : Bilan de l'analyse : true pour une correspondance. * +* * +* Remarques : - * +* * +******************************************************************************/ + +static bool check_scan_token_node_plain_content(const sized_binary_t *raw, const tracked_scan_atom_t *atom, phys_t start, GBinContent *content) +{ + bool result; /* Bilan à retourner */ + vmpa2t pos; /* Position dans les données */ + const bin_t *ptr; /* Accès aux données brutes */ + int ret; /* Bilan d'une comparaison */ + + result = false; + + init_vmpa(&pos, start, VMPA_NO_VIRTUAL); + + /* Validation du contenu avant l'atome */ + + if (atom->pos > 0) + { + ptr = g_binary_content_get_raw_access(content, &pos, atom->pos); + + ret = memcmp(raw->data, ptr, atom->pos); + if (ret != 0) goto done; + + } + + /* Validation du contenu après l'atome */ + + if (atom->rem > 0) + { + advance_vmpa(&pos, atom->len); + + ptr = g_binary_content_get_raw_access(content, &pos, atom->rem); + + ret = memcmp(raw->data + atom->pos + atom->len, ptr, atom->rem); + if (ret != 0) goto done; + + } + + result = true; + + done: + + return result; + +} + + +/****************************************************************************** +* * +* Paramètres : node = définition de la bribe à manipuler. * +* context = contexte de l'analyse à mener. * +* content = accès au contenu brut pour vérifications (optim.) * +* matches = suivi des correspondances à consolider. * +* offset = tolérance dans les positions à appliquer. * +* * +* Description : Transforme les correspondances locales en trouvailles. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_plain_bytes_check(const GScanTokenNodePlain *node, GScanContext *context, GBinContent *content, pending_matches_t *matches, const node_search_offset_t *offset) +{ + bool initialized; /* Initialisation du suivi ? */ + size_t i; /* Boucle de parcours #1 */ + const sized_binary_t *raw; /* Données brutes d'origine */ + const tracked_scan_atom_t *atom; /* Atome correspondant */ + size_t count; /* Quantité de bribes trouvées */ + const phys_t *found; /* Localisations des bribes */ + size_t k; /* Boucle de parcours #2 */ + phys_t start; /* Point de départ */ + bool status; /* Bilan d'une correspondance */ + size_t pcount; /* Nombre de correspondances */ + size_t p; /* Boucle de parcours #3 */ + + initialized = are_pending_matches_initialized(matches); + + for (i = 0; i < node->count; i++) + { + raw = &node->raw[i]; + atom = &node->atoms[i]; + + found = g_scan_context_get_atom_matches(context, atom->pid, &count); + + if (!initialized) + { + for (k = 0; k < count; k++) + { + start = found[k] - atom->pos; + + /** + * Si personne n'a manipulé les pré-résultats, mais qu'un décallage + * est spécifié par un noeud précédent, une validation sur la base + * d'une position 0 est menée. + */ + if (offset != NULL) + { + if (start < offset->min || start > offset->max) + continue; + } + + status = check_scan_token_node_plain_content(raw, atom, start, content); + + if (status) + /** + * Il ne peut y avoir qu'une seule séquence d'octets à un même + * emplacement, donc le couple (start, len) enregistré est + * unique. + */ + add_pending_match(matches, start, raw->len); + + } + + } + + else + { + reset_pending_matches_ttl(matches); + + pcount = count_pending_matches(matches); + + for (p = 0; p < pcount; p++) + for (k = 0; k < count; k++) + { + start = found[k] - atom->pos; + + /** + * Si bornes de tolérance il y a, on valide la position. + * + * Sinon les correspondances passées et actuelle doivent + * être jointes. + */ + if (offset != NULL) + { + if (!has_pending_match_ending_between(matches, p, start, offset->min, offset->max)) + continue; + } + else + { + if (!has_pending_match_ending_at(matches, p, start)) + continue; + } + + status = check_scan_token_node_plain_content(raw, atom, start, content); + + if (status) + { + /** + * Même si une base de couples uniques est assurée, + * la constitution d'un ensemble de noeuds peut amener une + * redondance dans les emplacements de correspondances. + * + * Par exemple, pour la séquence d'octets analysés suivante : + * + * aaa....bbb + * + * La définition { (61 61 | 61 61 61) [4-5] 62 62 62 } peut établir + * les correspondances suivantes : + * + * aa.....bbb -> couple pending[x] (0;2) puis (0;10) + * ^ + * aa....bbb -> couple pending[y] (1;3) puis (1;10) + * ^ + * aaa....bbb -> couple pending[z] (0;3) puis (0;10) + * ^ + * + * Par ailleurs, une même base de départ peut conduire + * à plusieurs zone de correspondances. + * + * Par exemple, pour la séquence d'octets analysés suivante : + * + * aa..bb..bb + * + * La définition { 61 61 [2-6] 62 62 } peut établir + * les correspondances suivantes : + * + * aa..bb..bb -> couple pending[x] (0;2) puis (0;6) + * ^ + * aa..bb..bb -> couple pending[x] (0;2) puis (0;10) + * ^ + */ + + /** + * La seconde situation est prise en compte par la fonction + * extend_pending_match() qui s'appuie sur le TTL pour dupliquer + * la correspondance pending[x] initiale. Le nouvel élément est + * placé en fin de liste, ce qui ne boulverse pas le parcours + * de liste courant, la valeur de pcount n'étant pas actualisée. + */ + + extend_pending_match(matches, p, start + raw->len); + + } + + } + + purge_pending_matches(matches); + + } + + } + + set_pending_matches_initialized(matches); + +} diff --git a/src/analysis/scan/patterns/tokens/nodes/plain.h b/src/analysis/scan/patterns/tokens/nodes/plain.h new file mode 100644 index 0000000..33e7feb --- /dev/null +++ b/src/analysis/scan/patterns/tokens/nodes/plain.h @@ -0,0 +1,70 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * plain.h - prototypes pour la gestion d'une recherche de motif textuel + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_PLAIN_H +#define _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_PLAIN_H + + +#include <glib-object.h> + + +#include "../node.h" +#include "../../modifier.h" +#include "../../../../../common/szstr.h" + + + +#define G_TYPE_SCAN_TOKEN_NODE_PLAIN g_scan_token_node_plain_get_type() +#define G_SCAN_TOKEN_NODE_PLAIN(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_TOKEN_NODE_PLAIN, GScanTokenNodePlain)) +#define G_IS_SCAN_TOKEN_NODE_PLAIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_TOKEN_NODE_PLAIN)) +#define G_SCAN_TOKEN_NODE_PLAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_TOKEN_NODE_PLAIN, GScanTokenNodePlainClass)) +#define G_IS_SCAN_TOKEN_NODE_PLAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_TOKEN_NODE_PLAIN)) +#define G_SCAN_TOKEN_NODE_PLAIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_TOKEN_NODE_PLAIN, GScanTokenNodePlainClass)) + + +/* Bribe de motif textuelle pour recherches (instance) */ +typedef struct _GScanTokenNodePlain GScanTokenNodePlain; + +/* Bribe de motif textuelle pour recherches (classe) */ +typedef struct _GScanTokenNodePlainClass GScanTokenNodePlainClass; + + +/* Propriétés d'un élément textuel à rechercher */ +typedef enum _ScanPlainNodeFlags +{ + SPNF_NONE = 0x0, /* Aucune particularité */ + SPNF_CASE_INSENSITIVE = 0x1, /* Ignorance de la casse */ + SPNF_FULL_WORD = 0x2, /* Recherche de mot entier */ + +} ScanPlainNodeFlags; + + +/* Indique le type défini pour un noeud représentant une bribe de texte à retrouver. */ +GType g_scan_token_node_plain_get_type(void); + +/* Construit un noeud représentant un motif textuel. */ +GScanTokenNode *g_scan_token_node_plain_new(const sized_binary_t *, GScanTokenModifier *, ScanPlainNodeFlags); + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_TOKENS_NODES_PLAIN_H */ diff --git a/src/analysis/scan/patterns/tokens/plain-int.h b/src/analysis/scan/patterns/tokens/plain-int.h new file mode 100644 index 0000000..40a71b5 --- /dev/null +++ b/src/analysis/scan/patterns/tokens/plain-int.h @@ -0,0 +1,64 @@ + +/* Chrysalide - Outil d'analyse de fichiers binaires + * plain-int.h - prototypes internes pour la recherche d'une chaîne de caractères brute + * + * Copyright (C) 2023 Cyrille Bagard + * + * This file is part of Chrysalide. + * + * Chrysalide is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * Chrysalide is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Foobar. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef _ANALYSIS_SCAN_PATTERNS_TOKENS_PLAIN_INT_H +#define _ANALYSIS_SCAN_PATTERNS_TOKENS_PLAIN_INT_H + + +#include "plain.h" + + +#include "atom.h" +#include "../token-int.h" + + + +/* Encadrement d'une recherche de texte brut (instance) */ +struct _GScanPlainBytes +{ + GStringToken parent; /* A laisser en premier */ + + sized_binary_t orig; /* Motif d'origine avant modifs*/ + GScanTokenModifier *modifier; /* Transformateur pour le motif*/ + ScanPlainBytesFlags flags; /* Fanions associés au motif */ + + sized_binary_t *raw; /* Liste de motifs à couvrir */ + tracked_scan_atom_t *atoms; /* Atomes correspondants */ + size_t count; /* Taille de cette liste */ + +}; + +/* Encadrement d'une recherche de texte brut (classe) */ +struct _GScanPlainBytesClass +{ + GStringTokenClass parent; /* A laisser en premier */ + +}; + + +/* Met en place un gestionnaire de recherche de texte brut. */ +bool g_scan_plain_bytes_create(GScanPlainBytes *, const sized_binary_t *, GScanTokenModifier *, ScanPlainBytesFlags); + + + +#endif /* _ANALYSIS_SCAN_PATTERNS_TOKENS_PLAIN_INT_H */ diff --git a/src/analysis/scan/patterns/tokens/plain.c b/src/analysis/scan/patterns/tokens/plain.c index 9eb731e..26e7dfa 100644 --- a/src/analysis/scan/patterns/tokens/plain.c +++ b/src/analysis/scan/patterns/tokens/plain.c @@ -28,59 +28,41 @@ #include <string.h> -#include "../token-int.h" +#include "plain-int.h" /* ----------------------- RECHERCHE D'UN MOTIF DE TEXTE BRUT ----------------------- */ -/* Encadrement d'une recherche de texte brut (instance) */ -struct _GPlainBytes -{ - GStringToken parent; /* A laisser en premier */ - - uint8_t *raw; /* Octets recherchés */ - size_t allocated; /* Taille allouée */ - size_t used; /* Quantité d'octets utilisée */ - - phys_t atom_pos; /* Début de sélection atomique */ - phys_t atom_len; /* Taille de ladite sélection */ - phys_t atom_rem; /* Reste après l'atome */ - patid_t pid; /* Identifiant de la bribe */ - -}; - -/* Encadrement d'une recherche de texte brut (classe) */ -struct _GPlainBytesClass -{ - GStringTokenClass parent; /* A laisser en premier */ - -}; - - /* Initialise la classe des recherches de texte brut. */ -static void g_plain_bytes_class_init(GPlainBytesClass *klass); +static void g_scan_plain_bytes_class_init(GScanPlainBytesClass *klass); /* Initialise une instance de recherche de texte brut. */ -static void g_plain_bytes_init(GPlainBytes *); +static void g_scan_plain_bytes_init(GScanPlainBytes *); /* Supprime toutes les références externes. */ -static void g_plain_bytes_dispose(GPlainBytes *); +static void g_scan_plain_bytes_dispose(GScanPlainBytes *); /* Procède à la libération totale de la mémoire. */ -static void g_plain_bytes_finalize(GPlainBytes *); +static void g_scan_plain_bytes_finalize(GScanPlainBytes *); /* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */ +/* Affiche un motif de recherche au format texte. */ +static void g_scan_plain_bytes_output_to_text(const GScanPlainBytes *, GScanContext *, int); + +/* Affiche un motif de recherche au format JSON. */ +static void g_scan_plain_bytes_output_to_json(const GScanPlainBytes *, GScanContext *, const sized_string_t *, unsigned int, int); + /* Inscrit la définition d'un motif dans un moteur de recherche. */ -static bool g_plain_bytes_enroll(GPlainBytes *, GScanContext *, GEngineBackend *, size_t); +static bool g_scan_plain_bytes_enroll(GScanPlainBytes *, GScanContext *, GEngineBackend *, size_t); /* Transforme les correspondances locales en trouvailles. */ -static void g_plain_bytes_check(const GPlainBytes *, GScanContext *, GBinContent *, pending_matches_t *); +static void g_scan_plain_bytes_check(const GScanPlainBytes *, GScanContext *, GBinContent *, pending_matches_t *); @@ -90,7 +72,7 @@ static void g_plain_bytes_check(const GPlainBytes *, GScanContext *, GBinContent /* Indique le type défini pour une suite d'octets à retrouver dans un binaire. */ -G_DEFINE_TYPE(GPlainBytes, g_plain_bytes, G_TYPE_STRING_TOKEN); +G_DEFINE_TYPE(GScanPlainBytes, g_scan_plain_bytes, G_TYPE_STRING_TOKEN); /****************************************************************************** @@ -105,7 +87,7 @@ G_DEFINE_TYPE(GPlainBytes, g_plain_bytes, G_TYPE_STRING_TOKEN); * * ******************************************************************************/ -static void g_plain_bytes_class_init(GPlainBytesClass *klass) +static void g_scan_plain_bytes_class_init(GScanPlainBytesClass *klass) { GObjectClass *object; /* Autre version de la classe */ GSearchPatternClass *pattern; /* Version de classe ancêtre */ @@ -113,26 +95,25 @@ static void g_plain_bytes_class_init(GPlainBytesClass *klass) object = G_OBJECT_CLASS(klass); - object->dispose = (GObjectFinalizeFunc/* ! */)g_plain_bytes_dispose; - object->finalize = (GObjectFinalizeFunc)g_plain_bytes_finalize; + object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_plain_bytes_dispose; + object->finalize = (GObjectFinalizeFunc)g_scan_plain_bytes_finalize; pattern = G_SEARCH_PATTERN_CLASS(klass); - //pattern->prepare = (prepare_pattern_fc)g_plain_bytes_prepare; - //pattern->analyze = (analyze_pattern_fc)g_plain_bytes_analyze; - //pattern->count = (count_pattern_matchs_fc); + pattern->to_text = (output_pattern_to_text_fc)g_scan_plain_bytes_output_to_text; + pattern->to_json = (output_pattern_to_json_fc)g_scan_plain_bytes_output_to_json; token = G_STRING_TOKEN_CLASS(klass); - token->enroll = (enroll_token_fc)g_plain_bytes_enroll; - token->check = (check_token_fc)g_plain_bytes_check; + token->enroll = (enroll_token_fc)g_scan_plain_bytes_enroll; + token->check = (check_token_fc)g_scan_plain_bytes_check; } /****************************************************************************** * * -* Paramètres : pattern = instance à initialiser. * +* Paramètres : bytes = instance à initialiser. * * * * Description : Initialise une instance de recherche de texte brut. * * * @@ -142,16 +123,15 @@ static void g_plain_bytes_class_init(GPlainBytesClass *klass) * * ******************************************************************************/ -static void g_plain_bytes_init(GPlainBytes *bytes) +static void g_scan_plain_bytes_init(GScanPlainBytes *bytes) { - bytes->raw = NULL; - bytes->allocated = 0; - bytes->used = 0; + init_szstr(&bytes->orig); + bytes->modifier = NULL; + bytes->flags = SPBF_NONE; - bytes->atom_pos = 0; - bytes->atom_len = 0; - bytes->atom_rem = 0; - bytes->pid = INVALID_PATTERN_ID; + bytes->raw = NULL; + bytes->atoms = NULL; + bytes->count = 0; } @@ -168,9 +148,11 @@ static void g_plain_bytes_init(GPlainBytes *bytes) * * ******************************************************************************/ -static void g_plain_bytes_dispose(GPlainBytes *bytes) +static void g_scan_plain_bytes_dispose(GScanPlainBytes *bytes) { - G_OBJECT_CLASS(g_plain_bytes_parent_class)->dispose(G_OBJECT(bytes)); + g_clear_object(&bytes->modifier); + + G_OBJECT_CLASS(g_scan_plain_bytes_parent_class)->dispose(G_OBJECT(bytes)); } @@ -187,20 +169,31 @@ static void g_plain_bytes_dispose(GPlainBytes *bytes) * * ******************************************************************************/ -static void g_plain_bytes_finalize(GPlainBytes *bytes) +static void g_scan_plain_bytes_finalize(GScanPlainBytes *bytes) { + size_t i; /* Boucle de parcours */ + + exit_szstr(&bytes->orig); + + for (i = 0; i < bytes->count; i++) + exit_szstr(&bytes->raw[i]); + if (bytes->raw != NULL) free(bytes->raw); - G_OBJECT_CLASS(g_plain_bytes_parent_class)->finalize(G_OBJECT(bytes)); + if (bytes->atoms != NULL) + free(bytes->atoms); + + G_OBJECT_CLASS(g_scan_plain_bytes_parent_class)->finalize(G_OBJECT(bytes)); } /****************************************************************************** * * -* Paramètres : text = texte brut à rechercher. * -* len = longueur de ce texte. * +* Paramètres : text = texte brut à rechercher. * +* modifier = transformateur éventuel à solliciter. * +* flags = particularités à prendre en considération. * * * * Description : Construit un gestionnaire de recherche de texte brut. * * * @@ -210,19 +203,51 @@ static void g_plain_bytes_finalize(GPlainBytes *bytes) * * ******************************************************************************/ -GSearchPattern *g_plain_bytes_new(const uint8_t *raw, size_t len) +GSearchPattern *g_scan_plain_bytes_new(const sized_binary_t *text, GScanTokenModifier *modifier, ScanPlainBytesFlags flags) { - GPlainBytes *result; /* Structure à retourner */ + GSearchPattern *result; /* Structure à retourner */ - result = g_object_new(G_TYPE_PLAIN_BYTES, NULL); + result = g_object_new(G_TYPE_SCAN_PLAIN_BYTES, NULL); - result->raw = malloc(len); - result->allocated = len; - result->used = len; + if (!g_scan_plain_bytes_create(G_SCAN_PLAIN_BYTES(result), text, modifier, flags)) + g_clear_object(&result); - memcpy(result->raw, raw, len); + return result; + +} - return G_SEARCH_PATTERN(result); +/****************************************************************************** +* * +* Paramètres : bytes = encadrement de motif à initialiser pleinement. * +* text = texte brut à rechercher. * +* modifier = transformateur éventuel à solliciter. * +* flags = particularités à prendre en considération. * +* * +* Description : Met en place un gestionnaire de recherche de texte brut. * +* * +* Retour : Bilan de l'opération. * +* * +* Remarques : - * +* * +******************************************************************************/ + +bool g_scan_plain_bytes_create(GScanPlainBytes *bytes, const sized_binary_t *text, GScanTokenModifier *modifier, ScanPlainBytesFlags flags) +{ + bool result; /* Bilan à retourner */ + + result = true; + + szstrdup(&bytes->orig, text); + + if (modifier != NULL) + { + bytes->modifier = modifier; + g_object_ref(G_OBJECT(modifier)); + } + + bytes->flags = flags; + + return result; } @@ -235,6 +260,52 @@ GSearchPattern *g_plain_bytes_new(const uint8_t *raw, size_t len) /****************************************************************************** * * +* Paramètres : pattern = définition de motif à considérer. * +* context = contexte de l'analyse à mener. * +* fd = canal d'écriture. * +* * +* Description : Affiche un motif de recherche au format texte. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_plain_bytes_output_to_text(const GScanPlainBytes *pattern, GScanContext *context, int fd) +{ + G_SEARCH_PATTERN_CLASS(g_scan_plain_bytes_parent_class)->to_text(G_SEARCH_PATTERN(pattern), context, fd); + +} + + +/****************************************************************************** +* * +* Paramètres : pattern = définition de motif à considérer. * +* context = contexte de l'analyse à mener. * +* padding = éventuel bourrage initial à placer ou NULL. * +* level = profondeur actuelle. * +* fd = canal d'écriture. * +* * +* Description : Affiche un motif de recherche au format JSON. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void g_scan_plain_bytes_output_to_json(const GScanPlainBytes *pattern, GScanContext *context, const sized_string_t *padding, unsigned int level, int fd) +{ + G_SEARCH_PATTERN_CLASS(g_scan_plain_bytes_parent_class)->to_json(G_SEARCH_PATTERN(pattern), context, padding, level, fd); + + /* TODO */ + +} + + +/****************************************************************************** +* * * Paramètres : bytes = définition de la bribe à enregistrer. * * context = contexte de l'analyse à mener. * * backend = moteur de recherche à préchauffer. * @@ -248,39 +319,99 @@ GSearchPattern *g_plain_bytes_new(const uint8_t *raw, size_t len) * * ******************************************************************************/ -static bool g_plain_bytes_enroll(GPlainBytes *bytes, GScanContext *context, GEngineBackend *backend, size_t maxsize) +static bool g_scan_plain_bytes_enroll(GScanPlainBytes *bytes, GScanContext *context, GEngineBackend *backend, size_t maxsize) { + return false; +#if 0 bool result; /* Statut à retourner */ + size_t i; /* Boucle de parcours #1 */ + tracked_scan_atom_t atom; /* Atome identifié */ + size_t letters; /* Nombre de lettres présentes */ + size_t k; /* Boucle de parcours #2 */ + size_t extra_count; /* Quantité pour l'exhaustivité*/ + sized_binary_t *extra; /* Couverture supplémntaire */ + size_t remaining; /* Quantité restant à traiter */ + /* Génération d'une base de chaînes à couvrir */ - result = true; - + if (bytes->modifier == NULL) + { + bytes->raw = malloc(sizeof(sized_binary_t)); + bytes->count = 1; + szstrdup(&bytes[0].raw[0], &bytes->orig); - bytes->atom_pos = 0; + result = true; - if (bytes->used > maxsize) // Attention à la position de départ (à retrancher) ! - { - bytes->atom_len = maxsize; - bytes->atom_rem = bytes->used - maxsize; } else + result = g_scan_token_modifier_transform(bytes->modifier, &bytes->orig, &bytes->raw, &bytes->count); + + if (!result) + goto exit; + + /* Préparation pour la mémorisation des atomes */ + + bytes->atoms = malloc(bytes->count * sizeof(tracked_scan_atom_t)); + + /* Recherche des atomes */ + + for (i = 0; i < bytes->count; i++) { - bytes->atom_len = bytes->used; - bytes->atom_rem = 0; - } + if (bytes->flags & SPBF_CASE_INSENSITIVE) + { + find_best_atom(&bytes->raw[i], maxsize, &atom, &letters); + if (letters == 0) + bytes->atoms[i] = atom; - bytes->pid = g_engine_backend_enroll_plain_pattern(backend, context, bytes->raw, bytes->atom_len); + /* Insertion des combinaisons pour couvrir toutes les casses */ + else + { + for (k = 0, extra_count = 1; k < letters; k++, extra_count *= 2) + ; + extra = make_atoms_case_insensitive(&bytes->raw[i], extra_count); + remaining = bytes->count - i - 1; - result = (bytes->pid != INVALID_PATTERN_ID); + bytes->count += (extra_count - 1); + bytes->raw = realloc(bytes->raw, bytes->count * sizeof(sized_binary_t)); + memmove(&bytes->raw[i + extra_count], &bytes->raw[i + 1], remaining * sizeof(sized_binary_t)); - return result; + for (k = 0; k < extra_count; k++) + bytes->raw[i + k] = extra[k]; + + free(extra); + + bytes->atoms = realloc(bytes->raw, bytes->count * sizeof(tracked_scan_atom_t)); + + for (k = 0; k < extra_count; k++) + bytes->atoms[i + k] = atom; + i += extra_count - 1; + + } + + } + + else + find_best_atom(&bytes->raw[i], maxsize, &bytes->atoms[i], &letters); + + } + + /* Enregistrements en masse */ + + + for (i = 0; i < bytes->count && result; i++) + result = enroll_prepared_atom(&bytes->raw[i], context, backend, &bytes->atoms[i]); + + exit: + + return result; +#endif } @@ -299,76 +430,64 @@ static bool g_plain_bytes_enroll(GPlainBytes *bytes, GScanContext *context, GEng * * ******************************************************************************/ -static void g_plain_bytes_check(const GPlainBytes *bytes, GScanContext *context, GBinContent *content, pending_matches_t *matches) +static void g_scan_plain_bytes_check(const GScanPlainBytes *bytes, GScanContext *context, GBinContent *content, pending_matches_t *matches) { - bool initialized; /* Initialisation du suivi ? */ +#if 0 + + size_t i; /* Boucle de parcours #1 */ + const sized_binary_t *raw; /* Données brutes d'origine */ + const tracked_scan_atom_t *atom; /* Atome correspondant */ size_t count; /* Quantité de bribes trouvées */ const phys_t *found; /* Localisations des bribes */ - size_t mindex; /* Indice d'élément à compléter*/ - size_t i; /* Boucle de parcours */ + size_t k; /* Boucle de parcours #2 */ phys_t start; /* Point de départ */ vmpa2t pos; /* Position dans les données */ const bin_t *ptr; /* Accès aux données brutes */ int ret; /* Bilan d'une comparaison */ - initialized = are_pending_matches_initialized(matches); - - found = g_scan_context_get_atom_matches(context, bytes->pid, &count); - - mindex = 0; - - for (i = 0; i < count; i++) + for (i = 0; i < bytes->count; i++) { - start = found[i] - bytes->atom_pos; - - /* Recherche d'un point de départ attendu et conforme ? */ + raw = &bytes->raw[i]; + atom = &bytes->atoms[i]; - if (initialized) - if (!find_target_in_pending_matches(matches, start, &mindex)) - continue; + found = g_scan_context_get_atom_matches(context, atom->pid, &count); - init_vmpa(&pos, start, VMPA_NO_VIRTUAL); - - /* Validation du contenu avant l'atome */ - - if (bytes->atom_pos > 0) + for (k = 0; k < count; k++) { - ptr = g_binary_content_get_raw_access(content, &pos, bytes->atom_len); - - ret = memcmp(bytes->raw + bytes->atom_pos, ptr, bytes->atom_len); - if (ret != 0) goto exclude_false_positive; + start = found[k] - atom->pos; - } + init_vmpa(&pos, start, VMPA_NO_VIRTUAL); - /* Validation du contenu après l'atome */ + /* Validation du contenu avant l'atome */ - if (bytes->atom_rem > 0) - { - advance_vmpa(&pos, bytes->atom_len); + if (atom->pos > 0) + { + ptr = g_binary_content_get_raw_access(content, &pos, atom->pos); - ptr = g_binary_content_get_raw_access(content, &pos, bytes->atom_rem); + ret = memcmp(raw->data, ptr, atom->pos); + if (ret != 0) continue; - ret = memcmp(bytes->raw + bytes->atom_pos + bytes->atom_len, ptr, bytes->atom_rem); - if (ret != 0) goto exclude_false_positive; + } - } + /* Validation du contenu après l'atome */ - /* Mémorisation de la correspondance */ + if (atom->rem > 0) + { + advance_vmpa(&pos, atom->len); - if (initialized) - extend_pending_matches(matches, mindex, bytes->used); - else - add_pending_matches(matches, start, bytes->used); + ptr = g_binary_content_get_raw_access(content, &pos, atom->rem); - continue; + ret = memcmp(raw->data + atom->pos + atom->len, ptr, atom->rem); + if (ret != 0) continue; - exclude_false_positive: + } - if (initialized) - remove_pending_matches(matches, mindex); + /* Mémorisation de la correspondance */ - } + add_pending_matches(matches, start, raw->len); - set_pending_matches_initialized(matches); + } + } +#endif } diff --git a/src/analysis/scan/patterns/tokens/plain.h b/src/analysis/scan/patterns/tokens/plain.h index de1d4ec..80a0b4d 100644 --- a/src/analysis/scan/patterns/tokens/plain.h +++ b/src/analysis/scan/patterns/tokens/plain.h @@ -26,41 +26,44 @@ #include <glib-object.h> -#include <stdint.h> +#include "../modifier.h" #include "../../pattern.h" +#include "../../../../common/szstr.h" -#define G_TYPE_PLAIN_BYTES g_plain_bytes_get_type() -#define G_PLAIN_BYTES(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_PLAIN_BYTES, GPlainBytes)) -#define G_IS_PLAIN_BYTES(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_PLAIN_BYTES)) -#define G_PLAIN_BYTES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_PLAIN_BYTES, GPlainBytesClass)) -#define G_IS_PLAIN_BYTES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_PLAIN_BYTES)) -#define G_PLAIN_BYTES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_PLAIN_BYTES, GPlainBytesClass)) +#define G_TYPE_SCAN_PLAIN_BYTES g_scan_plain_bytes_get_type() +#define G_SCAN_PLAIN_BYTES(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_PLAIN_BYTES, GScanPlainBytes)) +#define G_IS_SCAN_PLAIN_BYTES(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_PLAIN_BYTES)) +#define G_SCAN_PLAIN_BYTES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_PLAIN_BYTES, GScanPlainBytesClass)) +#define G_IS_SCAN_PLAIN_BYTES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_PLAIN_BYTES)) +#define G_SCAN_PLAIN_BYTES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_PLAIN_BYTES, GScanPlainBytesClass)) /* Représentation d'une suite d'octets à retrouver (instance) */ -typedef struct _GPlainBytes GPlainBytes; +typedef struct _GScanPlainBytes GScanPlainBytes; /* Représentation d'une suite d'octets à retrouver (classe) */ -typedef struct _GPlainBytesClass GPlainBytesClass; +typedef struct _GScanPlainBytesClass GScanPlainBytesClass; /* Propriétés d'un élément textuel à rechercher */ -typedef enum _StringTokenAttrib +typedef enum _ScanPlainBytesFlags { - STP_CASE_INSENSITIVE, + SPBF_NONE = 0x0, /* Aucune particularité */ + SPBF_CASE_INSENSITIVE = 0x1, /* Ignorance de la casse */ + SPBF_FULL_WORD = 0x2, /* Recherche de mot entier */ -} StringTokenAttrib; +} ScanPlainBytesFlags; /* Indique le type défini pour une suite d'octets à retrouver dans un binaire. */ -GType g_plain_bytes_get_type(void); +GType g_scan_plain_bytes_get_type(void); /* Construit un gestionnaire de recherche de texte brut. */ -GSearchPattern *g_plain_bytes_new(const uint8_t *, size_t); +GSearchPattern *g_scan_plain_bytes_new(const sized_binary_t *, GScanTokenModifier *, ScanPlainBytesFlags); diff --git a/src/analysis/scan/rule-int.h b/src/analysis/scan/rule-int.h index cc10b08..b43cba9 100644 --- a/src/analysis/scan/rule-int.h +++ b/src/analysis/scan/rule-int.h @@ -40,9 +40,9 @@ struct _GScanRule char *name; /* Désignation de la règle */ fnv64_t name_hash; /* Empreinte de la désignation */ - GSearchPattern **data_locals; /* Variables de données */ - size_t data_allocated; /* Taille allouée du tableau */ - size_t data_used; /* Nombre d'éléments présents */ + GSearchPattern **bytes_locals; /* Variables de données */ + size_t bytes_allocated; /* Taille allouée du tableau */ + size_t bytes_used; /* Nombre d'éléments présents */ GScanExpression *condition; /* Condition de correspondance */ diff --git a/src/analysis/scan/rule.c b/src/analysis/scan/rule.c index 6ca97ab..4727c9d 100644 --- a/src/analysis/scan/rule.c +++ b/src/analysis/scan/rule.c @@ -93,9 +93,9 @@ static void g_scan_rule_init(GScanRule *rule) rule->name = NULL; rule->name_hash = 0; - rule->data_locals = NULL; - rule->data_allocated = 0; - rule->data_used = 0; + rule->bytes_locals = NULL; + rule->bytes_allocated = 0; + rule->bytes_used = 0; rule->condition = NULL; @@ -118,8 +118,8 @@ static void g_scan_rule_dispose(GScanRule *rule) { size_t i; /* Boucle de parcours */ - for (i = 0; i < rule->data_used; i++) - g_clear_object(&rule->data_locals[i]); + for (i = 0; i < rule->bytes_used; i++) + g_clear_object(&rule->bytes_locals[i]); g_clear_object(&rule->condition); @@ -219,13 +219,13 @@ void g_scan_rule_add_local_variable(GScanRule *rule, GSearchPattern *pattern) { if (G_IS_STRING_TOKEN(pattern)) { - if (rule->data_used == rule->data_allocated) + if (rule->bytes_used == rule->bytes_allocated) { - rule->data_allocated += PATTERN_ALLOC_SIZE; - rule->data_locals = realloc(rule->data_locals, rule->data_allocated * sizeof(GSearchPattern *)); + rule->bytes_allocated += PATTERN_ALLOC_SIZE; + rule->bytes_locals = realloc(rule->bytes_locals, rule->bytes_allocated * sizeof(GSearchPattern *)); } - rule->data_locals[rule->data_used++] = pattern; + rule->bytes_locals[rule->bytes_used++] = pattern; g_object_ref(G_OBJECT(pattern)); } @@ -254,13 +254,13 @@ GSearchPattern *g_scan_rule_get_local_variable(GScanRule *rule, const char *targ result = NULL; - for (i = 0; i < rule->data_used; i++) + for (i = 0; i < rule->bytes_used; i++) { - name = g_search_pattern_get_name(rule->data_locals[i]); + name = g_search_pattern_get_name(rule->bytes_locals[i]); if (strcmp(name, target) == 0) { - result = rule->data_locals[i]; + result = rule->bytes_locals[i]; break; } @@ -327,9 +327,9 @@ bool g_scan_rule_setup_backend(GScanRule *rule, GEngineBackend *backend, GScanCo maxsize = g_engine_backend_get_atom_max_size(backend); - for (i = 0; i < rule->data_used && result; i++) + for (i = 0; i < rule->bytes_used && result; i++) { - pattern = rule->data_locals[i]; + pattern = rule->bytes_locals[i]; result = g_string_token_enroll(G_STRING_TOKEN(pattern), context, backend, maxsize); } @@ -380,11 +380,11 @@ void g_scan_rule_check(GScanRule *rule, GEngineBackend *backend, GScanContext *c /* Consolidation des résultats */ - for (i = 0; i < rule->data_used; i++) + for (i = 0; i < rule->bytes_used; i++) { init_pending_matches(&matches); - pattern = rule->data_locals[i]; + pattern = rule->bytes_locals[i]; g_string_token_check(G_STRING_TOKEN(pattern), context, content, &matches); @@ -392,7 +392,9 @@ void g_scan_rule_check(GScanRule *rule, GEngineBackend *backend, GScanContext *c { area = &matches.areas[k]; - match = g_bytes_match_new(G_SEARCH_PATTERN(pattern), content, area->start, area->length); + match = g_scan_bytes_match_new(G_SEARCH_PATTERN(pattern), content, + area->start, area->end - area->start); + g_scan_context_register_full_match(context, match); g_object_unref(G_OBJECT(match)); @@ -407,3 +409,161 @@ void g_scan_rule_check(GScanRule *rule, GEngineBackend *backend, GScanContext *c g_object_unref(G_OBJECT(content)); } + + +/****************************************************************************** +* * +* Paramètres : rule = règle de détection à considérer. * +* context = contexte de l'analyse à mener. * +* fd = canal d'écriture. * +* * +* Description : Affiche une règle au format texte. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_scan_rule_output_to_text(const GScanRule *rule, GScanContext *context, int fd) +{ + size_t i; /* Boucle de parcours */ + + for (i = 0; i < rule->bytes_used; i++) + g_search_pattern_output_to_text(rule->bytes_locals[i], context, fd); + + if (g_scan_context_has_match_for_rule(context, rule->name)) + { + write(fd, "Rule '", 6); + write(fd, rule->name, strlen(rule->name)); + write(fd, "' has matched!\n", 15); + } + +} + + +/****************************************************************************** +* * +* Paramètres : rule = règle de détection à considérer. * +* context = contexte de l'analyse à mener. * +* * +* Description : Convertit une règle en texte. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_scan_rule_convert_as_text(const GScanRule *rule, GScanContext *context) +{ + /* TODO */ + +} + + +/****************************************************************************** +* * +* Paramètres : rule = règle de détection à considérer. * +* context = contexte de l'analyse à mener. * +* padding = éventuel bourrage initial à placer ou NULL. * +* level = profondeur actuelle. * +* fd = canal d'écriture. * +* trailing = impose une virgule finale ? * +* * +* Description : Affiche une règle au format JSON. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_scan_rule_output_to_json(const GScanRule *rule, GScanContext *context, const sized_string_t *padding, unsigned int level, int fd, bool trailing) +{ + size_t i; /* Boucle de parcours */ + bool sub_trailing; /* Virgule finale */ + + /* Introduction */ + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + write(fd, "{\n", 2); + + /* Désignation de la règle */ + + for (i = 0; i < (level + 1); i++) + write(fd, padding->data, padding->len); + + write(fd, "\"name\": \"", 9); + + write(fd, rule->name, strlen(rule->name)); + + write(fd, "\",\n", 3); + + /* Affichage des correspondances d'octets */ + + for (i = 0; i < (level + 1); i++) + write(fd, padding->data, padding->len); + + write(fd, "\"bytes_patterns\": [\n", 20); + + for (i = 0; i < rule->bytes_used; i++) + { + sub_trailing = ((i + 1) < rule->bytes_used); + + g_search_pattern_output_to_json(rule->bytes_locals[i], context, padding, level + 2, fd, sub_trailing); + + } + + for (i = 0; i < (level + 1); i++) + write(fd, padding->data, padding->len); + + write(fd, "],\n", 3); + + /* Bilan du filtrage */ + + for (i = 0; i < (level + 1); i++) + write(fd, padding->data, padding->len); + + write(fd, "\"matched\": ", 11); + + if (g_scan_context_has_match_for_rule(context, rule->name)) + write(fd, "true", 4); + else + write(fd, "false", 5); + + write(fd, "\n", 1); + + /* Conclusion */ + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + if (trailing) + write(fd, "},\n", 3); + else + write(fd, "}\n", 2); + +} + + +/****************************************************************************** +* * +* Paramètres : rule = règle de détection à considérer. * +* context = contexte de l'analyse à mener. * +* * +* Description : Convertit une règle en JSON. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_scan_rule_convert_as_json(const GScanRule *rule, GScanContext *context) +{ + /* TODO */ + +} diff --git a/src/analysis/scan/rule.h b/src/analysis/scan/rule.h index 12a435c..cb2c287 100644 --- a/src/analysis/scan/rule.h +++ b/src/analysis/scan/rule.h @@ -34,6 +34,7 @@ #include "expr.h" #include "patterns/backend.h" #include "../../common/fnv1a.h" +#include "../../common/szstr.h" @@ -76,6 +77,18 @@ bool g_scan_rule_setup_backend(GScanRule *, GEngineBackend *, GScanContext *); /* Lance une analyse d'un contenu binaire selon une règle. */ void g_scan_rule_check(GScanRule *, GEngineBackend *, GScanContext *); +/* Affiche une règle au format texte. */ +void g_scan_rule_output_to_text(const GScanRule *, GScanContext *, int); + +/* Convertit une règle en texte. */ +void g_scan_rule_convert_as_text(const GScanRule *, GScanContext *); + +/* Affiche une règle au format JSON. */ +void g_scan_rule_output_to_json(const GScanRule *, GScanContext *, const sized_string_t *, unsigned int, int, bool); + +/* Convertit une règle en JSON. */ +void g_scan_rule_convert_as_json(const GScanRule *, GScanContext *); + #endif /* _ANALYSIS_SCAN_RULE_H */ diff --git a/src/analysis/scan/scanner.c b/src/analysis/scan/scanner.c index ce8d677..b550b1f 100644 --- a/src/analysis/scan/scanner.c +++ b/src/analysis/scan/scanner.c @@ -510,6 +510,8 @@ GScanContext *g_content_scanner_analyze(GContentScanner *scanner, GScanOptions * g_engine_backend_run_scan(scanner->data_backend, result); + g_scan_context_mark_scan_as_done(result); + for (i = 0; i < scanner->rule_count; i++) g_scan_rule_check(scanner->rules[i], scanner->data_backend, result); @@ -518,3 +520,117 @@ GScanContext *g_content_scanner_analyze(GContentScanner *scanner, GScanOptions * return result; } + + +/****************************************************************************** +* * +* Paramètres : scanner = gestionnaire de recherche à consulter. * +* context = contexte de l'analyse à mener. * +* fd = canal d'écriture. * +* * +* Description : Affiche un gestionnaire de recherches au format texte. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_content_scanner_output_to_text(const GContentScanner *scanner, GScanContext *context, int fd) +{ + size_t i; /* Boucle de parcours */ + + /* Sous-traitance aux règles */ + + for (i = 0; i < scanner->rule_count; i++) + g_scan_rule_output_to_text(scanner->rules[i], context, fd); + +} + + +/****************************************************************************** +* * +* Paramètres : scanner = gestionnaire de recherche à consulter. * +* context = contexte de l'analyse à mener. * +* * +* Description : Convertit un gestionnaire de recherches en texte. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_content_scanner_convert_as_text(const GContentScanner *scanner, GScanContext *context) +{ + /* TODO */ + +} + + +/****************************************************************************** +* * +* Paramètres : scanner = gestionnaire de recherche à consulter. * +* context = contexte de l'analyse à mener. * +* padding = éventuel bourrage initial à placer ou NULL. * +* level = profondeur actuelle. * +* fd = canal d'écriture. * +* * +* Description : Affiche un gestionnaire de recherches au format JSON. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_content_scanner_output_to_json(const GContentScanner *scanner, GScanContext *context, const sized_string_t *padding, unsigned int level, int fd) +{ + size_t i; /* Boucle de parcours */ + bool trailing; /* Virgule finale */ + + /* Introduction */ + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + write(fd, "[\n", 2); + + /* Sous-traitance aux règles */ + + for (i = 0; i < scanner->rule_count; i++) + { + trailing = ((i + 1) < scanner->rule_count); + + g_scan_rule_output_to_json(scanner->rules[i], context, padding, level + 1, fd, trailing); + + } + + /* Conclusion */ + + for (i = 0; i < level; i++) + write(fd, padding->data, padding->len); + + write(fd, "]\n", 2); + +} + + +/****************************************************************************** +* * +* Paramètres : scanner = gestionnaire de recherche à consulter. * +* context = contexte de l'analyse à mener. * +* * +* Description : Convertit un gestionnaire de recherches en JSON. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +void g_content_scanner_convert_as_json(const GContentScanner *scanner, GScanContext *context) +{ + /* TODO */ + +} diff --git a/src/analysis/scan/scanner.h b/src/analysis/scan/scanner.h index f838344..58dbe19 100644 --- a/src/analysis/scan/scanner.h +++ b/src/analysis/scan/scanner.h @@ -32,6 +32,7 @@ #include "expr.h" #include "options.h" #include "rule.h" +#include "../../common/szstr.h" @@ -71,6 +72,18 @@ bool g_content_scanner_add_rule(GContentScanner *, GScanRule *); /* Définit l'expression d'une correspondance recherchée. */ GScanContext *g_content_scanner_analyze(GContentScanner *, GScanOptions *, GBinContent *); +/* Affiche un gestionnaire de recherches au format texte. */ +void g_content_scanner_output_to_text(const GContentScanner *, GScanContext *, int); + +/* Convertit un gestionnaire de recherches en texte. */ +void g_content_scanner_convert_as_text(const GContentScanner *, GScanContext *); + +/* Affiche un gestionnaire de recherches au format JSON. */ +void g_content_scanner_output_to_json(const GContentScanner *, GScanContext *, const sized_string_t *, unsigned int, int); + +/* Convertit un gestionnaire de recherches en JSON. */ +void g_content_scanner_convert_as_json(const GContentScanner *, GScanContext *); + #endif /* _ANALYSIS_SCAN_SCANNER_H */ diff --git a/src/analysis/scan/tokens.l b/src/analysis/scan/tokens.l index f3dbc79..18594c4 100644 --- a/src/analysis/scan/tokens.l +++ b/src/analysis/scan/tokens.l @@ -15,47 +15,140 @@ #include <stdlib.h> -#define read_block(tmp) \ - ({ \ - unsigned int __depth; \ - bool __is_string; \ - char *__iter; \ - \ - __depth = 1; \ - __is_string = false; \ - \ - for (__iter = temp; __depth > 0; __iter += (__depth > 0 ? 1 : 0)) \ - { \ - *__iter = input(); \ - \ - switch (*__iter) \ - { \ - case '"': \ - __is_string = !__is_string; \ - break; \ - \ - case '{': \ - if (!__is_string) __depth++; \ - break; \ - \ - case '}': \ - if (!__is_string) \ - { \ - __depth--; \ - if (__depth == 0) unput('}'); \ - } \ - break; \ - \ - } \ - \ - } \ - \ - *__iter = '\0'; \ - \ - }) +/****************************************************************************** +* * +* Paramètres : src = liste d'octets à traiter. * +* len = taille de cette liste. * +* out = série d'octets bruts obtenue. [OUT] * +* * +* Description : Transcrit une série d'octets en en remplaçant certains. * +* * +* Retour : - * +* * +* Remarques : - * +* * +******************************************************************************/ + +static void rost_unescape_bytes(const char *src, size_t len, sized_string_t *out) +{ + size_t i; /* Boucle de parcours */ + bin_t byte; /* Octet à analyser */ + bin_t next; /* Octet suivant */ + + out->len = 0; + + for (i = 0; i < len; i++) + { + byte = src[i]; + + switch (byte) + { + case '\\': + + next = src[i + 1]; + + switch (next) + { + case '\a': + out->data[out->len++] = '\\'; + break; + + case '\t': + out->data[out->len++] = '\t'; + break; + + case '\n': + out->data[out->len++] = '\n'; + break; + + case '\v': + out->data[out->len++] = '\v'; + break; + + case '\f': + out->data[out->len++] = '\f'; + break; + + case '\r': + out->data[out->len++] = '\r'; + break; + + case '\\': + out->data[out->len++] = '\\'; + break; + + case 'x': + + next = src[i + 2]; + + switch (next) + { + case '0' ... '9': + out->data[out->len] = (next - '0'); + break; + + case 'A' ... 'F': + out->data[out->len] = 0x10 + (next - 'A'); + break; + + case 'a' ... 'f': + out->data[out->len] = 0x10 + (next - 'a'); + break; + + } + + out->data[out->len] <<= 4; + + next = src[i + 3]; + + switch (next) + { + case '0' ... '9': + out->data[out->len] |= (next - '0'); + break; + + case 'A' ... 'F': + out->data[out->len] |= 0x10 + (next - 'A'); + break; + + case 'a' ... 'f': + out->data[out->len] |= 0x10 + (next - 'a'); + break; + + } + + out->len++; + + i += 2; + break; + + case '{': + out->data[out->len++] = '{'; + break; + + case '}': + out->data[out->len++] = '}'; + break; + + } + + i++; + break; + + default: + out->data[out->len++] = byte; + break; + + } + + } + +} + + #define PUSH_STATE(s) yy_push_state(s, yyscanner) #define POP_STATE yy_pop_state(yyscanner) @@ -88,9 +181,15 @@ %x raw_block %x strings -%x strval -%x strval_raw -%x strval_hex +%x bytes_value +%x bytes_value_raw + +%x bytes_hex +%x bytes_hex_range + +%x bytes_regex +%x bytes_regex_quantifier +%x bytes_regex_range %x condition %x strlit @@ -101,6 +200,22 @@ %x comment + +hbyte [0-9a-fA-F]{2} + +reg_allowed [^^$.|/{}()\[\]*+?\\] +reg_allowed_escaped \\^|\\$|\\\.|\\\||\\\/|\\\{|\\\}|\\\(|\\\)|\\\[|\\\]|\\\*|\\\+|\\\?|\\\\ +reg_escaped \\a|\\t|\\n|\\v|\\f|\\r +reg_byte \\x[0-9a-fA-F]{2} + +regular_chars {reg_allowed}|{reg_allowed_escaped}|{reg_escaped}|{reg_byte} + +reg_classes \\w|\\W|\\s|\\S|\\d|\\D|\\b|\\B + + +bytes_id [A-Za-z_][A-Za-z0-9_]* + + %% @@ -139,8 +254,8 @@ <condition>-(0|[1-9][0-9]*) { yylval->signed_integer = strtoll(yytext, NULL, 10); return SIGNED_INTEGER; } <condition>-0x[0-9a-f]+ { yylval->signed_integer = strtoll(yytext, NULL, 16); return SIGNED_INTEGER; } -<condition>(0|[1-9][0-9]*) { yylval->unsigned_integer = strtoull(yytext, NULL, 10); return UNSIGNED_INTEGER; } -<condition>0x[0-9a-f]+ { yylval->unsigned_integer = strtoull(yytext, NULL, 16); return UNSIGNED_INTEGER; } +<bytes_hex_range,bytes_regex_quantifier,condition>(0|[1-9][0-9]*) { yylval->unsigned_integer = strtoull(yytext, NULL, 10); return UNSIGNED_INTEGER; } +<bytes_hex_range,bytes_regex_quantifier,condition>0x[0-9a-f]+ { yylval->unsigned_integer = strtoull(yytext, NULL, 16); return UNSIGNED_INTEGER; } <condition>[kK][bB] { return KB; } <condition>[mM][bB] { return MB; } @@ -181,6 +296,195 @@ +%{ /* Définition de motif en hexadécimal */ %} + + <bytes_value>"{" { + POP_STATE; + PUSH_STATE(bytes_hex); + } + + <bytes_hex>"}" { POP_STATE; } + + <bytes_hex>"[" { + PUSH_STATE(bytes_hex_range); + return HOOK_O; + } + + <bytes_hex_range>"-" { return MINUS; } + + <bytes_hex_range>"]" { + POP_STATE; + return HOOK_C; + } + + <bytes_hex>"(" { return PAREN_O; } + + <bytes_hex>")" { return PAREN_C; } + + <bytes_hex>"|" { return PIPE; } + + <bytes_hex>"~" { return TILDE; } + + <bytes_hex>{hbyte}([ ]*{hbyte})* { + bool even; + size_t i; + bin_t byte; + bin_t value; + + tmp_0->len = 0; + + even = true; + + for (i = 0; i < yyleng; i++) + { + byte = yytext[i]; + + switch (byte) + { + case ' ': + continue; + break; + + case '0' ... '9': + value = (byte - '0'); + break; + + case 'A' ... 'F': + value = 0x10 + (byte - 'A'); + break; + + case 'a' ... 'f': + value = 0x10 + (byte - 'a'); + break; + + } + + if (even) + { + tmp_0->data[tmp_0->len] = (value << 4); + even = false; + } + + else + { + tmp_0->data[tmp_0->len++] |= value; + even = true; + } + + } + + assert(even); + +#ifndef NDEBUG + /* Pour rendre plus lisibles les impressions de débogage */ + tmp_0->data[tmp_0->len] = '\0'; +#endif + + yylval->tmp_cstring = tmp_0; + return HEX_BYTES; + + } + + <bytes_hex>[\?]{2}([ ]*[\?]{2})* { + unsigned long long counter; + size_t i; + + counter = 0; + + for (i = 0; i < yyleng; i++) + if (yytext[i] == '?') + counter++; + + assert(counter % 2 == 0); + + yylval->unsigned_integer = counter / 2; + return FULL_MASK; + + } + + +%{ /* Définition d'expressions régulières */ %} + + <bytes_value>"/" { + POP_STATE; + printf(" -- regex\n"); + PUSH_STATE(bytes_regex); + } + + <bytes_regex>"/" { printf("exit regex\n"); POP_STATE; } + + <bytes_regex>"." { return DOT; } + + <bytes_regex>({regular_chars})+ { + rost_unescape_bytes(yytext, yyleng, tmp_0); + + printf(" regular: '%s'\n", yytext); + +#ifndef NDEBUG + /* Pour rendre plus lisibles les impressions de débogage */ + tmp_0->data[tmp_0->len] = '\0'; +#endif + + yylval->tmp_cstring = tmp_0; + return REGEX_BYTES; + + } + + <bytes_regex>({reg_classes})+ { + + return REGEX_CLASSES; + + } + +%{ /* <bytes_regex>\[({regular_chars}|({regular_chars})-z|{reg_classes})+\] { */ %} + + + <bytes_regex>"[" { + PUSH_STATE(bytes_regex_range); + printf(" !! entering range\n"); + return HOOK_O; + } + + <bytes_regex_range>"]" { + POP_STATE; + printf(" !! exiting range\n"); + return HOOK_C; + } + + + + +<bytes_regex_range>({regular_chars}|({regular_chars}-{regular_chars})|{reg_classes})+ { + + printf("range: '%s'\n", yytext); + return REGEX_RANGE; + + } + + <bytes_regex>"(" { return PAREN_O; } + + <bytes_regex>")" { return PAREN_C; } + + <bytes_regex>"|" { return PIPE; } + + <bytes_regex>"*" { return MUL; } + <bytes_regex>"+" { return PLUS; } + <bytes_regex>"?" { return QUESTION; } + + <bytes_regex>"{" { + PUSH_STATE(bytes_regex_quantifier); + return BRACKET_O; + } + + <bytes_regex_quantifier>"," { return COMMA; } + + <bytes_regex_quantifier>"}" { + POP_STATE; + return BRACKET_C; + } + + +%{ /* Condition de correspondance */ %} <condition>"and" { return AND; } <condition>"or" { return OR; } @@ -208,10 +512,17 @@ <condition>"/" { return DIV; } <condition>"%" { return MOD; } -<condition>"(" { return PAREN_O; } -<condition>")" { return PAREN_C; } -<condition>"," { return COMMA; } +<strings,condition>"(" { return PAREN_O; } +<strings,condition>")" { return PAREN_C; } +<strings,condition>"," { return COMMA; } + + +<condition>"[" { return HOOK_O; } +<condition>"]" { return HOOK_C; } + + <condition>"." { return DOT; } +<strings>"|" { return PIPE; } <condition>"none" { return NONE; } <condition>"any" { return ANY; } @@ -221,36 +532,51 @@ <condition>"in" { return IN; } -<strings,condition>$[A-Za-z0-9_]* { - yylval->sized_cstring.data = yytext + 1; - yylval->sized_cstring.len = yyleng - 1; - return IDENTIFIER; - } + <strings,condition>${bytes_id} { + yylval->sized_cstring.data = yytext + 1; + yylval->sized_cstring.len = yyleng - 1; + return BYTES_ID; + } + + <condition>#{bytes_id} { + yylval->sized_cstring.data = yytext + 1; + yylval->sized_cstring.len = yyleng - 1; + return BYTES_ID_COUNTER; + } + + <condition>@{bytes_id} { + yylval->sized_cstring.data = yytext + 1; + yylval->sized_cstring.len = yyleng - 1; + return BYTES_ID_START; + } + + <condition>!{bytes_id} { + yylval->sized_cstring.data = yytext + 1; + yylval->sized_cstring.len = yyleng - 1; + return BYTES_ID_LENGTH; + } + + <condition>~{bytes_id} { + yylval->sized_cstring.data = yytext + 1; + yylval->sized_cstring.len = yyleng - 1; + return BYTES_ID_END; + } -<condition>$[A-Za-z_][A-Za-z0-9_]* { - yylval->sized_cstring.data = yytext + 1; - yylval->sized_cstring.len = yyleng - 1; - return BYTES_ID; - } -<condition>#[A-Za-z_][A-Za-z0-9_]* { - yylval->sized_cstring.data = yytext + 1; - yylval->sized_cstring.len = yyleng - 1; - return BYTES_ID_COUNTER; - } -<condition>[A-Za-z_][A-Za-z0-9_]* { + +<strings,condition>[A-Za-z_][A-Za-z0-9_]* { yylval->sized_cstring.data = yytext; yylval->sized_cstring.len = yyleng; return NAME; } -<strings>"=" { PUSH_STATE(strval); return ASSIGN; } +<strings>"=" { PUSH_STATE(bytes_value); return ASSIGN; } -<strval>\"[^\"\\]+\" { +<bytes_value>\"[^\"\\]+\" { POP_STATE; yylval->sized_cstring.data = yytext + 1; yylval->sized_cstring.len = yyleng - 2; @@ -260,43 +586,28 @@ -<strval>"\"" { +<bytes_value>"\"" { POP_STATE; // *built_pattern = g_bytes_pattern_new(); - PUSH_STATE(strval_raw); - } -<strval>"{" { - POP_STATE; - // *built_pattern = g_bytes_pattern_new(); - PUSH_STATE(strval_hex); + PUSH_STATE(bytes_value_raw); } -<strval_raw>"\"" { POP_STATE; /*yylval->pattern = *built_pattern*/; return MASKED_STRING; } +<bytes_value_raw>"\"" { POP_STATE; /*yylval->pattern = *built_pattern*/; return MASKED_STRING; } -<strval_raw>"\\\"" { }//g_bytes_pattern_append_data(*built_pattern, '"', 0xff); } -<strval_raw>"\\t" { }//g_bytes_pattern_append_data(*built_pattern, '\t', 0xff); } -<strval_raw>"\\r" { }//g_bytes_pattern_append_data(*built_pattern, '\r', 0xff); } -<strval_raw>"\\n" { }//g_bytes_pattern_append_data(*built_pattern, '\n', 0xff); } -<strval_raw>"\\\\" { }//g_bytes_pattern_append_data(*built_pattern, '\\', 0xff); } +<bytes_value_raw>"\\\"" { }//g_bytes_pattern_append_data(*built_pattern, '"', 0xff); } +<bytes_value_raw>"\\t" { }//g_bytes_pattern_append_data(*built_pattern, '\t', 0xff); } +<bytes_value_raw>"\\r" { }//g_bytes_pattern_append_data(*built_pattern, '\r', 0xff); } +<bytes_value_raw>"\\n" { }//g_bytes_pattern_append_data(*built_pattern, '\n', 0xff); } +<bytes_value_raw>"\\\\" { }//g_bytes_pattern_append_data(*built_pattern, '\\', 0xff); } -<strval_raw>\\x[0-9a-fA-F]{2} { +<bytes_value_raw>\\x[0-9a-fA-F]{2} { uint8_t __ch; __ch = strtol(yytext + 2, NULL, 16); + printf("__ch: %hhx\n", __ch); //g_bytes_pattern_append_data(*built_pattern, __ch, 0xff); } -<strval_raw>. { }//g_bytes_pattern_append_data(*built_pattern, *yytext, 0xff); } - -<strval_hex>"}" { POP_STATE; /*yylval->pattern = *built_pattern;*/ return MASKED_STRING; } - -<strval_hex>[0-9a-fA-F]{2} { - uint8_t __ch; - __ch = strtol(yytext, NULL, 16); - //g_bytes_pattern_append_data(*built_pattern, __ch, 0xff); - } - -<strval_hex>"??" { /*g_bytes_pattern_insert_space(*built_pattern, 1, 1);*/ } - +<bytes_value_raw>. { }//g_bytes_pattern_append_data(*built_pattern, *yytext, 0xff); } @@ -318,7 +629,9 @@ %{ /* Actions par défaut */ %} -<*>[ \t\n]+ { } +<*>[ \t]+ { } + +<*>[\n] { static int ln = 1; if (0) printf("----------- %%< -------------- %%< ---- %d\n", ln++); } <*>. { char *msg; |