#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


typedef char* hash;
typedef char* signature;

typedef struct{
  char *n;
  char *e;
  char *d;
} cle;


char * demanderPass()
{
    char * pass1 = malloc(sizeof(char) * 32);
    char pass2[32];

    printf("Veuillez entrez votre mot de passe (8-31 caractères).\n");

    do{
	printf("Password : ");
	fgets(pass1, 32, stdin);
	while(strlen(pass1) < 9){
	    printf("Entre 8 et 31 carcactères svp...\n");
	    printf("Password : ");
	    fgets(pass1, 32, stdin);
	}
	
	printf("Confirm : ");
	fgets(pass2, 32, stdin);
    }while(strcmp(pass1, pass2));

    pass1[9] = '\0';
    return pass1;
}


long  size(int fd)
{
   long savepos, size;
   savepos = lseek(fd, 0, SEEK_CUR);    /* sauvegarder la position  */
   size = lseek(fd, 0, SEEK_END);       /* aller en fin */
   lseek(fd, savepos, SEEK_SET); /* rétablir la position */
   return size;
}

/* taille du fichier */
long  fsize(FILE* fd)
{
   long savepos, size;
   savepos = ftell(fd);          /* sauvegarder la position  */
   fseek(fd, 0, SEEK_END);       /* aller en fin */
   size = ftell(fd);             /* lire la taille */
   fseek(fd, savepos, SEEK_SET); /* rétablir la position */
   return size;
}

/* Transforme une chaine représentant un grand nombre en un nb */
char *parsenb(char * n)
{
    char *result = malloc(sizeof(char) * (strlen(n)+1));
    strcpy(result, n);
    return result;
}

/* Lit une clé (écrite au format de cle2str) dans une chaine de caractères */
cle str2cle(char * str)
{
    cle result;
    int size = strlen(str);
    char * n = malloc(sizeof(char) * (size+1));
    char * np = n;
    char * e = malloc(sizeof(char) * (size+1));
    char * ep = e;
    char * d = malloc(sizeof(char) * (size+1));
    char * dp = d;

    while( *str != '&'){
	*(np++) = *(str++);
    }
    str++;
    *np = '\0';
    while( *str != '&'){
	*(ep++) = *(str++);
    }
    str++;
    *ep = '\0';
    while( *str != '\0'){
	*(dp++) = *(str++);
    }
    *dp = '\0';
   
    result.n = parsenb(n);
    result.e = parsenb(e);
    result.d = parsenb(d);
    free(n); free(e); free(d);
    return result;
}


#include <crypt.h>

/* Explose la chaine str en un champ de bits dans champ */
void exploserChaine(char bloc[64], unsigned char str[8])
{
    unsigned char tmp;
    int i,j;
    for(i=0; i<8; i++){
        tmp = str[i];
        for(j=0; j<8; j++){
            bloc[i*8 + j] = tmp % 2;
            tmp /= 2;
        }
    }
}

/* Réduit un champ de bits en une chaine de caractères */
void reduireChamp(char bloc[64], unsigned char str[8])
{
    unsigned char tmp, tmp2;
    int i, j;
    for(i=0; i<8; i++){
        tmp2 = 1;
        tmp = 0;
        for(j=0; j<8; j++){
            tmp += bloc[i*8 + j]?tmp2:0;
            tmp2 *= 2;
        }
        str[i] = tmp;
    }
}

/* Initialise la clé utilisée par l'algorihme avec le pass */
void creerCle(char * pass)
{
    char key[64];
    exploserChaine(key, pass);
    setkey(key);
}



hash calculerHash(int fd)
{
    hash h = malloc(sizeof(char)*17);
    if(!h){
      return NULL;
    }

    long s = size(fd);
    char * str = malloc(sizeof(char) * (s+1));
    if(!str){
      return NULL;
    }

    int lu = read(fd, str, s);
    if(lu != s){
	fprintf(stderr, "Erreur lors de la lecture du programme.\n");
	return NULL;
    }
    str[s] = '\0';
    free(str);
    return h;
}

/**
 * Décrypte une chaine de caractères encodée avec la fonction crypter.
 */
cle decrypter(unsigned char * s, char * pass)
{
    int r = strlen(s);
    unsigned char * result  = malloc(sizeof(char) * (r+1));
    unsigned char * presult = result;
    int i;
    char champ[64];
    cle res;

    creerCle(pass);
    /* Encodage par bloc de 64 bits */
    while( r > 0 ){
       exploserChaine(champ, s);
       encrypt(champ, 1);
       reduireChamp(champ, presult);
       presult += 8;
       s += 8;
       r -= 8;
    }
    
    presult--;
    while( *presult == '*' ){
	presult--;
    }
    presult++;
    *presult = '\0';
    
    res = str2cle(result);
    free(result);
    return res;
}



/**
 * Calcule la signature d'un fichier et la concatène à la fin du fichier.
 * @param f - fichier à signer
 * @param p - clé privée 
 */
int valider(char * f, cle p)
{
    hash h;
    signature s;

    int fd = open(f, O_RDONLY);
    if(fd==-1){
	fprintf(stderr, "Erreur : impossible d'ouvrir %s en lecture.\n", f);
	return -1;
    }

    h = calculerHash(fd);
    if(!h){
	fprintf(stderr, "Erreur lors du calcul du hash du fichier %s.\n", f);
	return -1;
    }    
    
    return 0;
}

 
char * USAGE = 
"usage : \n"
"%s [-c] -f progName -p privFile\n"
"%s [-c] -p privFile -P pubFile\n"
"%s -a|-s [-P pubFile] -u user\n";

/* Donne la valeur d'une option, NULL si elle est absente
 * str1 est la version courte de l'argument, str2 est la version longue
 */
char * valArg(char * str1, char * str2, int argc, char ** argv)
{
    int i;
    char * result;
    for(i=1; i<argc; i++){
	if( !strcmp(str1, argv[i]) || !strcmp(str2, argv[i]) ){
	    if(i<argc-1){
	      result = malloc(strlen(argv[i+1]) + 1);
	      strcpy(result, argv[i+1]);
	      return result;
	    } else {
		fprintf(stderr, "Erreur : la valeur de l'option n'a pas été précisée\n");
		return NULL;
	    }
	}
    }
    return NULL;
}

/* Indique si un argument est présent */
int estPresent(char * str1, char * str2, int argc, char ** argv)
{
    int i;
    for(i=1; i<argc; i++){
	if( !strcmp(str1, argv[i]) || !strcmp(str2, argv[i]) ){
	    return 1;
	}
    }
    return 0;
}


int main(int argc, char ** argv)
{
    char * progName = valArg("-f", "--fich", argc, argv);
    char * privFile = valArg("-p", "--priv", argc, argv);
    int crypted = estPresent("-c", "--crypt", argc, argv);

    if(progName && privFile){ //Validation d'un programme

	cle * c;
	FILE * cle = fopen(privFile, "r");
	if(!cle){
	    fprintf(stderr, "Erreur : "
		 "le fichier %s n'a pu être ouvert en lecture.\n", privFile);
	    exit(1);
	}

	if(crypted){
	    int s = fsize(cle);
	    char * msg = malloc(sizeof(char) * (s+1));
	    fgets(msg, s+1, cle);
	    *c = decrypter(msg, demanderPass());
	    free(msg);
	} 

	if(valider(progName, *c)){
	    fprintf(stderr, "Erreur lors de la validation de %s.\n", progName);
	    exit(1);
	}
	fclose(cle);
	exit(0);

    } else { //Options incohérentes
	fprintf(stderr, "Erreur, les arguments sont incohérents\n");
	fprintf(stderr, USAGE, argv[0], argv[0], argv[0]);
    }
    return 0;
}