Deusexodus

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include "gmp.h"
#include "bibliotheque.h"

#define LENGTH_BITS 256 // defini la taille de la cle en bits
#define HYPOTHESIS  45  // a changer car on utilise maintenant le bibliotheque et le centre se trouve etre environ 45 ou 50

char *cle_de_codage(char key[500], char *cipher, mpz_t *return_key) {               // retouch� le 27/11/07 (v�rifier sur l'utilisation de **cipher)
    int count = -1 ;
    mpz_t current ;                                             // recuperation de la cle dans cette variable
    mpz_t temp ;                                                // temporaire lors de la creation
    mpz_t zero ;                                                // variable bignum egale a 0
    mpz_t grew ;                                                // variable qui sert �  multiplier ou diviser, current ou temp

    mpz_init(zero) ; mpz_init(current) ; mpz_init(temp) ; mpz_init(grew) ; mpz_init(*return_key) ;

    while( key[++count] != '\0' ) {
        mpz_add_ui(temp, zero, (unsigned long int)( (int)key[count] ) ) ;

        if( mpz_cmp(current, zero) != 0 )
            mpz_mul(current, current, temp) ;
        else
            mpz_set(current, temp) ;

        mpz_init(temp) ;
    }                                                   // recuperation des caracteres un par un pour d�finir une valeur directe de la cle

    printf("La conversion de %s donne : ", key) ;
    gmp_printf("%Zd\n", current) ;                                      // affichage (juste pour le debug)

    mpz_nextprime(current ,current) ;                                   // definition du premier nombre premier suivant a 'current'

    printf("Votre cle rotative de %d bits sera donc : ", (int)mpz_sizeinbase(current, 2)) ;
    gmp_printf("%Zd\n", current) ;                                      // affichage [a modifier le type d'affichage et de nommage]

    cipher = (char *)malloc(((int)mpz_sizeinbase(current, 10) + 1)*sizeof(char)) ;              // creation de la variable cipher
    cipher = mpz_get_str(cipher, 10, current) ;                                 // variable cipher (tableau de caractere contenant des chiffres)

    mpz_add_ui(grew, zero, 10 + (unsigned long int)(cipher[count=0] - '0')) ;               // attribution du "multiplicateur" variant de 10 a 19

    while( (int)mpz_sizeinbase(current, 2) < LENGTH_BITS ) {                        // grandissement pseudo-al�atoire
        mpz_set(temp, current) ;
        mpz_add_ui(grew, zero, 10 + (unsigned long int)(cipher[(++count) % strlen(cipher)] - '0')) ;    // cipher genere la pseudo-aleatoirite // ERREUR ???????
        mpz_mul(current, current, grew) ;
    }

    mpz_nextprime(current ,current) ;                                   // apres l'adaptation de la taille de la cle au nombre de bit que l'on veut, passage au nombre premier suivant
    printf("La cle de codage de %d bits (en realite de %d) est : \n", LENGTH_BITS, (int)mpz_sizeinbase(current, 2)) ;   gmp_printf("%Zd\n", current) ; // affichage final

    mpz_set(*return_key, current) ;

    return cipher ;
}

void encrypt(char *cipher, mpz_t key, int *bibliotheque) {                          // modification effectuee le 27/11/07
    FILE *input = NULL, *output = NULL ;
    char name_input[20] = "entree.log", name_output[20] = "sortie.log", temp ;
    int count = -1 ;
    unsigned long int result = 0;
    mpz_t resultat ;

    mpz_init(resultat) ;

    input = fopen(name_input, "r") ;

    if(input == NULL)                                           // v�rification de presence de input
        printf("Le fichier d'entree n'est pas present.\n") ;
    else
        printf("Le fichier d'entree est present, poursuite de la procedure.\n") ;

    output = fopen(name_output, "w") ;                                  // pas de verification car l'option "w" overwrite s'il existe et le cree sinon

    while( (temp = fgetc(input)) != EOF) {                                  // obtention des caracteres pas a pas
        mpz_mod_ui(resultat, key, recherche_bibliographique(temp, bibliotheque)) ;                  // modulo
        gmp_printf("%Zd\n", resultat) ;
//      mpz_add_ui(resultat, resultat, (unsigned long int)(cipher[(++count) % strlen(cipher)] - '0') ) ;    // plus la variable cipher // sens de count et cipher a definir
        gmp_printf("%Zd\n", resultat) ;
        result = passage_bibliographique(mpz_get_ui(resultat), bibliotheque) ;                  // sortie du resultat // chiffrement effectif avec passage par bibliotheque (pour equivalence)

        printf("Conversion de : %c en %c.\n", temp, (char)result) ;                     // affichage
        fprintf(output, "%c", (char)result) ;                               // envoi dans le fichier de sortie
    }
    fclose(input) ; fclose(output) ;                                    // fermeture des fichiers l'action de cryptage est terminee
}

void decrypt(char *cipher, mpz_t key, int bibliotheque[]) {                             // PARITE NON MISE A JOUR : RECONSTRUCTION EN COURS
    FILE *input = NULL, *output = NULL ;
    char name_input[20] = "sortie.log", name_output[20] = "test.log", temp ;
    int count = 0 ;
    unsigned long int result = 0 ;
    int difference ;
    mpz_t resultat ;

    mpz_init(resultat) ;
    input = fopen(name_input, "r") ;

    if(input == NULL)                                           // test de presence du fichier d'entree
        printf("Le fichier d'entree n'est pas present.\n") ;
    else
        printf("Le fichier d'entree est present, poursuite de la procedure.\n") ;

    output = fopen(name_output, "w") ;                                  // creation du fichier de sortie

    while( (temp = fgetc(input)) != EOF) {                                  // meme fonctionnement que encrypt initialement
        mpz_mod_ui(resultat, key, recherche_bibliographique(HYPOTHESIS, bibliotheque)) ;
        mpz_add_ui(resultat, resultat, (unsigned long int)(cipher[(++count) % strlen(cipher)] - '0')) ;
        result = passage_bibliographique(mpz_get_ui(resultat), bibliotheque) ;

        difference = (int)temp - (int)result ;                              // cas qui differe avec la difference

        printf("Conversion de : %c en %c.\n", temp, (char)(HYPOTHESIS + difference)) ;
        fprintf(output, "%c", (char)(HYPOTHESIS + difference) ) ;                   // si pas trop valable rajoute une boucle de verification qui fera du proche en proche
    }
    fclose(input) ; fclose(output) ;                                    // fermeture des fichiers : tous les caracteres ont ete lus
}

int main(void) {
    char *cipher, init_key[500], done = 0 ;
    mpz_t key ;
    int choice, state_biblio, *bibliotheque ;

    printf("Veuillez entrer votre cle de cryptage (cle forte) : ") ;
    fgets(init_key, sizeof(init_key), stdin) ; init_key[strlen(init_key)-1] = '\0' ;

    cipher = cle_de_codage(init_key, cipher, &key) ;
    bibliotheque = create_bibliotheque(bibliotheque) ;

    if(state_biblio == 1)
        done = 1 ;                                          // faudra rajouter les printf pour montrer l'erreur

    while(choice != 3 && done == 0) {
        printf( "+---------------------------------------------------+\n"
                "|                                                   |\n"
                "|  Veuillez choisir une action a effectuer :        |\n"
                "|                                                   |\n"
                "+---------------------------------------------------+\n"
                "|                                                   |\n"
                "|  1) Encrypter un texte avec la cle de codage      |\n"
                "|  2) Decrypter le texte avec la cle de codage      |\n"
                "|  3) Ne rien faire (habeas corpus)                 |\n"
                "|                                                   |\n"
                "+---------------------------------------------------+\n") ;
        printf("Choix : ") ;
        scanf("%d", &choice) ;

        switch(choice) {
            case 1 : encrypt(cipher, key, bibliotheque) ;
                   done = 1 ;
                   break ;

            case 2 : decrypt(cipher, key, bibliotheque) ;
                   done = 1 ;
                   break ;

            case 3 : break ;

            default : printf("Vous avez du vous tromper ! Retappez votre saisie.\n") ;
                  break ;
        }
    }
    return 0 ;
}