path: root/src/analysis/db/server.c

/* Chrysalide - Outil d'analyse de fichiers binaires
 * server.c - mise en place d'un fournisseur d'éléments ajoutés
 *
 * Copyright (C) 2014-2017 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 "server.h"


#include <assert.h>
#include <malloc.h>
#include <netdb.h>
#include <poll.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/un.h>


#include "cdb.h"
#include "keymgn.h"
#include "protocol.h"
#include "misc/rlestr.h"
#include "../../common/io.h"
#include "../../common/xdg.h"
#include "../../core/logs.h"
#include "../../core/params.h"



/* Utilisateur enregistré */
typedef struct _registered_user
{
    rle_string author;                      /* Désignation d'utilisateur   */
    char *key_file;                         /* Chemin vers sa clef publique*/

} registered_user;

/* Format générique des adresses de connexion */
typedef union _gen_sockaddr_t
{
    struct sockaddr_in inet_addr;           /* Adresse d'écoute IPv4       */
    struct sockaddr_un unix_addr;           /* Adresse d'écoute Unix       */

} gen_sockaddr_t;

#ifndef UNIX_PATH_MAX
#   define UNIX_PATH_MAX 108
#endif

/* Description de serveur à l'écoute (instance) */
struct _GDbServer
{
    GObject parent;                         /* A laisser en premier        */

    registered_user *users;                 /* Liste d'utilisateurs        */
    size_t users_count;                     /* Nombre d'enregistrés        */

    int fd;                                 /* Canal de communication      */
    int domain;                             /* Domaine du canal            */
    gen_sockaddr_t addr;                    /* Adresse d'écoute générique  */
    socklen_t sock_len;                     /* Taille de cette adresse     */
    char *desc;                             /* Désignation du serveur      */

    char *basedir;                          /* Répertoire de stockage      */

    GThread *listener;                      /* Procédure de traitement     */

    GList *archives;                        /* Liste des binaires ouverts  */
    GMutex mutex;                           /* Verrou pour l'accès         */

};

/* Description de serveur à l'écoute (classe) */
struct _GDbServerClass
{
    GObjectClass parent;                    /* A laisser en premier        */

};


/* Initialise la classe des descriptions de fichier binaire. */
static void g_db_server_class_init(GDbServerClass *);

/* Initialise une description de fichier binaire. */
static void g_db_server_init(GDbServer *);

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

/* Supprime toute trace d'utilisateur inscrit. */
static void g_db_server_unregister_all_user(GDbServer *);

/* Inscrit un nouvel utilisateur comme étant enregistré. */
static bool g_db_server_register_user(GDbServer *, const char *, char *);

/* Inscrit un nouvel utilisateur comme étant enregistré. */
static bool g_db_server_is_registered_user(GDbServer *, const rle_string *, unsigned char *);

/* Assure l'accueil des nouveaux clients. */
static void *g_db_server_listener(GDbServer *);



/* Indique le type défini pour une description de serveur à l'écoute. */
G_DEFINE_TYPE(GDbServer, g_db_server, G_TYPE_OBJECT);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des descriptions de fichier binaire.    *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_db_server_class_init(GDbServerClass *klass)
{
    GObjectClass *object;                   /* Autre version de la classe  */

    object = G_OBJECT_CLASS(klass);

    object->finalize = (GObjectFinalizeFunc)g_db_server_finalize;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : server = instance à initialiser.                             *
*                                                                             *
*  Description : Initialise une description de fichier binaire.               *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_db_server_init(GDbServer *server)
{
    server->fd = -1;

    g_mutex_init(&server->mutex);

}


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

static void g_db_server_finalize(GDbServer *server)
{
    g_db_server_unregister_all_user(server);

    free(server->desc);

    G_OBJECT_CLASS(g_db_server_parent_class)->finalize(G_OBJECT(server));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : author = utilisateur à représenter via le client.            *
*                kfile  = clef menant à sa clef publique.                     *
*                                                                             *
*  Description : Prépare un serveur de BD pour les clients internes.          *
*                                                                             *
*  Retour      : Structure mise en place ou NULL en cas d'échec.              *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GDbServer *g_db_server_new_internal(const char *author, char *kfile)
{
    GDbServer *result;                      /* Adresse à retourner         */
    bool ret;                               /* Bilan d'un appel            */
    char *suffix;                           /* Suffixe pour un fichier     */
    char *sock_path;                        /* Chemin vers le canal UNIX   */

    result = g_object_new(G_TYPE_DB_SERVER, NULL);

    /* Chargement du profil */

    ret = g_db_server_register_user(result, author, kfile);
    if (!ret) goto gdsni_error;

    /* Détermination du point d'écoute */

    result->domain = AF_UNIX;

    asprintf(&suffix, "chrysalide" G_DIR_SEPARATOR_S ".internal_server.%d", getpid());
    sock_path = get_xdg_config_dir(suffix);
    free(suffix);

    memset(&result->addr, 0, sizeof(struct sockaddr_un));

    result->addr.unix_addr.sun_family = AF_UNIX;
    strncpy(result->addr.unix_addr.sun_path, sock_path, UNIX_PATH_MAX - 1);

    free(sock_path);

    result->sock_len = sizeof(struct sockaddr_un);

    /* Désignation humaine */

    asprintf(&result->desc, "unix://.internal_server.%d", getpid());

    /* Répertoire de stockage */

    result->basedir = get_xdg_config_dir("chrysalide" G_DIR_SEPARATOR_S "cdbs");

    return result;

 gdsni_error:

    g_object_unref(G_OBJECT(result));

    return NULL;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : conf = fichier de configuration à interpréter.               *
*                                                                             *
*  Description : Prépare un serveur de BD pour les clients distants.          *
*                                                                             *
*  Retour      : Structure mise en place ou NULL en cas d'échec.              *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GDbServer *g_db_server_new_remote(const char *conf)
{
    GDbServer *result;                      /* Adresse à retourner         */

    char *host;
    short port;


    struct hostent *hp;                     /* Informations sur l'hôte     */
    size_t desclen;                         /* Taille de désignation       */
    const char *ip;                         /* Adresse IPv4 ou IPv6        */

    result = g_object_new(G_TYPE_DB_SERVER, NULL);

    /* Chargement des profils */


    /*
    ret = g_db_server_register_user(result, author, kfile);
    if (!ret) goto gdsni_error;
    */

    result->domain = AF_INET;

    host = "localhost";
    port = 9999;


    /* Détermination du point d'écoute */

    hp = gethostbyname(host);
    if (hp == NULL)
    {
        perror("gethostbyname");
        goto gdsn_error;
    }

    result->addr.inet_addr.sin_family = hp->h_addrtype;
    memcpy(&result->addr.inet_addr.sin_addr, hp->h_addr_list[0], sizeof(struct in_addr));

    result->addr.inet_addr.sin_port = htons(port);

    result->sock_len = sizeof(struct sockaddr_in);

    desclen = INET6_ADDRSTRLEN + 1 + 5 + 1;
    result->desc = (char *)calloc(desclen, sizeof(char));

    ip = inet_ntop(AF_INET, &result->addr.inet_addr.sin_addr, result->desc, INET6_ADDRSTRLEN);
    if (ip == NULL)
    {
        perror("inet_ntop");
        goto gdsn_error;
    }

    /* Désignation humaine */

    snprintf(result->desc + strlen(ip), 1 + 5, ":%hu", port);

    /* Répertoire de stockage */


    result->basedir = strdup("/tmp/"); /* TODO */


    return result;

 gdsn_error:

    g_object_unref(G_OBJECT(result));

    return NULL;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : server = serveur pour les accès distants à manipuler.        *
*                                                                             *
*  Description : Supprime toute trace d'utilisateur inscrit.                  *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_db_server_unregister_all_user(GDbServer *server)
{
    size_t i;                               /* Boucle de parcours          */

    for (i = 0; i < server->users_count; i++)
    {
        exit_rle_string(&server->users[i].author);
        free(server->users[i].key_file);
    }

    if (server->users != NULL)
        free(server->users);

    server->users = NULL;
    server->users_count = 0;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : server = serveur pour les accès distants à manipuler.        *
*                author = utilisateur à représenter via le client.            *
*                kfile  = clef menant à sa clef publique.                     *
*                                                                             *
*  Description : Inscrit un nouvel utilisateur comme étant enregistré.        *
*                                                                             *
*  Retour      : Bilan de l'inscription.                                      *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static bool g_db_server_register_user(GDbServer *server, const char *author, char *kfile)
{
    if (strlen(author) == 0)
        return false;

    server->users = (registered_user *)realloc(server->users,
                                               ++server->users_count * sizeof(registered_user));

    dup_into_rle_string(&server->users[server->users_count - 1].author, author);    /* FIXME : src ? */
    server->users[server->users_count - 1].key_file = kfile;

    return true;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : server = serveur pour les accès distants à manipuler.        *
*                author = utilisateur à représenter via le client.            *
*                sig    = signature d'utilisateur à valider.                  *
*                                                                             *
*  Description : Inscrit un nouvel utilisateur comme étant enregistré.        *
*                                                                             *
*  Retour      : true si l'utilisateur est bien enregistré, false sinon.      *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static bool g_db_server_is_registered_user(GDbServer *server, const rle_string *author, unsigned char *sig)
{
    bool result;                            /* Bilan à retourner           */
    size_t i;                               /* Boucle de parcours          */
    GChecksum *checksum;                    /* Empreinte MD5 à signer      */
    unsigned char md5_digest[16];           /* Empreinte MD5 calculée      */
    RSA *key;                               /* Clef pour la signature      */

    result = false;

    /* Recherche de l'utilisateur */

    for (i = 0; i < server->users_count; i++)
        if (cmp_rle_string(&server->users[i].author, author) == 0)
            break;

    if (i == server->users_count)
        goto gdsiru_exit;

    /* Validation de la signature présentée */

    checksum = g_checksum_new(G_CHECKSUM_MD5);
    g_checksum_update(checksum, (guchar *)get_rle_string(author), get_rle_length(author));
    g_checksum_get_digest(checksum, (guint8 *)md5_digest, (gsize []) { sizeof(md5_digest) });
    g_checksum_free(checksum);

    key = load_rsa_key(server->users[i].key_file, false);
    if (key == NULL) goto gdsiru_exit;

    result = verify_md5_hash(key, md5_digest, sig);

    RSA_free(key);

 gdsiru_exit:

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : server = serveur pour les accès distants à manipuler.        *
*                                                                             *
*  Description : Assure l'accueil des nouveaux clients.                       *
*                                                                             *
*  Retour      : NULL.                                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void *g_db_server_listener(GDbServer *server)
{
    struct pollfd fds;                      /* Surveillance des flux       */
    int ret;                                /* Bilan d'un appel            */
    gen_sockaddr_t peer;                    /* Adresse cliente             */
    int fd;                                 /* Canal établi vers un client */
    const char *ip;                         /* Statut de la conversion     */
    char *peer_name;                        /* Désignation du correspondant*/
    DBError error;                          /* Validation de la connexion  */
    GCdbArchive *archive;                   /* Destinataire final du client*/
    packed_buffer in_pbuf;                  /* Tampon de réception         */
    bool status;                            /* Bilan d'une opération       */
    uint32_t cmd;                           /* Commande initiale lue       */
    uint32_t version;                       /* Version du client lue       */
    rle_string hash;                        /* Empreinte du binaire visé   */
    rle_string user;                        /* Nom d'utilisateur du client */
    unsigned char sig[RSA_USED_SIZE];       /* Signature effectuée         */
    GList *iter;                            /* Boucle de parcours          */
    packed_buffer out_pbuf;                 /* Tampon d'émission           */

    fds.fd = server->fd;
    fds.events = POLLIN | POLLPRI;

    while (1)
    {
        ret = poll(&fds, 1, -1);
        if (ret != 1) continue;

        /* Le canal est fermé, une sortie doit être demandée... */
        if (fds.revents & POLLHUP)
            break;

        if (fds.revents & (POLLIN | POLLPRI))
        {
            fd = accept(server->fd, (struct sockaddr *)&peer, (socklen_t []) { sizeof(gen_sockaddr_t) });
            if (fd == -1)
            {
                perror("accept");
                continue;
            }

            /* Construction d'une représentation */

            if (*((sa_family_t *)&peer) == AF_UNIX)
                peer_name = strdup(server->desc);

            else if (*((sa_family_t *)&peer) == AF_INET)
            {
                peer_name = (char *)calloc(INET6_ADDRSTRLEN + 1 + 5 + 1, sizeof(char));

                ip = inet_ntop(AF_INET, &peer.inet_addr.sin_addr, peer_name, INET6_ADDRSTRLEN);
                if (ip == NULL)
                {
                    perror("inet_ntop");
                    goto gdsl_error;
                }

                snprintf(peer_name + strlen(ip), 1 + 5, ":%hu", ntohs(peer.inet_addr.sin_port));

            }

            error = DBE_NONE;
            archive = NULL;

            /**
             * Le premier "paquet" reçu de la part d'un client doit contenir les informations suivantes :
             *    - la commande 'DBC_HELO'.
             *    - le numéro de version du client.
             *    - l'empreinte du binaire analysé.
             *    - l'identifiant de l'utilisateur effectuant des modifications.
             *    - la signature de l'empreinte MD5 de l'identifiant.
             *
             * Tout ceci est à synchroniser avec la fonction g_db_client_start().
             */

            status = recv_packed_buffer(&in_pbuf, fd);
            if (!status)
            {
                log_variadic_message(LMT_ERROR, _("Error while getting the initial packet from '%s'..."),
                                     peer_name);
                error = DBE_BAD_EXCHANGE;
                goto gdsl_error_sending;
            }

            status = extract_packed_buffer(&in_pbuf, &cmd, sizeof(uint32_t), true);
            if (!status)
            {
                log_variadic_message(LMT_ERROR, _("Error while getting the initial command from '%s'..."),
                                     peer_name);
                error = DBE_BAD_EXCHANGE;
                goto gdsl_error_sending;
            }

            status = extract_packed_buffer(&in_pbuf, &version, sizeof(uint32_t), true);
            if (!status)
            {
                log_variadic_message(LMT_ERROR, _("Error while getting the protocol version from '%s'..."),
                                     peer_name);
                error = DBE_BAD_EXCHANGE;
                goto gdsl_error_sending;
            }

            status = unpack_rle_string(&hash, &in_pbuf);
            if (!status)
            {
                log_variadic_message(LMT_ERROR, _("Error while getting the binary hash from '%s'..."),
                                     peer_name);
                error = DBE_BAD_EXCHANGE;
                goto gdsl_error_sending;
            }

            status = unpack_rle_string(&user, &in_pbuf);
            if (!status)
            {
                log_variadic_message(LMT_ERROR, _("Error while getting the user name from '%s'..."),
                                     peer_name);
                error = DBE_BAD_EXCHANGE;
                goto gdsl_error_sending;
            }

            status = extract_packed_buffer(&in_pbuf, sig, RSA_USED_SIZE, false);
            if (!status)
            {
                log_variadic_message(LMT_ERROR, _("Error while getting the signature from '%s'..."),
                                     peer_name);
                error = DBE_BAD_EXCHANGE;
                goto gdsl_error_sending;
            }

            if (cmd != DBC_HELO)
            {
                log_variadic_message(LMT_ERROR, _("The client from '%s' did not introduce itself!"),
                                     peer_name);
                error = DBE_BAD_EXCHANGE;
                goto gdsl_error_sending;
            }

            if (version != CDB_PROTOCOL_VERSION)
            {
                log_variadic_message(LMT_ERROR, _("The client from '%s' does not use the same protocol: 0x%08x vs 0x%08x..."),
                                     peer_name, be32toh(version), CDB_PROTOCOL_VERSION);
                error = DBE_WRONG_VERSION;
                goto gdsl_error_sending;
            }

            if (is_rle_string_empty(&hash))
            {
                log_variadic_message(LMT_ERROR, _("The submitted binary hash from '%s' is empty!"),
                                     peer_name);
                error = DBE_BAD_EXCHANGE;
                goto gdsl_error_sending;
            }

            if (is_rle_string_empty(&user))
            {
                log_variadic_message(LMT_ERROR, _("No user is associated with the client from '%s'..."),
                                     peer_name);
                error = DBE_BAD_EXCHANGE;
                goto gdsl_error_sending;
            }

            if (!g_db_server_is_registered_user(server, &user, sig))
            {
                log_variadic_message(LMT_ERROR, _("This user is not registered."));
                error = DBE_BAD_EXCHANGE;
                goto gdsl_error_sending;
            }

            /**
             * On met en place le maximum ici, de manière à pouvoir indiquer une erreur
             * en cas d'échec, et être le plus précis possible dans la courte réponse.
             */

            assert(error == DBE_NONE);

            for (iter = g_list_first(server->archives);
                 iter != NULL;
                 iter = g_list_next(iter))
            {
                archive = G_CDB_ARCHIVE(iter->data);
                if (g_cdb_archive_compare_hash(archive, &hash) == 0)
                    break;
            }

            if (iter == NULL)
                archive = g_cdb_archive_new(server->basedir, &hash, &user, &error);

            /**
             * Le serveur doit répondre pour un message type :
             *    - la commande 'DBC_WELCOME'.
             *    - un identifiant d'erreur ('DBE_NONE', 'DBE_BAD_EXCHANGE'
             *      ou 'DBE_WRONG_VERSION' ... 'DBE_LOADING_ERROR').
             */

 gdsl_error_sending:

            exit_packed_buffer(&in_pbuf);

            init_packed_buffer(&out_pbuf);

            status = extend_packed_buffer(&out_pbuf, (uint32_t []) { DBC_WELCOME }, sizeof(uint32_t), true);
            if (!status) goto gdsl_error;

            status = extend_packed_buffer(&out_pbuf, (uint32_t []) { error }, sizeof(uint32_t), true);
            if (!status) goto gdsl_error;

            status = send_packed_buffer(&out_pbuf, fd);
            if (!status) goto gdsl_error;

            exit_packed_buffer(&out_pbuf);

            /**
             * L'ajout dans la liste des clients connectés provoque un envoie de mises à jour.
             * L'éventuelle erreur survenant pendant l'envoi ne peut donc pas être remontée
             * lors des échanges initiaux, car ces derniers seraient alors précédés des mises à jour...
             */

            if (archive != NULL)
            {
                assert(error == DBE_NONE);

                server->archives = g_list_append(server->archives, archive);
                error = g_cdb_archive_add_client(archive, fd, &user);

                free(peer_name);

                exit_rle_string(&hash);
                exit_rle_string(&user);

                continue;

            }

            assert(error != DBE_NONE);

 gdsl_error:

            exit_packed_buffer(&out_pbuf);

            free(peer_name);

            exit_rle_string(&hash);
            exit_rle_string(&user);

            close(fd);

        }

    }

    return NULL;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : server = serveur pour les accès distants à manipuler.        *
*                                                                             *
*  Description : Démarre le serveur de base de données.                       *
*                                                                             *
*  Retour      : Bilan de l'opération.                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

bool g_db_server_start(GDbServer *server)
{
    int ret;                                /* Bilan d'un appel            */
    int backlog;                            /* Nombre de connexions maximal*/

    server->fd = socket(server->domain, SOCK_STREAM, 0);
    if (server->fd == -1)
    {
        perror("socket");
        return false;
    }

    ret = setsockopt(server->fd, SOL_SOCKET, SO_REUSEADDR, (int []) { 1 }, sizeof(int));
    if (ret == -1)
    {
        perror("setsockopt");
        exit(0);
        goto gdss_error;
    }

    ret = bind(server->fd, (struct sockaddr *)&server->addr, server->sock_len);
    if (ret == -1)
    {
        perror("bind");
        goto gdss_error;
    }

    if (!g_generic_config_get_value(get_main_configuration(), MPK_SERVER_BACKLOG, &backlog))
        goto gdss_error;

    ret = listen(server->fd, backlog);
    if (ret == -1)
    {
        perror("listen");
        goto gdss_error;
    }

    server->listener = g_thread_new("cdb_listener", (GThreadFunc)g_db_server_listener, server);

    log_variadic_message(LMT_PROCESS, _("Server started and listening at %s"), server->desc);

    return true;

 gdss_error:

    close(server->fd);
    server->fd = -1;

    return false;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : server = serveur pour les accès distants à manipuler.        *
*                                                                             *
*  Description : Arrête le serveur de base de données.                        *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_db_server_stop(GDbServer *server)
{
    int ret;                                /* Bilan d'un appel            */

    if (server->fd == -1)
        return;

    ret = shutdown(server->fd, SHUT_RDWR);
    if (ret == -1) perror("shutdown");

    g_thread_join(server->listener);

    ret = close(server->fd);
    if (ret == -1) perror("close");

    server->fd = -1;

    /* TODO : s'occuper des archives ouvertes */

}