/*
 
    Utilidad que cifra ficheros basandose en el cifrado de Beaufort con claves multiples
 
    Al ultilzar claves multiples, la longitud de la clave resultante sera el minimo comun
multiplo de todas las claves utilizadas.
 
    cifra +|- "claves" fichero_de_entrada fichero_de_salida
 
    +: cifrar
    -: descifrar
 
*/
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
/* funcion que guarda en tokens las palabras contenidas en s y devuelve el numero de parabras extraidas */
int tokenize(char *s, char ***tokens);
 
/* carga en (*s) el contenido del fichero al que apunta f */
unsigned long cargar_fichero(FILE *f, unsigned char** s);
 
/*
 
calcula el coeficiente nsimo segun el siguiene criterio:
 
ultima_clave[posicion % longitud ultima_clave] -
penultima_clave[posicion % longitud penuultima_clave] +
antepenultima_clave[posicion % longitud antepenultima_clave] +
... + o - (segun el numero de claves) primera_clave[posicion % longitud primera_clave]
*/
int coeficiente(unsigned long posicion, char **claves, int nclaves);
 
/*
    cifrado[i] = coeficiente[i] + o - (depende del numero de claves) texto_plano[i] mod 256;
 
    tomando la clase de quivalencia positiva entre 0 y 255
*/
int cifrar(unsigned char *s, unsigned long longitud, char **claves, int nclaves);
 
 
/*
    texto_plando[i] = 1 o (-1) (depende del numero de claves) * (cifrado[i] - coeficiente[i]) mod 256;
 
    tomando la clase de quivalencia positiva entre 0 y 255
*/
int descifrar(unsigned char *s, unsigned long longitud, char **claves, int nclaves);
 
/*
 
    las siguientes funciones calculan el minimo comun multiplo y maximo comun divisor de dos enteros
 
*/
unsigned long mcm(unsigned long a, unsigned long b);
unsigned long mcd(unsigned long a, unsigned long b);
 
int main(int argc, char *argv[])
{
    FILE *f; /* fichero de entrada y de salida */
    char **claves = NULL; /* variable para guardar las claves introducidas */
    unsigned char *contenido = NULL; /* puntero para almacenar el contenido del fichero */
    unsigned long longitud, nclaves; /* longitud del fichero y numero de claves introducidas*/
 
    if(argc != 5)
    {
        printf("\ncomando: cifra +|- \"claves\" fic_entrada fic_salida\n\n+: cifrar\n-: descifrar\n");
    }
    else
    {
        if(!(f = fopen(argv[3] , "rb")))
            printf("No se puede abrir el fichero: %s\n", argv[3]);
        else
        {
            if((longitud = cargar_fichero(f,&contenido)) == (unsigned long)(-1))
            {
                printf("Ha ocurrido un error al cargar el contenido del fichero de entrada.\n");
                fclose(f);
            }
            else
            {
                if((nclaves = tokenize(argv[2] , &claves)) != (unsigned long)(-1))
                {
                    if(!strcmp(argv[1],"+"))
                    {
                        if(!cifrar(contenido,longitud,claves,nclaves))
                            printf("\nHa ocurrido un error en el proceso de cifrado.\n");
                        else
                        {
                            if(!(f = fopen(argv[4] , "wb")))
                                printf("No se puede abrir el fichero: %s\n", argv[4]);
                            else
                            {
                                fwrite(contenido,longitud,1,f);
                                fclose(f);
                            }
                        }
 
                        free(contenido);
 
                        for(longitud = 0 ; longitud < nclaves ; longitud++)
                            free(claves[longitud]);
                        free(claves);
                    }
                    else if(!strcmp(argv[1],"-"))
                    {
                        if(!descifrar(contenido,longitud,claves,nclaves))
                            printf("\nHa ocurrido un error en el proceso de descifrado.\n");
                        else
                        {
                            if(!(f = fopen(argv[4] , "wb")))
                                printf("No se puede abrir el fichero: %s\n", argv[4]);
                            else
                            {
                                fwrite(contenido,longitud,1,f);
                                fclose(f);
                            }
                        }
 
                        free(contenido);
 
                        for(longitud = 0 ; longitud < nclaves ; longitud++)
                            free(claves[longitud]);
                        free(claves);
                    }
                    else
                        printf("\ncomando: cifra +|- \"claves\" fic_entrada fic_salida\n\n+: cifrar\n-: descifrar\n");
                }
                else
                {
                    printf("\nHa ocurrido un error al cargar las claves.\n");
                    free(contenido);
                }
            }
        }
    }
 
    return 0;
}
 
unsigned long cargar_fichero(FILE *f,unsigned char **ptr)
{
    unsigned long pos, len;
 
    /* calculamos la longitud del fichero */
    pos = ftell(f);
    fseek(f,0,SEEK_END);
    len = ftell(f);
    fseek(f,pos,SEEK_SET);
 
    /* asignamos tantos bytes como tenga el fichero */
    if(((*ptr) = (unsigned char *) malloc(len * sizeof(unsigned char))) != NULL)
        /* y cargamos el contenido */
        fread((*ptr),len,1,f);
    else
        len = (unsigned long)(-1);
 
    return len;
}
 
int tokenize(char *s, char ***tokens)
{
    char **aux; /* variable auxiliar para ir añadiendo una cadena mas a la lista */
    char *palabra; /* palabra extraida de la cadena s*/
    int npalabras = 0,i; /* numero de palabras y contador para bucles */
 
    /* intentamos leer una palabra */
    palabra = strtok(s," ");
 
    (*tokens) = NULL;
 
    while(palabra)
    {
        /* si se ha encontrado una palabra incrementamos el recuento de palabras*/
        npalabras++;
 
        /* hacemos que aux contenga tantos punteros a char como paralbras haya */
        if(!(aux = (char **) realloc((*tokens) , npalabras * sizeof(char*))))
        {
            for(i = 0 ; i < npalabras - 1 ; i++)
                free((*tokens)[i]);
 
            free(*tokens);
            (*tokens) = NULL;
 
            return -1;
        }
        else
        {
            /* asignamos la ultima palabra leida */
            aux[npalabras - 1] = (char *) malloc(sizeof(char) * (strlen(palabra) + 1));
            strcpy(aux[npalabras - 1] , palabra);
 
            /* y hacemos que la variable de entrada/salida apunte al nuevo conjunto de palabras */
            (*tokens) = aux;
        }
 
        /* intentamos leer la siguiente palabra */
        palabra = strtok(NULL , " ");
    }
 
    return npalabras;
}
 
int coeficiente(unsigned long posicion, char **claves, int nclaves)
{
    int c=0;
    unsigned long j;
 
    for(j = 0 ; j < nclaves ; j++)
    {
        if((nclaves - 1 - j) % 2)
            c -= claves[j][posicion % strlen(claves[j])];
        else
            c += claves[j][posicion % strlen(claves[j])];
    }
 
    return c;
}
 
int cifrar(unsigned char *s, unsigned long longitud, char **claves, int nclaves)
{
    unsigned long i;
    char *clave;
    unsigned long long_clave=1;
 
    /* la longitud de la clave final sera el mcm de las longitudes de las claves */
    for(i = 0 ; i < nclaves ; i++)
        long_clave = mcm(long_clave , strlen(claves[i]));
 
    if(!(clave = (char*) malloc(long_clave * sizeof(char))))
        return 0;
 
    for(i = 0 ; i < long_clave ; i++)
        clave[i] = coeficiente(i,claves,nclaves);
 
    for(i = 0 ; i < longitud ; i++)
        s[i] = (nclaves * 256 + (clave[i % long_clave] + (1 - 2 *(nclaves % 2)) * s[i])) % 256;
 
    free(clave);
 
    return 1;
}
 
int descifrar(unsigned char *s, unsigned long longitud, char **claves, int nclaves)
{
    unsigned long i;
    char *clave;
    unsigned long long_clave=1;
 
    for(i = 0 ; i < nclaves ; i++)
        long_clave = mcm(long_clave , strlen(claves[i]));
 
    if(!(clave = (char*) malloc(long_clave * sizeof(char))))
        return 0;
 
    for(i = 0 ; i < long_clave ; i++)
        clave[i] = coeficiente(i,claves,nclaves);
 
    for(i = 0 ; i < longitud ; i++)
        s[i] = (nclaves * 256 + ((1 - 2 * (nclaves % 2)) * (s[i] - clave[i % long_clave]))) % 256;
 
    free(clave);
 
    return 1;
}
 
unsigned long mcm(unsigned long a, unsigned long b)
{
    return (a * b) / mcd(a,b);
}
 
unsigned long mcd(unsigned long a, unsigned long b)
{
    if(a < b)
    {
        a ^= b;
        b ^= a;
        a ^= b;
    }
 
    if(!b)
        return a;
 
    return mcd(b , a % b);
}
 

cifra + "clave de prueba" prueba cifrado