// Programa de criptografia basado en metodos de sustitucion. (Anilandro)

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
 
void cripto(char mensaje_ent[10000],char mensaje_sal[10000],char tabla[67],char f,char m, int cod, int lt, int lm,int kk);
void carga(char mensaje_ent[10000],char opcion[20]);
void guarda(char mensaje_ent[10000],char opcion[20]);
void borra(void);

main()
		{

	char tabla[67]={' ',',','.',';',':','0','1','2','3','4','5','6','7',
   	            '8','9','a','b','c','d','e','f','g','h','i','j','k',
		    'l','m','n','o','p','q','r','s','t','u','v','w','x',
		    'y','z','A','B','C','D','E','F','G','H','I','J','K',
		    'L','M','N','O','P','Q','R','S','T','U','V','W','X',
		    'Y','Z'};

   
	char mensaje_ent[10000]={' ','\0'};
	char mensaje_sal[10000]={' ','\0'};
	char mensaje_old[10000]={' ','\0'};
	char mensaje_buf[10000]={' ','\0'};
	char opcion[20];

		float rak[7];
		int clave;
		char m='s',f='a';
    int i,kk=0,cod=0,lm=1,lt=66,imprimir;   // lt Indice del ultimo valor de la tabla 
  
	rak[0]=0;
	system("cls");

	for(i=0;i<20;i++)    // limpia tabla que contiene nombre del fichero
				{
    opcion[i]=' ';
				}

	while (f!='q')
    { 
    cod=0;
    imprimir=1;

    system("cls");
        
    printf("\n\n\n    ************* KRIPTOS ************ ");
    printf("\n\n            - por Anilandro - ");
    printf("\n\n      ** Programa de Encriptacion **");
    printf("\n\n");
    printf("\n      Cargar Fichero de Disco.. (c)   ");
    printf("\n      Guardar Fichero en Disco. (g)   ");
    printf("\n      Borrar Fichero de Disco.. (b)   ");
    printf("\n\n      Crear Texto Activo....... (t)   ");
    printf("\n      Borrar Texto Activo...... (a)   "); 
    printf("\n      Ver Textos Memoria-Activo (v)   "); 
    printf("\n      Intercambiar T. Mem.-Act. (i)   "); 
    printf("\n\n      Cargar Texto de Memoria.. (r)   "); 
    printf("\n      Guardar Texto en Memoria. (m)   "); 
    printf("\n      Borrar Texto de Memoria.. (o)   "); 
    printf("\n\n      Encriptar Texto Activo... (e)   ");
    printf("\n      Desencriptar Texto Activo (d)   ");
    printf("\n\n                      SALIR.... (q)   ");
    printf("\n\n    ********************************** ");


	scanf(" %c",&f); 
	system("cls");
    
	   // NOTA: La funcion oculta crakear no se incluye en el listado (k) 


	if(f=='c')         // llama a funcion de carga de fichero de disco
			  	{
	for(i=0;i<10000;i++)          // guarda mensaje_ent[] en mensaje_old[]
								{
								mensaje_old[i]=mensaje_ent[i];
								}
	carga(mensaje_ent,opcion);
	system("cls");
	printf("\n  FICHERO: %s   TEXTO ACTIVO: \n\n\n%s ",opcion,mensaje_ent);
      
					while(mensaje_ent[lm]!='\0')
					 	{    // Calcula longitud del mensaje de entrada
	lm=lm+1;
						 }   // FIN calcular longitud 
	printf("\n\n\n   El texto tiene una longitud de %d caracteres ",lm); 
	printf("\n\n   Pulse enter para continuar "); 
						getchar();
	getchar();
						system("cls");
 			 	}             

	if(f=='g')         // llama a funcion de guarda fichero en disco
	 			 {
	guarda(mensaje_ent,opcion);
	system("cls");
		 		 }

	if(f=='b')         // llama a funcion de borrar fichero de disco
			 	 {
	borra();
	system("cls");
				  }			

	if(f=='r')			  // Cargar texto de memoria
				{
	for(i=0;i<10000;i++)
					{
					mensaje_ent[i]=mensaje_old[i];
					}
	system("cls");
	printf("\n TEXTO EN MEMORIA: \n\n%s ",mensaje_old);
	printf("\n\n");
	printf("\n TEXTO ACTIVO: \n\n%s ",mensaje_ent);
				  getchar();
				  getchar();
						}

	if(f=='m')			  // Guardar texto en memoria
			 	{
	for(i=0;i<10000;i++)
				{
				mensaje_old[i]=mensaje_ent[i];
				}
	system("cls");
	printf("\n TEXTO EN MEMORIA: \n\n%s ",mensaje_old);
	printf("\n\n");
	printf("\n TEXTO ACTIVO: \n\n%s ",mensaje_ent);
				  getchar();
				  getchar();
				}

				if(f=='o')  // Borrar texto de memoria
				{
	for(i=0;i<10000;i++)
				{
				mensaje_old[i]=' ';
				}
	mensaje_old[0]=' ';
	mensaje_old[1]='\0';
	system("cls");
	printf("\n TEXTO EN MEMORIA: \n\n%s ",mensaje_old);
	printf("\n\n");
	printf("\n TEXTO ACTIVO: \n\n%s ",mensaje_ent);
				  getchar();
				  getchar();
						}


				if(f=='i')  // Intercambiar textos memoria-activo
				 	{
	for(i=0;i<10000;i++)
				{
				mensaje_buf[i]=mensaje_old[i];
				}
	for(i=0;i<10000;i++)
				{
				mensaje_old[i]=mensaje_ent[i];
				}
	for(i=0;i<10000;i++)
				{
				mensaje_ent[i]=mensaje_buf[i];
				}
	system("cls");
	printf("\n TEXTO EN MEMORIA: \n\n%s ",mensaje_old);
	printf("\n\n");
	printf("\n TEXTO ACTIVO: \n\n%s ",mensaje_ent);
				  getchar();
				  getchar();
				}



	if(f=='a')		  // Borrar texto activo
			 	{
	for(i=0;i<10000;i++)
				{
				mensaje_ent[i]=' ';
				}
	mensaje_ent[0]=' ';
	mensaje_ent[1]='\0';
	system("cls");
	printf("\n TEXTO EN MEMORIA: \n\n%s ",mensaje_old);
	printf("\n\n");
	printf("\n TEXTO ACTIVO: \n\n%s ",mensaje_ent);
				  getchar();
				  getchar();
				}

	if(f=='q')		  // Salida del programa
				{
	printf("\n");        
		    return 0;                    	 
      }

	if(f=='t')            // Crear nuevo texto
			  	{
	for(i=0;i<10000;i++)  // guarda mensaje_ent[] en mensaje_old[]
				{
				mensaje_old[i]=mensaje_ent[i];
								}
	printf("\n    Introduzca texto de MAX 10.000 caracteres, y pulse ENTER \n\n");
	printf("    TEXTO ACTIVO: \n\n\n");
	scanf(" %[^\n]",mensaje_ent);    // con %[^\n] se pueden introducir espacios
	lm=0;
			 
	while(mensaje_ent[lm]!='\0')
				{            // Calcula longitud del mensaje de entrada
	lm=lm+1;
				 }                                         
	printf("\n\n\n   El texto tiene una longitud de %d caracteres ",lm); 
	printf("\n\n   Pulse enter para continuar "); 
						getchar();
						getchar();
						system("cls");
						}


	if(f=='v')                // ver mensajes activos
			  	{
	system("cls");
	printf("\n TEXTO EN MEMORIA: \n\n%s ",mensaje_old);
	printf("\n\n");
	printf("\n TEXTO ACTIVO: \n\n%s ",mensaje_ent);
				  getchar();
				  getchar();
			 	 }
			
			 if ((f=='e') || (f=='d'))    // encriptar/desencriptar
				 	{
	for(i=0;i<10000;i++)          // guarda mensaje_ent[] en mensaje_old[]
								{
								mensaje_old[i]=mensaje_ent[i];
								}
	kk=0;                        // indica que no se llama desde crakear
	cripto (mensaje_ent,mensaje_sal,tabla,f,m,cod,lt,lm,kk); // Llama a funcion cripto 
	for(i=0;i<lm;i++)
						 	{
	mensaje_ent[i]=mensaje_sal[i];   // Convierte salida en entrada
							 }
	system("cls");
	printf("\n TEXTO ORIGINAL (EN MEMORIA): \n\n%s ",mensaje_old);
	printf("\n\n");
	printf("\n TEXTO ENCRIPTADO (ACTIVO): \n\n%s ",mensaje_ent);
				  getchar();
				  getchar();
	 	    }
  
	   } 
	return 0;
	}	                               // FIN de programa principal
	 

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void borra(void)       // Funcion borra archivo
	{

	char opcion[20];
	char cer;

	printf("\n\n");
	system("dir/b *.txt");       // lista los archivos del directorio
    
	printf("\n Introduzca nombre de fichero");
	printf("\n o 'q' para regresar al menu ");
	printf("\n\n Nombre: ");
	scanf(" %s",opcion);         

	if(opcion[0]!='q')
				{
		  printf("\n\n Esta seguro de querer borrarlo s/n ? : ");
		  scanf(" %c",&cer);
	if(cer=='s') remove(opcion);
				}

	}

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                      
                      // Funcion de carga de texto desde ficheros de disco 

void carga(char mensaje_ent[10000],char opcion[20])
		{
    
	FILE *f;                   // declara un fichero llamado f
  
	printf("\n\n");
	system("dir/b *.txt");       // lista los archivos del directorio
    
	printf("\n Introduzca nombre de fichero");
	printf("\n o 'q' para regresar al menu ");
	printf("\n\n Nombre: ");
	scanf(" %s",opcion);   
    
	if(opcion[0]!='q')
				{

	f=fopen(opcion,"r");        // abre archivo para lectura
	if(f==NULL)
						{
	printf("Error al intentar abrir el archivo\n");
	return;
						}
	else
				 			{
	fgets(mensaje_ent,9999,f);	 // recupera mensaje_ent
								}
	fclose(f);
						} 

	printf("\n\n");        

	}
    
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


                     // Funcion guarda texto en ficheros de disco 

void guarda(char mensaje_ent[10000],char opcion[20])
	{

	FILE *f;             // crea un fichero llamado f
    
	printf("\n\n");	 
	system("dir/b *.txt");   // lista los archivos del directorio
	printf("\n\n");

	printf("\n Introduzca nombre de fichero");
	printf("\n o 'q' para regresar al menu ");
	printf("\n\n Nombre: ");
	scanf(" %s",opcion);    
   
	if(opcion[0]=='q')
		{
	return;  // vuelve a menu principal    
		}
	else
		{
	f=fopen(opcion,"w");      // abre archivo para escritura
	if(f==NULL)
		{
	printf("Error al intentar crear el archivo\n");
	return;
		}
	else
		{
	fputs(mensaje_ent,f);	  // guarda mensaje_ent
		}
	fclose(f);
		}
	printf("\n\n");

	}

// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

     
                             // Funcion CRIPTO
  
  
void cripto(char mensaje_ent[10000],char mensaje_sal[10000],char tabla[67],char f,char m, int cod, int lt, int lm,int kk)
		{ 


	int im=0,it=0,pcod=0,cambiado;
	float dato;

	// im Indice de cadena mensaje de entrada
	// it Indice de cadena tabla
	// lm Indice de conteo de logitud de mensaje
	 
 

	if(kk==0)
		{
	if((f=='e') || (f=='d'))
						{
	printf("\n\n     RUTINA DE ENCRIPTACION elija metodo:   ");
	printf("\n\n     - Metodo Simple     - J.Cesar  - (s)   ");
	printf("\n     - Metodo Progresivo - Tritemio - (p)   ");
	printf("\n     - Metodo Complejo   - Aleatix  - (c)   "); 
	scanf(" %c",&m);
	do
							 {
	system("cls");
	printf("\n\n\n     CODIGO DE CIFRADO  (1-99.999.999) ");
	printf("\n\n      Introduzca codigo elegido: ");
	scanf(" %d",&cod);
		 }while((cod<1) || (cod>99999999));

	 	}
 	}
	 
	 
	srand(cod);             // utiliza el codigo de cifrado como semilla aleatoria

	for (im=0;im<lm;im++)               // Explora mensaje de entrada
			{                               
	    cambiado=0;
	    for (it=0;it<=lt;it++)            // Explora tabla
			 	{                             
			if (mensaje_ent[im]==tabla[it]) // Detecta igualdad
								 	{   
			if (f=='e')                   // INICIO encriptar
			 	{                   
	        if (m=='s')               // Calcula salto simple (J.Cesar) 
				{               
				pcod=it+cod;
				 }
			if (m=='p')               // Calcula salto progresivo (Tritemio)
				{                
				pcod=it+(cod*(im+1));
				 }
			if (m=='c')               // Calcula salto complejo (Aleatix)
				{                
			dato=(float)rand();
			pcod=it+((int)(lt * (dato/(RAND_MAX))));
				 }
			        
											
			while (pcod>lt)
				 	{          // Cierra bucle de tabla arriba>abajo
			pcod=(pcod-1)-lt;
				 }
					 }         // FIN de encriptar

									
			if (f=='d')
				 	{          // INICIO desencriptar
			if (m=='s')                // Calcula salto simple (J.Cesar)
														 	{                      
			pcod=it-cod;
															 }
			if (m=='p')               // Calcula salto progresivo (Tritemio)
																 	{                    
			pcod=it-(cod*(im+1));
																		}
			if (m=='c')               // Calcula salto complejo (Aleatix)
				 	{                
			dato=(float)rand();
			pcod=it-((int)(lt * (dato/(RAND_MAX))));
					 }
													
			while (pcod<0)
				{                     // Cierra bucle de tabla abajo>arriba  
				pcod=(pcod+1)+lt;    
				}
				 }                   // FIN de desencriptar  	
				 
			mensaje_sal[im]=tabla[pcod]; // Realiza sustitucion y carga en cadena_sal 

			cambiado=1;                  // flag indica que caracter ha sido cambiado  		    
					}                                // FIN de detectar igualdad
				 }                   // FIN explora tabla   
		if (cambiado==0)
										{
		mensaje_sal[im]=mensaje_ent[im];  // No sustituye y copia directamente a cadena_sal
					}                                  
 						} // FIN explora mensaje de entrada
 
	    mensaje_sal[im]='\0';                 // Incorpora \0 al final del mensaje


  }                                       // FIN de funcion