Save an initial version of rost.

6 files changed, 698 insertions, 0 deletions

diff --git a/src/analysis/scan/matches/Makefile.am b/src/analysis/scan/matches/Makefile.am
new file mode 100644
index 0000000..d6b51c6
--- /dev/null
+++ b/src/analysis/scan/matches/Makefile.am
@@ -0,0 +1,15 @@
+
+noinst_LTLIBRARIES  = libanalysisscanmatches.la
+
+
+libanalysisscanmatches_la_SOURCES =		\
+	bytes-int.h							\
+	bytes.h bytes.c						\
+	pending.h pending.c
+
+libanalysisscanmatches_la_CFLAGS = $(LIBGOBJ_CFLAGS)
+
+
+devdir = $(includedir)/chrysalide/$(subdir:src/%=core/%)
+
+dev_HEADERS = $(libanalysisscanmatches_la_SOURCES:%c=)
diff --git a/src/analysis/scan/matches/bytes-int.h b/src/analysis/scan/matches/bytes-int.h
new file mode 100644
index 0000000..c983aa3
--- /dev/null
+++ b/src/analysis/scan/matches/bytes-int.h
@@ -0,0 +1,60 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * bytes-int.h - prototypes internes pour la sauvegarde d'une correspondance identifiée de suite d'octets
+ *
+ * Copyright (C) 2022 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_MATCHES_BYTES_INT_H
+#define _ANALYSIS_SCAN_MATCHES_BYTES_INT_H
+
+
+#include "bytes.h"
+
+
+#include "../match-int.h"
+
+
+
+/* Correspondance trouvée avec une chaîne (instance) */
+struct _GBytesMatch
+{
+    GScanMatch parent;                      /* A laisser en premier        */
+
+    GBinContent *content;                   /* Contenu binaire de référence*/
+
+    phys_t start;                           /* Début du motif représenté   */
+    phys_t len;                             /* Taille du motif représenté  */
+
+};
+
+/* Correspondance trouvée avec une chaîne (classe) */
+struct _GBytesMatchClass
+{
+    GScanMatchClass parent;                 /* A laisser en premier        */
+
+};
+
+
+/* Met en place une correspondance trouvée avec un motif. */
+bool g_bytes_match_create(GBytesMatch *, GSearchPattern *, GBinContent *, phys_t, phys_t);
+
+
+
+#endif  /* _ANALYSIS_SCAN_MATCHES_BYTES_INT_H */
diff --git a/src/analysis/scan/matches/bytes.c b/src/analysis/scan/matches/bytes.c
new file mode 100644
index 0000000..90fa27d
--- /dev/null
+++ b/src/analysis/scan/matches/bytes.c
@@ -0,0 +1,286 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * bytes.h - sauvegarde d'une correspondance identifiée de suite d'octets
+ *
+ * Copyright (C) 2022 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 "bytes.h"
+
+
+#include <ctype.h>
+
+
+#include "bytes-int.h"
+
+
+
+/* --------------------- CORRESPONDANCE AVEC UNE SUITE D'OCTETS --------------------- */
+
+
+/* Initialise la classe des correspondances de chaînes. */
+static void g_bytes_match_class_init(GBytesMatchClass *);
+
+/* Initialise une instance de correspondance de chaîne trouvée. */
+static void g_bytes_match_init(GBytesMatch *);
+
+/* Supprime toutes les références externes. */
+static void g_bytes_match_dispose(GBytesMatch *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_bytes_match_finalize(GBytesMatch *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Affiche une correspondance sur la sortie standard. */
+static void g_bytes_match_display(const GBytesMatch *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       CORRESPONDANCE AVEC UNE SUITE D'OCTETS                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour un correspondance de chaîne identifiée. */
+G_DEFINE_TYPE(GBytesMatch, g_bytes_match, G_TYPE_SCAN_MATCH);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des correspondances de chaînes.         *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_bytes_match_class_init(GBytesMatchClass *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;
+
+    match = G_SCAN_MATCH_CLASS(klass);
+
+    match->display = (display_scan_match_fc)g_bytes_match_display;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : match = instance à initialiser.                              *
+*                                                                             *
+*  Description : Initialise une instance de correspondance de chaîne trouvée. *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_bytes_match_init(GBytesMatch *match)
+{
+    match->content = NULL;
+
+    match->start = VMPA_NO_PHYSICAL;
+    match->len = VMPA_NO_PHYSICAL;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : match = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_bytes_match_dispose(GBytesMatch *match)
+{
+    g_clear_object(&match->content);
+
+    G_OBJECT_CLASS(g_bytes_match_parent_class)->dispose(G_OBJECT(match));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : match = instance d'objet GLib à traiter.                     *
+*                                                                             *
+*  Description : Procède à la libération totale de la mémoire.                *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_bytes_match_finalize(GBytesMatch *match)
+{
+    G_OBJECT_CLASS(g_bytes_match_parent_class)->finalize(G_OBJECT(match));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : source  = lien vers le motif recherché d'origine.            *
+*                content = contenu binaire présentant un motif reconnu.       *
+*                start   = position de départ d'un motif détecté.             *
+*                len     = taille du motif repéré.                            *
+*                                                                             *
+*  Description : Prend note d'une correspondance trouvée avec un motif.       *
+*                                                                             *
+*  Retour      : Correspondance mise en place.                                *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GScanMatch *g_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);
+
+    if (!g_bytes_match_create(G_BYTES_MATCH(result), source, content, start, len))
+        g_clear_object(&result);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : match   = instance à initialiser pleinement.                 *
+*                source  = lien vers le motif recherché d'origine.            *
+*                content = contenu binaire présentant un motif reconnu.       *
+*                start   = position de départ d'un motif détecté.             *
+*                len     = taille du motif repéré.                            *
+*                                                                             *
+*  Description : Met en place une correspondance trouvée avec un motif.       *
+*                                                                             *
+*  Retour      : Bilan de l'opération.                                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_bytes_match_create(GBytesMatch *match, GSearchPattern *source, GBinContent *content, phys_t start, phys_t len)
+{
+    bool result;                            /* Bilan à retourner           */
+    GScanMatch *base;                       /* Lien vers les infos de base */
+
+    result = true;
+
+    base = G_SCAN_MATCH(match);
+
+    base->source = source;
+    g_object_ref(G_OBJECT(source));
+
+    match->content = content;
+    g_object_ref(G_OBJECT(content));
+
+    match->start = start;
+    match->len = len;
+
+    return result;
+
+}
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
+/* ---------------------------------------------------------------------------------- */
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : match = définition de correspondance à manipuler.            *
+*                                                                             *
+*  Description : Affiche une correspondance sur la sortie standard.           *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_bytes_match_display(const GBytesMatch *match)
+{
+    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          */
+
+    /* Affichage d'un repère */
+
+    base = G_SCAN_MATCH(match);
+
+    name = g_search_pattern_get_name(base->source);
+
+    /**
+     * Les fonctionnalités Yara d'origine autorisent les variables anonymes '$'.
+     *
+     * Cette absence de nom est supportée ici.
+     */
+
+    if (name == NULL)
+        name = "";
+
+    printf("0x%llx:$%s: ", (unsigned long long)match->start, name);
+
+    /* Affichage du contenu */
+
+    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++)
+    {
+        if (isprint(data[i]))
+            printf("%c", data[i]);
+        else
+            printf("\\x%02hhx", data[i]);
+    }
+
+    printf("\n");
+
+}
diff --git a/src/analysis/scan/matches/bytes.h b/src/analysis/scan/matches/bytes.h
new file mode 100644
index 0000000..22e76a6
--- /dev/null
+++ b/src/analysis/scan/matches/bytes.h
@@ -0,0 +1,59 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * bytes.h - prototypes pour la sauvegarde d'une correspondance identifiée de suite d'octets
+ *
+ * Copyright (C) 2022 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_MATCHES_BYTES_H
+#define _ANALYSIS_SCAN_MATCHES_BYTES_H
+
+
+#include <glib-object.h>
+
+
+#include "../match.h"
+#include "../../content.h"
+
+
+
+#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))
+
+
+/* Correspondance trouvée avec une chaîne (instance) */
+typedef struct _GBytesMatch GBytesMatch;
+
+/* Correspondance trouvée avec une chaîne (classe) */
+typedef struct _GBytesMatchClass GBytesMatchClass;
+
+
+/* Indique le type défini pour un correspondance de chaîne identifiée. */
+GType g_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);
+
+
+
+#endif  /* _ANALYSIS_SCAN_MATCHES_BYTES_H */
diff --git a/src/analysis/scan/matches/pending.c b/src/analysis/scan/matches/pending.c
new file mode 100644
index 0000000..700b868
--- /dev/null
+++ b/src/analysis/scan/matches/pending.c
@@ -0,0 +1,202 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * pending.c - consolidation de correspondances partielles
+ *
+ * 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 "pending.h"
+
+
+#include <assert.h>
+#include <malloc.h>
+#include <string.h>
+
+
+#define PENDING_ALLOC_SIZE 10
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : matches = suivi de correspondances à initialiser.            *
+*                                                                             *
+*  Description : Initialise une structure de consolidation de correspondances.*
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void init_pending_matches(pending_matches_t *matches)
+{
+    matches->areas = NULL;
+    matches->allocated = 0;
+    matches->used = 0;
+
+    matches->initialized = false;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : matches = suivi de correspondances à purger.                 *
+*                                                                             *
+*  Description : Libère la mémoire utilisée par une consolidation.            *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void exit_pending_matches(pending_matches_t *matches)
+{
+    if (matches->areas != NULL)
+        free(matches->areas);
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  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.  *
+*                                                                             *
+*  Retour      : Bilan de l'opération : true en cas de succès des recherches. *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool find_target_in_pending_matches(pending_matches_t *matches, phys_t start, size_t *target)
+{
+    bool result;                            /* Bilan à retourner           */
+    size_t i;                               /* Boucle de parcours          */
+    match_area_t *area;                     /* Zone à initialiser          */
+
+    assert(mindex <= matches->used);
+
+    result = false;
+
+    for (i = *target; i < matches->used; i++)
+    {
+        area = &matches->areas[i];
+
+        if ((area->start + area->length) == start)
+        {
+            *target = i;
+            result = true;
+            break;
+        }
+
+    }
+
+    return result;
+
+}
+
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : matches = suivi de correspondances à compléter.              *
+*                start   = point de départ d'une nouvelle correspondance.     *
+*                length  = taille de la zone couverte.                        *
+*                                                                             *
+*  Description : Ajoute au suivi la définition d'une nouvelle correspondance. *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void add_pending_matches(pending_matches_t *matches, phys_t start, phys_t length)
+{
+    match_area_t *area;                     /* Zone à initialiser          */
+
+    if (matches->used == matches->allocated)
+    {
+        matches->allocated += PENDING_ALLOC_SIZE;
+
+        matches->areas = realloc(matches->areas, matches->allocated * sizeof(match_area_t));
+
+    }
+
+    area = &matches->areas[matches->used++];
+
+    area->start = start;
+    area->length = length;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : matches = suivi de correspondances à compléter.              *
+*                target  = indice de la zone de correspondance concernée.     *
+*                length  = taille de la zone couverte supplémentaire.         *
+*                                                                             *
+*  Description : Etend une zone couverte dans le suivi des correspondances.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void extend_pending_matches(pending_matches_t *matches, size_t target, phys_t length)
+{
+    assert(target < matches->used);
+
+    matches->areas[target].length += length;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : matches = suivi de correspondances à modifier.               *
+*                target  = indice de la zone de correspondance concernée.     *
+*                                                                             *
+*  Description : Retire une correspondance finalement non établie du suivi.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+void remove_pending_matches(pending_matches_t *matches, size_t target)
+{
+    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));
+
+    matches->used--;
+
+}
diff --git a/src/analysis/scan/matches/pending.h b/src/analysis/scan/matches/pending.h
new file mode 100644
index 0000000..de2fd5f
--- /dev/null
+++ b/src/analysis/scan/matches/pending.h
@@ -0,0 +1,76 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * pending.h - prototypes pour la consolidation de correspondances partielles
+ *
+ * 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_MATCHES_PENDING_H
+#define _ANALYSIS_SCAN_MATCHES_PENDING_H
+
+
+#include "../../content.h"
+
+
+
+/* Couverture d'une correspondance */
+typedef struct _match_area_t
+{
+    phys_t start;                           /* Point de départ             */
+    phys_t length;                          /* Taille de la zone couverte  */
+
+} match_area_t;
+
+/* Suivi de correspondances */
+typedef struct _pending_matches_t
+{
+    match_area_t *areas;                    /* Zones couvertes             */
+    size_t allocated;                       /* Nombre d'allocations        */
+    size_t used;                            /* Nombre de zones             */
+
+    bool initialized;                       /* Etat du suivi               */
+
+} pending_matches_t;
+
+
+/* Initialise une structure de consolidation de correspondances. */
+void init_pending_matches(pending_matches_t *);
+
+/* Libère la mémoire utilisée par une consolidation. */
+void exit_pending_matches(pending_matches_t *);
+
+#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 *);
+
+/*  Ajoute au suivi la définition d'une nouvelle correspondance. */
+void add_pending_matches(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);
+
+/* Retire une correspondance finalement non établie du suivi. */
+void remove_pending_matches(pending_matches_t *, size_t);
+
+
+
+#endif  /* _ANALYSIS_SCAN_MATCHES_PENDING_H */