Introduce parameters for scan pattern modifiers.

7 files changed, 523 insertions, 41 deletions

diff --git a/src/analysis/scan/patterns/modifiers/Makefile.am b/src/analysis/scan/patterns/modifiers/Makefile.am
index fe5263c..f66393e 100644
--- a/src/analysis/scan/patterns/modifiers/Makefile.am
+++ b/src/analysis/scan/patterns/modifiers/Makefile.am
@@ -7,7 +7,8 @@ libanalysisscanpatternsmodifiers_la_SOURCES = \
 	list-int.h								\
 	list.h list.c							\
 	plain.h plain.c							\
-	rev.h rev.c
+	rev.h rev.c								\
+	xor.h xor.c
 
 libanalysisscanpatternsmodifiers_la_CFLAGS = $(LIBGOBJ_CFLAGS)
 
diff --git a/src/analysis/scan/patterns/modifiers/hex.c b/src/analysis/scan/patterns/modifiers/hex.c
index cf1583c..da992df 100644
--- a/src/analysis/scan/patterns/modifiers/hex.c
+++ b/src/analysis/scan/patterns/modifiers/hex.c
@@ -56,7 +56,7 @@ static void g_scan_hex_modifier_finalize(GScanHexModifier *);
 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 *);
+static bool g_scan_hex_modifier_transform(const GScanHexModifier *, const sized_binary_t *, size_t, sized_binary_t **, size_t *);
 
 
 
@@ -212,8 +212,9 @@ static char *g_scan_hex_modifier_get_name(const GScanHexModifier *modifier)
 *                                                                             *
 *  Paramètres  : modifier = modificateur à solliciter.                        *
 *                src      = séquence d'octets à traiter.                      *
+*                scount   = quantité de ces séquences.                        *
 *                dest     = nouvelle(s) séquence(s) d'octets obtenue(s) [OUT] *
-*                count    = quantité de ces séquences.                        *
+*                dcount   = quantité de ces séquences.                        *
 *                                                                             *
 *  Description : Transforme une séquence d'octets pour motif de recherche.    *
 *                                                                             *
@@ -223,28 +224,36 @@ static char *g_scan_hex_modifier_get_name(const GScanHexModifier *modifier)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_scan_hex_modifier_transform(const GScanHexModifier *modifier, const sized_binary_t *src, sized_binary_t **dest, size_t *count)
+static bool g_scan_hex_modifier_transform(const GScanHexModifier *modifier, const sized_binary_t *src, size_t scount, sized_binary_t **dest, size_t *dcount)
 {
     bool result;                            /* Bilan d'opération à renvoyer*/
     sized_binary_t *binary;                 /* Raccourci vers le stockage  */
-    size_t i;                               /* Boucle de parcours          */
+    size_t i;                               /* Boucle de parcours #1       */
+    const sized_binary_t *_src;             /* SOurce courante             */
+    size_t k;                               /* Boucle de parcours #2       */
 
     static char *alphabet = "0123456789abcdef";
 
     result = true;
 
-    *dest = malloc(1 * sizeof(sized_binary_t));
-    *count = 1;
+    *dcount = scount;
+    *dest = malloc(*dcount * sizeof(sized_binary_t));
 
     binary = &(*dest)[0];
 
-    binary->len = src->len * 2;
-    binary->data = malloc(binary->len);
-
-    for (i = 0; i < src->len; i++)
+    for (i = 0; i < scount; i++, binary++)
     {
-        binary->data[i * 2 + 0] = alphabet[src->data[i] >> 4];
-        binary->data[i * 2 + 1] = alphabet[src->data[i] & 0xf];
+        _src = src + i;
+
+        binary->len = _src->len * 2;
+        binary->data = malloc(binary->len);
+
+        for (k = 0; k < _src->len; k++)
+        {
+            binary->data[k * 2 + 0] = alphabet[_src->data[k] >> 4];
+            binary->data[k * 2 + 1] = alphabet[_src->data[k] & 0xf];
+        }
+
     }
 
     return result;
diff --git a/src/analysis/scan/patterns/modifiers/list.c b/src/analysis/scan/patterns/modifiers/list.c
index 141fa54..5bf0faa 100644
--- a/src/analysis/scan/patterns/modifiers/list.c
+++ b/src/analysis/scan/patterns/modifiers/list.c
@@ -56,7 +56,7 @@ static void g_scan_modifier_list_finalize(GScanModifierList *);
 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 *);
+static bool g_scan_modifier_list_transform(const GScanModifierList *, const sized_binary_t *, size_t, sized_binary_t **, size_t *);
 
 
 
@@ -345,8 +345,9 @@ static char *g_scan_modifier_list_get_name(const GScanModifierList *modifier)
 *                                                                             *
 *  Paramètres  : modifier = modificateur à solliciter.                        *
 *                src      = séquence d'octets à traiter.                      *
+*                scount   = quantité de ces séquences.                        *
 *                dest     = nouvelle(s) séquence(s) d'octets obtenue(s) [OUT] *
-*                count    = quantité de ces séquences.                        *
+*                dcount   = quantité de ces séquences.                        *
 *                                                                             *
 *  Description : Transforme une séquence d'octets pour motif de recherche.    *
 *                                                                             *
@@ -356,7 +357,7 @@ static char *g_scan_modifier_list_get_name(const GScanModifierList *modifier)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_scan_modifier_list_transform(const GScanModifierList *modifier, const sized_binary_t *src, sized_binary_t **dest, size_t *count)
+static bool g_scan_modifier_list_transform(const GScanModifierList *modifier, const sized_binary_t *src, size_t scount, sized_binary_t **dest, size_t *dcount)
 {
     bool result;                            /* Bilan d'opération à renvoyer*/
     size_t i;                               /* Boucle de parcours #1       */
@@ -366,17 +367,17 @@ static bool g_scan_modifier_list_transform(const GScanModifierList *modifier, co
     size_t k;                               /* Boucle de parcours #2       */
 
     *dest = NULL;
-    *count = 0;
+    *dcount = 0;
 
     for (i = 0; i < modifier->count; i++)
     {
-        result = g_scan_token_modifier_transform(modifier->modifiers[i], src, &extra, &extra_count);
+        result = g_scan_token_modifier_transform(modifier->modifiers[i], src, scount, &extra, &extra_count);
         if (!result) goto exit;
 
-        new = (*dest) + *count;
+        new = (*dest) + *dcount;
 
-        *count += extra_count;
-        *dest = realloc(*dest, *count * sizeof(sized_binary_t)); 
+        *dcount += extra_count;
+        *dest = realloc(*dest, *dcount * sizeof(sized_binary_t));
 
         for (k = 0; k < extra_count; k++, new++)
             copy_szstr(*new, extra[k]);
@@ -389,14 +390,14 @@ static bool g_scan_modifier_list_transform(const GScanModifierList *modifier, co
 
     if (!result)
     {
-        for (i = 0; i < *count; i++)
+        for (i = 0; i < *dcount; i++)
             exit_szstr(dest[i]);
 
         if (*dest != NULL)
             free(*dest);
 
         *dest = NULL;
-        *count = 0;
+        *dcount = 0;
 
     }
 
diff --git a/src/analysis/scan/patterns/modifiers/plain.c b/src/analysis/scan/patterns/modifiers/plain.c
index 5837d46..485bb23 100644
--- a/src/analysis/scan/patterns/modifiers/plain.c
+++ b/src/analysis/scan/patterns/modifiers/plain.c
@@ -56,7 +56,7 @@ static void g_scan_plain_modifier_finalize(GScanPlainModifier *);
 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 *);
+static bool g_scan_plain_modifier_transform(const GScanPlainModifier *, const sized_binary_t *, size_t, sized_binary_t **, size_t *);
 
 
 
@@ -212,8 +212,9 @@ static char *g_scan_plain_modifier_get_name(const GScanPlainModifier *modifier)
 *                                                                             *
 *  Paramètres  : modifier = modificateur à solliciter.                        *
 *                src      = séquence d'octets à traiter.                      *
+*                scount   = quantité de ces séquences.                        *
 *                dest     = nouvelle(s) séquence(s) d'octets obtenue(s) [OUT] *
-*                count    = quantité de ces séquences.                        *
+*                dcount   = quantité de ces séquences.                        *
 *                                                                             *
 *  Description : Transforme une séquence d'octets pour motif de recherche.    *
 *                                                                             *
@@ -223,22 +224,30 @@ static char *g_scan_plain_modifier_get_name(const GScanPlainModifier *modifier)
 *                                                                             *
 ******************************************************************************/
 
-static bool g_scan_plain_modifier_transform(const GScanPlainModifier *modifier, const sized_binary_t *src, sized_binary_t **dest, size_t *count)
+static bool g_scan_plain_modifier_transform(const GScanPlainModifier *modifier, const sized_binary_t *src, size_t scount, sized_binary_t **dest, size_t *dcount)
 {
     bool result;                            /* Bilan d'opération à renvoyer*/
     sized_binary_t *binary;                 /* Raccourci vers le stockage  */
+    size_t i;                               /* Boucle de parcours          */
+    const sized_binary_t *_src;             /* SOurce courante             */
 
     result = true;
 
-    *dest = malloc(1 * sizeof(sized_binary_t));
-    *count = 1;
+    *dcount = scount;
+    *dest = malloc(*dcount * sizeof(sized_binary_t));
 
     binary = &(*dest)[0];
 
-    binary->len = src->len;
-    binary->data = malloc(binary->len);
+    for (i = 0; i < scount; i++, binary++)
+    {
+        _src = src + i;
 
-    memcpy(binary->data, src->data, src->len);
+        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/rev.c b/src/analysis/scan/patterns/modifiers/rev.c
index d22b549..8b931bd 100644
--- a/src/analysis/scan/patterns/modifiers/rev.c
+++ b/src/analysis/scan/patterns/modifiers/rev.c
@@ -56,7 +56,7 @@ static void g_scan_reverse_modifier_finalize(GScanReverseModifier *);
 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 *);
+static bool g_scan_reverse_modifier_transform(const GScanReverseModifier *, const sized_binary_t *, size_t, sized_binary_t **, size_t *);
 
 
 
@@ -212,8 +212,9 @@ static char *g_scan_reverse_modifier_get_name(const GScanReverseModifier *modifi
 *                                                                             *
 *  Paramètres  : modifier = modificateur à solliciter.                        *
 *                src      = séquence d'octets à traiter.                      *
+*                scount   = quantité de ces séquences.                        *
 *                dest     = nouvelle(s) séquence(s) d'octets obtenue(s) [OUT] *
-*                count    = quantité de ces séquences.                        *
+*                dcount   = quantité de ces séquences.                        *
 *                                                                             *
 *  Description : Transforme une séquence d'octets pour motif de recherche.    *
 *                                                                             *
@@ -223,24 +224,32 @@ static char *g_scan_reverse_modifier_get_name(const GScanReverseModifier *modifi
 *                                                                             *
 ******************************************************************************/
 
-static bool g_scan_reverse_modifier_transform(const GScanReverseModifier *modifier, const sized_binary_t *src, sized_binary_t **dest, size_t *count)
+static bool g_scan_reverse_modifier_transform(const GScanReverseModifier *modifier, const sized_binary_t *src, size_t scount, sized_binary_t **dest, size_t *dcount)
 {
     bool result;                            /* Bilan d'opération à renvoyer*/
     sized_binary_t *binary;                 /* Raccourci vers le stockage  */
-    size_t i;                               /* Boucle de parcours          */
+    size_t i;                               /* Boucle de parcours #1       */
+    const sized_binary_t *_src;             /* SOurce courante             */
+    size_t k;                               /* Boucle de parcours #2       */
 
     result = true;
 
-    *dest = malloc(1 * sizeof(sized_binary_t));
-    *count = 1;
+    *dcount = scount;
+    *dest = malloc(*dcount * sizeof(sized_binary_t));
 
     binary = &(*dest)[0];
 
-    binary->len = src->len;
-    binary->data = malloc(binary->len);
+    for (i = 0; i < scount; i++, binary++)
+    {
+        _src = src + i;
 
-    for (i = 0; i < src->len; i++)
-        binary->data[src->len - i - 1] = src->data[i];
+        binary->len = _src->len;
+        binary->data = malloc(binary->len);
+
+        for (k = 0; k < _src->len; k++)
+            binary->data[_src->len - k - 1] = _src->data[k];
+
+    }
 
     return result;
 
diff --git a/src/analysis/scan/patterns/modifiers/xor.c b/src/analysis/scan/patterns/modifiers/xor.c
new file mode 100644
index 0000000..65194ab
--- /dev/null
+++ b/src/analysis/scan/patterns/modifiers/xor.c
@@ -0,0 +1,395 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * xor.c - transormation via opération XOR
+ *
+ * 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 "xor.h"
+
+
+#include <assert.h>
+#include <malloc.h>
+#include <stdint.h>
+#include <string.h>
+
+
+#include "../modifier-int.h"
+
+
+
+/* ----------------------- RECHERCHE D'UN MOTIF DE TEXTE BRUT ----------------------- */
+
+
+/* Initialise la classe des transmissions via opération XOR. */
+static void g_scan_xor_modifier_class_init(GScanXorModifierClass *klass);
+
+/* Initialise une instance de transmission via opération XOR. */
+static void g_scan_xor_modifier_init(GScanXorModifier *);
+
+/* Supprime toutes les références externes. */
+static void g_scan_xor_modifier_dispose(GScanXorModifier *);
+
+/* Procède à la libération totale de la mémoire. */
+static void g_scan_xor_modifier_finalize(GScanXorModifier *);
+
+
+
+/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */
+
+
+/* Fournit le nom d'appel d'un modificateur pour motif. */
+static char *g_scan_xor_modifier_get_name(const GScanXorModifier *);
+
+/* Transforme une séquence d'octets pour motif de recherche. */
+static bool g_scan_xor_modifier_transform(const GScanXorModifier *, const sized_binary_t *, size_t, sized_binary_t **, size_t *);
+
+/* Détermine si un argument est bien toléré par un modificateur. */
+static bool g_scan_xor_modifier_can_handle_arg(const GScanXorModifier *, const modifier_arg_t *);
+
+/* Transforme une séquence d'octets pour motif de recherche. */
+static bool g_scan_xor_modifier_transform_with_arg(const GScanXorModifier *, const sized_binary_t *, size_t, const modifier_arg_t *, sized_binary_t **, size_t *);
+
+
+
+/* ---------------------------------------------------------------------------------- */
+/*                         RECHERCHE D'UN MOTIF DE TEXTE BRUT                         */
+/* ---------------------------------------------------------------------------------- */
+
+
+/* Indique le type défini pour une transormation via une opération XOR. */
+G_DEFINE_TYPE(GScanXorModifier, g_scan_xor_modifier, G_TYPE_SCAN_TOKEN_MODIFIER);
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : klass = classe à initialiser.                                *
+*                                                                             *
+*  Description : Initialise la classe des transmissions via opération XOR.    *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_xor_modifier_class_init(GScanXorModifierClass *klass)
+{
+    GObjectClass *object;                   /* Autre version de la classe  */
+    GScanTokenModifierClass *modifier;      /* Version de classe parente   */
+
+    object = G_OBJECT_CLASS(klass);
+
+    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_xor_modifier_dispose;
+    object->finalize = (GObjectFinalizeFunc)g_scan_xor_modifier_finalize;
+
+    modifier = G_SCAN_TOKEN_MODIFIER_CLASS(klass);
+
+    modifier->get_name = (get_scan_modifier_name_fc)g_scan_xor_modifier_get_name;
+
+    modifier->transform = (transform_scan_token_fc)g_scan_xor_modifier_transform;
+    modifier->can_handle = (can_token_modifier_handle_arg)g_scan_xor_modifier_can_handle_arg;
+    modifier->transform_with = (transform_scan_token_with_fc)g_scan_xor_modifier_transform_with_arg;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : modifier = instance à initialiser.                           *
+*                                                                             *
+*  Description : Initialise une instance de transmission via opération XOR.   *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_xor_modifier_init(GScanXorModifier *modifier)
+{
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : modifier = instance d'objet GLib à traiter.                  *
+*                                                                             *
+*  Description : Supprime toutes les références externes.                     *
+*                                                                             *
+*  Retour      : -                                                            *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static void g_scan_xor_modifier_dispose(GScanXorModifier *modifier)
+{
+    G_OBJECT_CLASS(g_scan_xor_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_xor_modifier_finalize(GScanXorModifier *modifier)
+{
+    G_OBJECT_CLASS(g_scan_xor_modifier_parent_class)->finalize(G_OBJECT(modifier));
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : -                                                            *
+*                                                                             *
+*  Description : Construit un modificateur livrant des octets traités par XOR.*
+*                                                                             *
+*  Retour      : Mécanisme mis en place.                                      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+GScanTokenModifier *g_scan_xor_modifier_new(void)
+{
+    GScanTokenModifier *result;                    /* Structure à retourner       */
+
+    result = g_object_new(G_TYPE_SCAN_XOR_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_xor_modifier_get_name(const GScanXorModifier *modifier)
+{
+    char *result;                           /* Désignation à retourner     */
+
+    result = strdup("xor");
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : modifier = modificateur à solliciter.                        *
+*                src      = séquence d'octets à traiter.                      *
+*                scount   = quantité de ces séquences.                        *
+*                dest     = nouvelle(s) séquence(s) d'octets obtenue(s) [OUT] *
+*                dcount   = 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_xor_modifier_transform(const GScanXorModifier *modifier, const sized_binary_t *src, size_t scount, sized_binary_t **dest, size_t *dcount)
+{
+    bool result;                            /* Bilan d'opération à renvoyer*/
+    sized_binary_t *binary;                 /* Raccourci vers le stockage  */
+    size_t i;                               /* Boucle de parcours #1       */
+    const sized_binary_t *_src;             /* SOurce courante             */
+    long long x;                            /* Boucle de parcours #2       */
+    size_t k;                               /* Boucle de parcours #3       */
+
+    result = true;
+
+    *dcount = scount * 256;
+    *dest = malloc(*dcount * sizeof(sized_binary_t));
+
+    binary = &(*dest)[0];
+
+    for (i = 0; i < scount; i++)
+    {
+        _src = src + i;
+
+        for (x = 0; x <= 0xff; x++, binary++)
+        {
+            binary->len = _src->len;
+            binary->data = malloc(binary->len);
+
+            for (k = 0; k < _src->len; k++)
+                binary->data[k] = _src->data[k] ^ x;
+
+        }
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : modifier = modificateur à solliciter.                        *
+*                arg      = argument de personnalisation.                     *
+*                                                                             *
+*  Description : Détermine si un argument est bien toléré par un modificateur.*
+*                                                                             *
+*  Retour      : Bilan de la consultation : support ou non.                   *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+static bool g_scan_xor_modifier_can_handle_arg(const GScanXorModifier *modifier, const modifier_arg_t *arg)
+{
+    bool result;                            /* Bilan d'opération à renvoyer*/
+
+    switch (arg->type)
+    {
+        case MAT_UNSIGNED_INTEGER:
+            result = (arg->value.u_integer <= UINT8_MAX);
+            break;
+
+        case MAT_RANGE:
+            result = (INT8_MIN <= arg->value.range.start && arg->value.range.end <= INT8_MAX);
+            break;
+
+        default:
+            result = false;
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : modifier = modificateur à solliciter.                        *
+*                src      = séquence d'octets à traiter.                      *
+*                scount   = quantité de ces séquences.                        *
+*                arg      = argument de personnalisation.                     *
+*                dest     = nouvelle(s) séquence(s) d'octets obtenue(s) [OUT] *
+*                dcount   = 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_xor_modifier_transform_with_arg(const GScanXorModifier *modifier, const sized_binary_t *src, size_t scount, const modifier_arg_t *arg, sized_binary_t **dest, size_t *dcount)
+{
+    bool result;                            /* Bilan d'opération à renvoyer*/
+    sized_binary_t *binary;                 /* Raccourci vers le stockage  */
+    size_t i;                               /* Boucle de parcours #1       */
+    const sized_binary_t *_src;             /* SOurce courante             */
+    long long x;                            /* Boucle de parcours #2       */
+    size_t k;                               /* Boucle de parcours #3       */
+
+    result = true;
+
+    switch (arg->type)
+    {
+        case MAT_UNSIGNED_INTEGER:
+
+            *dcount = scount;
+            *dest = malloc(*dcount * sizeof(sized_binary_t));
+
+            binary = &(*dest)[0];
+
+            for (i = 0; i < scount; i++)
+            {
+                _src = src + i;
+
+                binary->len = _src->len;
+                binary->data = malloc(binary->len);
+
+                for (k = 0; k < _src->len; k++)
+                    binary->data[k] = _src->data[k] ^ arg->value.u_integer;
+
+            }
+
+            break;
+
+        case MAT_RANGE:
+
+            *dcount = scount * (arg->value.range.end - arg->value.range.start + 1);
+            *dest = malloc(*dcount * sizeof(sized_binary_t));
+
+            binary = &(*dest)[0];
+
+            for (i = 0; i < scount; i++)
+            {
+                _src = src + i;
+
+                for (x = arg->value.range.start; x <= arg->value.range.end; x++, binary++)
+                {
+                    binary->len = _src->len;
+                    binary->data = malloc(binary->len);
+
+                    for (k = 0; k < _src->len; k++)
+                        binary->data[k] = _src->data[k] ^ x;
+
+                }
+
+            }
+
+            break;
+
+        default:
+            assert(false);
+            result = false;
+
+    }
+
+    return result;
+
+}
diff --git a/src/analysis/scan/patterns/modifiers/xor.h b/src/analysis/scan/patterns/modifiers/xor.h
new file mode 100644
index 0000000..1a3e7e6
--- /dev/null
+++ b/src/analysis/scan/patterns/modifiers/xor.h
@@ -0,0 +1,58 @@
+
+/* Chrysalide - Outil d'analyse de fichiers binaires
+ * xor.h - prototypes pour la transormation via opération XOR
+ *
+ * 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_XOR_H
+#define _ANALYSIS_SCAN_PATTERNS_MODIFIERS_XOR_H
+
+
+#include <glib-object.h>
+
+
+#include "../modifier.h"
+
+
+
+#define G_TYPE_SCAN_XOR_MODIFIER            g_scan_xor_modifier_get_type()
+#define G_SCAN_XOR_MODIFIER(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), G_TYPE_SCAN_XOR_MODIFIER, GScanXorModifier))
+#define G_IS_SCAN_XOR_MODIFIER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), G_TYPE_SCAN_XOR_MODIFIER))
+#define G_SCAN_XOR_MODIFIER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), G_TYPE_SCAN_XOR_MODIFIER, GScanXorModifierClass))
+#define G_IS_SCAN_XOR_MODIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), G_TYPE_SCAN_XOR_MODIFIER))
+#define G_SCAN_XOR_MODIFIER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), G_TYPE_SCAN_XOR_MODIFIER, GScanXorModifierClass))
+
+
+/* Transormation via inversement d'une séquence d'octets (instance) */
+typedef GScanTokenModifier GScanXorModifier;
+
+/* Transormation via inversement d'une séquence d'octets (classe) */
+typedef GScanTokenModifierClass GScanXorModifierClass;
+
+
+/* Indique le type défini pour une transormation via une opération XOR. */
+GType g_scan_xor_modifier_get_type(void);
+
+/* Construit un modificateur livrant des octets traités par XOR. */
+GScanTokenModifier *g_scan_xor_modifier_new(void);
+
+
+
+#endif  /* _ANALYSIS_SCAN_PATTERNS_MODIFIERS_XOR_H */