path: root/src/analysis/scan/matches/bytes.c

/* 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 <assert.h>
#include <ctype.h>
#include <stdio.h>


#include "bytes-int.h"
#include "../patterns/token.h"
#include "../../../common/cpp.h"
#include "../../../core/logs.h"



/* -------------------- CONSERVATION DE CORRESPONDANCES ETABLIES -------------------- */


/* Initialise la classe des séries de correspondances d'octets. */
static void g_scan_bytes_matches_class_init(GScanBytesMatchesClass *);

/* Initialise une instance de série de correspondances trouvées. */
static void g_scan_bytes_matches_init(GScanBytesMatches *);

/* Supprime toutes les références externes. */
static void g_scan_bytes_matches_dispose(GScanBytesMatches *);

/* Procède à la libération totale de la mémoire. */
static void g_scan_bytes_matches_finalize(GScanBytesMatches *);



/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */


/* Dénombre les correspondances enregistrées pour un motif. */
static size_t g_scan_bytes_matches_count(const GScanBytesMatches *);

/* Affiche une correspondance au format texte. */
static void g_scan_bytes_matches_output_to_text(const GScanBytesMatches *, int);

/* Affiche une correspondance au format JSON. */
static void g_scan_bytes_matches_output_to_json(const GScanBytesMatches *, const sized_string_t *, unsigned int, int);



/* ---------------------------------------------------------------------------------- */
/*                      CONSERVATION DE CORRESPONDANCES ETABLIES                      */
/* ---------------------------------------------------------------------------------- */


/* Indique le type défini pour une série de correspondances d'octets identifiées. */
G_DEFINE_TYPE(GScanBytesMatches, g_scan_bytes_matches, G_TYPE_SCAN_MATCHES);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des séries de correspondances d'octets. *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_scan_bytes_matches_class_init(GScanBytesMatchesClass *klass)
{
    GObjectClass *object;                   /* Autre version de la classe  */
    GScanMatchesClass *matches;             /* Version parente de la classe*/

    object = G_OBJECT_CLASS(klass);

    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_bytes_matches_dispose;
    object->finalize = (GObjectFinalizeFunc)g_scan_bytes_matches_finalize;

    matches = G_SCAN_MATCHES_CLASS(klass);

    matches->count = (count_scan_matches_fc)g_scan_bytes_matches_count;

    matches->to_text = (output_scan_matches_to_text_fc)g_scan_bytes_matches_output_to_text;
    matches->to_json = (output_scan_matches_to_json_fc)g_scan_bytes_matches_output_to_json;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : matches = instance à initialiser.                            *
*                                                                             *
*  Description : Initialise une instance de série de correspondances trouvées.*
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_scan_bytes_matches_init(GScanBytesMatches *matches)
{
    matches->areas = NULL;
    matches->count = 0;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : matches = instance d'objet GLib à traiter.                   *
*                                                                             *
*  Description : Supprime toutes les références externes.                     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_scan_bytes_matches_dispose(GScanBytesMatches *matches)
{
    G_OBJECT_CLASS(g_scan_bytes_matches_parent_class)->dispose(G_OBJECT(matches));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : matches = instance d'objet GLib à traiter.                   *
*                                                                             *
*  Description : Procède à la libération totale de la mémoire.                *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_scan_bytes_matches_finalize(GScanBytesMatches *matches)
{
    G_OBJECT_CLASS(g_scan_bytes_matches_parent_class)->finalize(G_OBJECT(matches));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : -                                                            *
*                                                                             *
*  Description : Crée un suivi pour série de correspondances avec des octets. *
*                                                                             *
*  Retour      : Correspondance mise en place.                                *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GScanMatches *g_scan_bytes_matches_new(void)
{
    GScanMatches *result;                   /* Structure à retourner       */

    result = g_object_new(G_TYPE_SCAN_BYTES_MATCHES, NULL);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : matches = suivi de correspondances à manipuler.              *
*                list    = correspondances établies à mémoriser.              *
*                count   = taille de cette liste.                             *
*                                                                             *
*  Description : Intègre une liste de correspondances vérifiées.              *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_scan_bytes_matches_set_list(GScanBytesMatches *matches, match_area_t *list, size_t count)
{
    matches->areas = list;

    matches->count = count;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : matches = suivi de correspondances à consulter.              *
*                index   = indice de la correspondance recherchée.            *
*                                                                             *
*  Description : Fournit les informations relatives à une correspondance.     *
*                                                                             *
*  Retour      : Propritétés de la correspondance visée ou NULL pour un échec.*
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

const match_area_t *g_scan_bytes_matches_get(const GScanBytesMatches *matches, size_t index)
{
    const match_area_t *result;             /* Pointeur à retourner        */

    for_each_match_area(result, matches->areas)
    {
        if (index == 0)
            break;
    }

    assert(index == 0);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : matches = informations de correspondance à consulter.        *
*                index   = indice de la correspondance visée.                 *
*                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_matches_get_location(const GScanBytesMatches *matches, size_t index, phys_t *start, phys_t *end)
{
    phys_t result;                          /* Taille à retourner          */

    result = 0;

    /*
    result = match->len;

    *start = match->start;
    *end = match->start + result;
    */

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : matches = informations de correspondance à consulter.        *
*                                                                             *
*  Description : Retrouve l'origine d'une correspondance à partir d'un indice.*
*                                                                             *
*  Retour      : Version humainement lisible de la combinaison gagnante.      *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

char *g_scan_bytes_matches_get_modifier_path(const GScanBytesMatches *matches)
{
    char *result;                           /* Combinaison à retourner     */
    GBytesToken *pattern;                   /* Autre version du motif      */

    result = NULL;

    /*

    if (match->has_mod_path)
    {
        pattern = G_BYTES_TOKEN(G_SCAN_MATCH(match)->source);
        result = g_bytes_token_get_modifier_path(pattern, match->mod_path_index);
    }

    else
        result = NULL;
    */

    return result;

}



/* ---------------------------------------------------------------------------------- */
/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : matches = suivi de correspondances à consulter.              *
*                                                                             *
*  Description : Dénombre les correspondances enregistrées pour un motif.     *
*                                                                             *
*  Retour      : Quantité de correspondances établies.                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static size_t g_scan_bytes_matches_count(const GScanBytesMatches *matches)
{
    size_t result;                          /* Quantité à retourner        */

    result = matches->count;

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : matches = définition de correspondance à manipuler.          *
*                fd      = canal d'écriture.                                  *
*                                                                             *
*  Description : Affiche une correspondance au format texte.                  *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_scan_bytes_matches_output_to_text(const GScanBytesMatches *matches, int fd)
{
    GScanMatches *base;                     /* Lien vers les infos de base */
    GBinContent *content;                   /* Contenu binaire analysé     */
    const char *name;                       /* Désignation du motif ciblé  */
    match_area_t *iter;                     /* Boucle de parcours #1       */
    char value[2 + ULLONG_MAXLEN];          /* Impression de la position   */
    int ret;                                /* Bilan d'une conversion      */
    vmpa2t pos;                             /* Tête de lecture             */
    phys_t len;                             /* Taille d'une correspondance */
    const bin_t *data;                      /* Accès aux données brutes    */
    phys_t k;                               /* Boucle de parcours #2       */

    base = G_SCAN_MATCHES(matches);

    content = g_scan_context_get_content(base->context);

    name = g_search_pattern_get_name(base->source);

    for_each_match_area(iter, matches->areas)
    {
        /* Position dans le binaire (hexadécimal) */

        ret = snprintf(value, ULLONG_MAXLEN, "0x%llx", (unsigned long long)iter->start);

        if (ret > 0)
            write(fd, value, ret);

        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);

        /**
         * Les fonctionnalités Yara d'origine autorisent les variables anonymes '$'.
         *
         * Cette absence de nom est supportée ici.
         */

        if (name != NULL)
            write(fd, name, strlen(name));

        write(fd, ": ", 2);

        /* Affichage du contenu */

        init_vmpa(&pos, iter->start, VMPA_NO_VIRTUAL);

        len = iter->end - iter->start;

        data = g_binary_content_get_raw_access(content, &pos, len);
        assert(data != NULL);

        for (k = 0; k < 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);

    }

    g_object_unref(G_OBJECT(content));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : matches = 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_matches_output_to_json(const GScanBytesMatches *matches, const sized_string_t *padding, unsigned int level, int fd)
{
    unsigned int i;                         /* Boucle de parcours #1       */
    char value[4 + ULLONG_MAXLEN];          /* Impression de la position   */
    int ret;                                /* Bilan d'une conversion      */
    GScanMatches *base;                     /* Lien vers les infos de base */
    GBinContent *content;                   /* Contenu binaire analysé     */
    match_area_t *iter;                     /* Boucle de parcours #1       */
    vmpa2t pos;                             /* Tête de lecture             */
    phys_t len;                             /* Taille d'une correspondance */
    const bin_t *data;                      /* Accès aux données brutes    */
    phys_t k;                               /* Boucle de parcours #2       */

    /* 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", matches->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);

    base = G_SCAN_MATCHES(matches);

    content = g_scan_context_get_content(base->context);

    for_each_match_area(iter, matches->areas)
    {
        /* Marqueur de début */

        for (i = 0; i < (level + 1); i++)
            write(fd, padding->data, padding->len);

        write(fd, "{\n", 2);

        /* Position dans le binaire (décimal) */

        for (i = 0; i < (level + 2); i++)
            write(fd, padding->data, padding->len);

        write(fd, "\"offset\": ", 10);

        ret = snprintf(value, ULLONG_MAXLEN, "%llu", (unsigned long long)iter->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 + 2); i++)
            write(fd, padding->data, padding->len);

        write(fd, "\"offset_hex\": ", 14);

        ret = snprintf(value, ULLONG_MAXLEN, "\"0x%llx\"", (unsigned long long)iter->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 brut */

        for (i = 0; i < (level + 2); i++)
            write(fd, padding->data, padding->len);

        write(fd, "\"content\": \"", 12);

        init_vmpa(&pos, iter->start, VMPA_NO_VIRTUAL);

        len = iter->end - iter->start;

        data = g_binary_content_get_raw_access(content, &pos, len);
        assert(data != NULL);

        for (k = 0; k < len; k++)
        {
            if (data[k] == '\\')
                write(fd, "\\\\", 2);

            else if (isprint(data[k]))
                write(fd, &data[k], 1);

            else
            {
                write(fd, "\\u", 2);

                /**
                 * Cf. https://datatracker.ietf.org/doc/html/rfc8259#section-7
                 */
                ret = snprintf(value, ULLONG_MAXLEN, "%04hhx", data[k]);

                if (ret > 0)
                {
                    assert(ret == 4);
                    write(fd, value, ret);
                }

                else
                {
                    log_simple_message(LMT_EXT_ERROR, "Error while converting data!");
                    write(fd, "??", 2);
                }

            }

        }

        write(fd, "\",\n", 3);

        /* Affichage du contenu en version humainement lisible */

        for (i = 0; i < (level + 2); i++)
            write(fd, padding->data, padding->len);

        write(fd, "\"content_str\": \"", 16);

        init_vmpa(&pos, iter->start, VMPA_NO_VIRTUAL);

        data = g_binary_content_get_raw_access(content, &pos, len);
        assert(data != NULL);

        for (k = 0; k < len; k++)
        {
            if (data[k] == '\\')
                write(fd, "\\\\", 2);

            else if (isprint(data[k]))
                write(fd, &data[k], 1);

            else
            {
                write(fd, "\\\\x", 3);

                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", 3);

        /* Affichage du contenu brut */

        for (i = 0; i < (level + 2); i++)
            write(fd, padding->data, padding->len);

        write(fd, "\"length\": ", 10);

        ret = snprintf(value, ULLONG_MAXLEN, "%llu", (unsigned long long)len);

        if (ret > 0)
            write(fd, value, ret);

        else
        {
            log_simple_message(LMT_EXT_ERROR, "Error while converting data!");
            write(fd, "-1", 2);
        }

        write(fd, ",\n", 2);

        /* Affichage du contenu brut (hexadécimal) */

        for (i = 0; i < (level + 2); i++)
            write(fd, padding->data, padding->len);

        write(fd, "\"length_hex\": ", 14);

        ret = snprintf(value, ULLONG_MAXLEN, "\"0x%llx\"", (unsigned long long)len);

        if (ret > 0)
            write(fd, value, ret);

        else
        {
            log_simple_message(LMT_EXT_ERROR, "Error while converting data!");
            write(fd, "\"0xffffffffffffffff\"", 20);
        }

        write(fd, "\n", 1);

        /* Marqueur de fin */

        for (i = 0; i < (level + 1); i++)
            write(fd, padding->data, padding->len);

        if (is_last_match_area(iter, matches->areas))
            write(fd, "}\n", 2);
        else
            write(fd, "},\n", 3);

    }

    g_object_unref(G_OBJECT(content));

    for (i = 0; i < level; i++)
        write(fd, padding->data, padding->len);

    write(fd, "]\n", 2);

}