/* chiffre.c : Système simple de chiffrement d'octets inspiré de la méthode PlayFair */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>

#include "chiffre.h"


#ifdef XOR_SIMPLE
static long long CLE = 0xABCD1276FA8745EC; // clé simple de 64 bits

/* Fonction de chiffrement avec xOR, en utilisant une clé fixe de 64 bits. */
void chiffre_xor_simple(char *buf, int l)
{
    long long *debut, *fin;
    debut = (long long*) buf;
    fin = (long long*) (buf + l);

    /* Le chiffrement avec xOR */
    while (debut < fin) *debut++ ^= CLE;

#ifdef TRACE_CH
    if (ori == 0) { // le thread local -> distant
        if (Chiff == 1) printf("Chiffrement l=%d vers %d !\n", l, ntohs(PORTD));
        else printf("Déchiffrement l=%d depuis %d !\n", l, ntohs(PORTL));
    } else { // le fils principal distant -> local
        if (Chiff == 1) printf("Déchiffrement l=%d depuis %d !\n", l, ntohs(PORTD));
        else printf("Chiffrement l=%d vers %d !\n", l, ntohs(PORTL));
    }
#endif
}
#endif

#ifdef XOR_FICHIER
static char *NFCLE = "/tmp/clepass"; // nom du fichier utilisé pour la clé
static char BCLE[LCLE]; // buffer contenant la clé

/* Gestion des clés à partir d'un fichier externe. */
int init_cle_xor_fichier(void)
{
    int fd;

    if ((fd = open(NFCLE, O_RDONLY)) == -1) return -1;
    if (read(fd, BCLE, LCLE) != LCLE) return -1;
    close(fd);
    return 0;
}

/* Fonction de chiffrement avec xOR, en utilisant une clé externe provenant d'un fichier. */
void chiffre_xor_fichier(char *buf, int l)
{
    long long *debut, *fin, *cle, *fin_cle;
    debut = (long long *) buf;
    fin = (long long *) (buf + l);
    cle = (long long *) BCLE;
    fin_cle = (long long *)(BCLE + LCLE);

    /* Le chiffrement avec xOR */
    while (debut < fin) {
        *debut++ ^= *cle++; // équivalent à *debut ^= *cle; debut++; cle++;
        if (cle == fin_cle) cle = (long long *) BCLE;
    }

#ifdef TRACE_CH
    if (ori == 0) { // le thread local -> distant
        if (Chiff == 1) printf("Chiffrement l=%d vers %d !\n", l, ntohs(PORTD));
        else printf("Déchiffrement l=%d depuis %d !\n", l, ntohs(PORTL));
    } else { // le fils principal distant -> local
        if (Chiff == 1) printf("Déchiffrement l=%d depuis %d !\n", l, ntohs(PORTD));
        else printf("Chiffrement l=%d vers %d !\n", l, ntohs(PORTL));
    }
#endif
}
#endif

#ifdef PLAYFAIR
static char table_chiffre[NBO]; /* table des octets à chiffrer */
static char table_bool[NBO] = {0}; /* table pour noter le remplissage des octets */

#ifdef DEBUG
/* Fonction qui affiche la table de chiffrement. */
static void Trace(void)
{
    int i, j;
    unsigned char c;

    fprintf(stderr, "Table de chiffrement:\n");

    for (i = 0; i < LCM; i++) {
        for (j = 0; j < LCM; j++) {
            c = (unsigned char) table_chiffre[(i * LCM) + j];
            if ((c >= ' ') && (c <= '~')) fprintf(stderr, " %c ", c);
            else fprintf(stderr, "%.2x ", c);
        }
        fprintf(stderr, "\n");
    }

    fprintf(stderr, "\n");
}
#endif

void init_table_chiffre(char *cle) /* on passe la clé en parametre */
{
    /* initialisation de la table */
    int i, I = 0, j;
    char c;

    for (i = 0; i < (int) strlen(cle); i++) {
        c = cle[i];
        if (table_bool[(int) c]) continue;
        table_chiffre[I++] = c;
        table_bool[(int) c] = 1;
    }

    /*
    for (i = 0; i < NBO; i++) {
        if (buf2[i]) continue;
        buf[I++] = (char) i;
        buf2[i] = 1;
    }
    */

    for (j = 0; j < SAUT; j++) {
        for (i = j; i < NBO; i += SAUT) {
            if (table_bool[i]) continue;
            table_chiffre[I++] = i;
            table_bool[i] = 1;
        }
    }

#ifdef DEBUG
    Trace();
    for (i = 0; i < NBO; i++) {
        if (table_bool[i]) continue;
        fprintf(stderr, "Valeur %d non affectée !!\n", i);
    }
#endif

}

/* Fonction qui définit les coordonnées d'un caractère à partir de sa position dans la table */
static void coordCar(char C, int *l, int *c)
{
    int i;

    for (i = 0; i < NBO; i++) if (table_bool[i] == C) break;

    *c = i % LCM;
    *l = i / LCM;
}

/* Fonction qui retourne le caractère de la ligne l, colonne c */
static char carLC(int l, int c)
{
    return(table_bool[(l * LCM) + c]);
}

/* fonction qui chiffre directement dans le buffer des données à chiffrer */
void chiffre_playfair(char *B, int T) // B adresse du buf, T le nb d'octets
{
    int i, l1, c1, l2, c2;

    for (i = 0; i < T; i += 2) {
        if (i == T - 1) { /* cas particulier du dernier octet */
            coordCar(B[i], &l1, &c1);
            l1 += 2; /* on descend de 2 lignes */
            if (l1 >= LCM) l1 -= LCM;
            B[i] = carLC(l1, c1);
        } else { /* cas du couple */
            coordCar(B[i], &l1, &c1);
            coordCar(B[i + 1], &l2, &c2);
            if (l1 == l2) { /* sur la même ligne */
                /* on décale vers le haut */
                l1--;
                if (l1 < 0) l1 += LCM;
                B[i] = carLC(l1, c1);
                B[i + 1] = carLC(l1, c2);
            } else if (c1 == c2) { /* sur la même colonne */
                /* on décale vers la droite */
                c1++;
                if (c1 >= LCM) c1 -= LCM;
                B[i] = carLC(l1, c1);
                B[i + 1] = carLC(l2, c1);
            } else { /* on a un rectangle */
                /* schéma
                        c1        c2

                l1      x         b


                l2      a         y

                On fait la permutation x, y => a, b
                **************************************/
                B[i] = carLC(l2, c1);
                B[i + 1] = carLC(l1, c2);
            }
        }
    }
}

/* Fonction inverse de chiffre_playfair, puisque cette fonction n'est pas involutive */
void dechiffre_playfair(char *B, int T) // B adresse du buf, T le nb d'octets
{
    int i, l1, c1, l2, c2;

    for (i = 0; i < T; i += 2) {
        if (i == T - 1) { /* cas particulier du dernier octet */
            coordCar(B[i], &l1, &c1);
            l1 -= 2; /* on monte de 2 lignes */
            if (l1 < 0) l1 += LCM;
            B[i] = carLC(l1, c1);
        } else { /* cas du couple */
            coordCar(B[i], &l1, &c1);
            coordCar(B[i + 1], &l2, &c2);
            if (l1 == l2) { /* sur la même ligne */
                /* on décale vers le bas */
                l1++;
                if (l1 >= LCM) l1 -= LCM;
                B[i] = carLC(l1, c1);
                B[i + 1] = carLC(l1, c2);
            } else if (c1 == c2) { /* sur la même colonne */
                /* on décale vers la gauche */
                c1--;
                if (c1 < 0) c1 += LCM;
                B[i] = carLC(l1, c1);
                B[i + 1] = carLC(l2, c1);
            } else { /* on a un rectangle */
                /* schéma
                        c1        c2

                l1      x         b


                l2      a         y

                On fait la permutation x, y => a, b
                **************************************/
                B[i] = carLC(l2, c1);
                B[i + 1] = carLC(l1, c2);
            }
        }
    }
}
#endif