// 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 f_bruta(char mensaje_ent[10000],char mensaje_sal[10000],char mensaje_old[10000],char tabla[67],char f,char m, int cod, int lt,int lm);
void rank(char mensaje[10000],int lm,float rak[7],char icv);
void sumacadena(char mensaje_sal[10000],char m,int cod,int lm);
void ordenamensaje(char mensaje_sal[10000],char listado[20][10000],float rak[7],int lm,char icv);
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();
		    }

	if (f=='k')         // Llama a funcion f_bruta (crakear codigos) 
			   {				 
	imprimir=0;
		    f='d';
						printf("\n   Opcion incorrecta, entre 'x' para regresar al menu ");
	scanf(" %d",&clave);
						if(clave==1492)
								{
	system("cls");
						printf("\n\n\n                     !! ATENCION !! "); 
		  				printf("\n\n        Ha entrado usted en la opcion reservada de "); 
						printf("\n\n        ROMPEDOR DE CLAVES DE MENSAJES CODIFICADOS ");
	getchar();

		  				f_bruta (mensaje_ent,mensaje_sal,mensaje_old,tabla,f,m,cod,lt,lm);   
								}
	system("cls");
			   }
     
	 
	 
  
	   } 
	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 F_Bruta de crakeo inteligente de mensajes codificados
  
 
void f_bruta(char mensaje_ent[10000],char mensaje_sal[10000],char mensaje_old[10000],char tabla[67],char f,char m, int cod, int lt, int lm)
	{ 

	char listado[20][10000];    // guarda resultados del crakeo
	char mensaje[10000];
	float rak[7]; 
	char x;

	int i,j=0,k,l,fs=20,nc=0,im=0,it=0,pcod=0,lmx=0;
	int kk=1,nresult=0,pos_fix=0,pos=0,ptotal=0,barra=0,abarra=0;
	int numero=0,fiabilidad=0,time=0,atime=0,difseg,diflast;
	int segundos=0,minutos=0,horas=0,dias=0,primera=0,salto=0;
	float ranking1=0,ranking2=0,ranking_mim=0,pf=100;
	int timep;
	float cv;
	char icv;

	nc=67;      // Asignacion directa de ciclos de busqueda para JC y TR

	printf("\n\n\n              Posible idioma del mensaje ");
	printf("\n\n		    Espanol.... (e) ");
	printf("\n		    Ingles..... (i) ");
	printf("\n		    Frances.... (f) ");
	printf("\n		    Catalan.... (c) ");
	scanf(" %c",&icv); 

	printf("\n       LIMITE DE EXPLORACION DEL CODIGO DE CIFRADO ");
	printf("\n            - Maximo 99.999.999 (8 cifras) - ");
	printf("\n\n    !! ATENCION !! Valores altos pueden precisar");
	printf("\n\n            tiempos largos de proceso");
	printf("\n\n  Tabla Orientativa:           (1)     (2)   ");
	printf("\n                       1500.... 1 m.    8 s. ");  
	printf("\n                       6000.... 4 m.   30 s. ");  
	printf("\n                     24.000... 16 m.    2 m. ");  
	printf("\n                    100.000.... 1 h.    8 m. ");  
	printf("\n                    400.000.... 4 h.   32 m. ");  
	printf("\n                  1.600.000... 16 h.    2 h. ");  
	printf("\n                  6.400.000.... 3 d.    8 h. ");  
	printf("\n                 24.000.000... 12 d.  1,5 d. ");  
	printf("\n                 99.000.000... 48 d.    6 d. ");  
	printf("\n\n    (1) Pentium II a 500 Mhz. y mensaje de 1000 caracteres.");  
	printf("\n    (2) Pentium IV a 2.4 Ghz. y mensaje de 1000 caracteres.   ");  
	printf("\n\n               Introduzca valor elegido: ");  
	scanf(" %d",&lmx); 

	printf("\n\n        Filtro de parada forzada de ciclo  0-100 %% ? ");
	scanf(" %f",&pf);

	printf("\n\n        Filtro de fiabilidad de resultados 0-100 %% ? ");
	scanf(" %d",&fiabilidad); 

	printf("\n\n        Desea observar el proceso de busqueda.. s/n ? ");
	scanf(" %c",&x); 
 	
	ptotal=67+67+lmx;
    
	for(i=0;i<20;i++)       // pone espacios vacios en cada registro de listado[]
				{             
		for(j=0;j<10000;j++)
						{
		    listado[i][j]=' ';
						}
			 }

	system("cls");
	printf("\n\n\n          ====================================");
	printf("\n               !!! PROCESANDO CODIGOS !!! ");
	printf("\n          ====================================");
	printf("\n          ");
	printf("\n          ====================================");
	printf("\n             Calculando tiempo restante ... ");  


    
	for (i=0;i<nc*2;i++)    // INICIO bucle de craqueo
		 	{                        
				barra=i*37/ptotal;          // calcula barra de progreso del proceso 
				if(barra>abarra)            // detecta cambio de tamaņo de barra, solo imprinme si es mayor
			 		{
 					time=clock();
	 				difseg=(time-atime);
		 			atime=time;
		diflast=difseg*(37-barra);
		dias=0;
		horas=0;
		minutos=0;
		segundos=diflast/1000;
		if(segundos>60)                // conversion de segundos en minutos-horas-dias
								{
					 		minutos=segundos/60;
						 	segundos=segundos-(minutos*60);
							 }
		if(minutos>60)
								{
						  horas=minutos/60;
						  minutos=minutos-(horas*60);
								}
		if(horas>24)
							{
						  dias=horas/24;
						  horas=horas-(dias*24);
								}
		if(x=='n')
								{
			system("cls");
			printf("\n\n\n          ====================================");
			printf("\n               !!! PROCESANDO CODIGOS !!! ");
			printf("\n          ====================================");
			printf("\n          ");
	for(l=1;l<=barra;l++)
										{
	printf("%c",char(178));
										}
			printf("\n          ====================================");
	if(primera>1)
										{
			printf("\n          Tiempo restante: %d d %d h %d m %d s ",dias,horas,minutos,segundos);
										}						

	primera=primera+1;
	abarra=barra;
								}
						}
			 if(i<nc)            // prueba 67 posibilidades con sistema J. Cesar
						{
	m='s';  
	cod=i;
		}
	else                // prueba 67 posibilidades con sistema Tritemio
						{
	m='p';  
	cod=i-nc;
	}
								
	cripto (mensaje_ent,mensaje_sal,tabla,f,m,cod,lt,lm,kk);  // Llama a funcion de encriptacion/desencriptacion) 
	sumacadena(mensaje_sal,m,cod,lm);               // llama a funcion sumacadena, suma sistema y codigo
	ordenamensaje(mensaje_sal,listado,rak,lm,icv);  // llama a funcion ordenar en listado segun puntos

	if((x=='s')&&(i%10==0))    // solo muestra uno de cada diez textos (para aumentar velocidad)
						{
	system("cls");
	printf("\n TEXTO ORIGINAL \n\n %s ",mensaje_ent);
	printf("\n\n TEXTO RESULTANTE \n\n %s ",mensaje_sal);
						}

	if((x=='s')&&(rak[0]>fiabilidad))  // espera si detecta mensaje > fiabilidad
       {
	system("cls");
	printf("\n TEXTO ORIGINAL \n\n %s ",mensaje_ent);
	printf("\n\n !!! RESULTADO DETECTADO !!!");
	printf("\n\n Fiabilidad: %d %% \n %s ",(int)rak[0],mensaje_sal);
	printf("\a");
	timep=(clock()/1000);
	while(((clock()/1000)-timep)<3);  // Bucle que espera tres segundos             
		}
	if(rak[0]>pf)                       // parada si mensaje > filtro de parada 
							{           
	salto=1;
		break;   
		}
     
			}                        // fin de bucle de crakeo J.Cesar y Tritemio
	 

	primera=0;
		for(i=0;i<lmx;i++)       // prueba lmx posibilidades de crakeo Aleatix 
						{
		barra=(i+67+67)*37/ptotal;
	if(barra>abarra)
							{
		time=clock();
		difseg=(time-atime);
		atime=time;
		diflast=difseg*(37-barra);
		dias=0;
		horas=0;
		minutos=0;
		segundos=diflast/1000;
		if(segundos>60)
				{
				minutos=segundos/60;
				segundos=segundos-(minutos*60);
							}
		if(minutos>60)
							{
				horas=minutos/60;
				minutos=minutos-(horas*60);
							}
		if(horas>24)
							{
				dias=horas/24;
				horas=horas-(dias*24);
							}
		if(x!='s')
							{
		system("cls");
		printf("\n\n\n          ====================================");
		printf("\n               !!! PROCESANDO CODIGOS !!! ");
		printf("\n          ====================================");
		printf("\n          ");
					
	for(l=1;l<=barra;l++)
         {
         printf("%c",char(178));
         }
		printf("\n          ====================================");
	if(primera>1)
         {
				     printf("\n           Tiempo restante: %d d %d h %d m %d s ",dias,horas,minutos,segundos);
         }						
				   primera=primera+1;
				   abarra=barra;	
       }
       }
			 
	m='c';
	cod=i;
	cripto (mensaje_ent,mensaje_sal,tabla,f,m,cod,lt,lm,kk);  // Llama a funcion de encriptacion/desencriptacion) 
	sumacadena(mensaje_sal,m,cod,lm);         // llama a funcion sumacadena, suma sistema y codigo
	ordenamensaje(mensaje_sal,listado,rak,lm,icv);  // llama a funcion ordenar en listado segun puntos

	if((x=='s')&&(i%10==0))          // muestra uno de cada diez
       {
		system("cls");
		printf("\n TEXTO ORIGINAL \n\n %s ",mensaje_ent);
		printf("\n\n TEXTO RESULTANTE \n\n %s ",mensaje_sal);
       }
       
	if((x=='s')&&(rak[0]>fiabilidad))  // espera si detecta mensaje > fiabilidad
       {
		system("cls");
		printf("\n TEXTO ORIGINAL \n\n %s ",mensaje_ent);
		printf("\n\n !!! RESULTADO DETECTADO !!!");
		printf("\n\n Fiabilidad: %d %% \n %s ",(int)rak[0],mensaje_sal);
		printf("\a");
		timep=(clock()/1000);
		while(((clock()/1000)-timep)<3);  // Bucle que espera tres segundos             
       }
	if((rak[0]>pf)||(salto==1))       // parada si mensaje > filtro de parada 
							{           
		salto=1;
		break;   
       }

							
	}               
 
     
      
	system("cls");
	printf("\a");

	printf("\n    RESULTADOS DEL ROMPEDOR DE CLAVES");
	printf("\n\n    TEXTO ORIGINAL: ");
	printf("\n\n %s",mensaje_ent);
	printf("\n\n\n    TEXTO DECODIFICADO: ");
	printf("\n\n");

	for(j=0;j<fs;j++)            // muestra resultados obtenidos
       {                      
		for(k=0;k<lm+14;k++)
         {
         mensaje[k]=listado[j][k];    // carga registro de listado[j] en mensaje[k]
         }
		rank(mensaje,lm,rak,icv);     // llama a rutina de ranking de puntuacion (solo para imprimir)
		cv=rak[1]/rak[0];

		if(rak[4]>fiabilidad)         // Imprime encabezado solo si la fiabilidad es superior a la elegida
							{
		printf("\n %d)  Fiabilidad: %d %% ",j+1,(int)rak[4]);   // imprime datos
							}


		if(rak[4]>fiabilidad)         // Imprime mensaje solo si la fiabilidad es superior a la elegida
							{
		printf("\n ");
		for(k=0;k<lm+14;k++)
									{
		printf("%c",listado[j][k]);   
         } 
		printf("\n");
							}	      
							}     
	 
		printf("\n\n       Desea guardar alguno de los resultados ");
		printf("\n\n  - En caso afirmativo, introduzca el numero de mensaje ");
		printf("\n  - En caso negativo, introduzca un '0' : ");
		scanf(" %d",&numero); 

		if((numero>0) && (numero<21))
			 	 {
		for(i=0;i<10000;i++)              // guarda mensaje_ent[] en mensaje_old[]
					  	{
						  mensaje_old[i]=mensaje_ent[i];
						  }
		for(k=0;k<lm;k++)
				 	 	{
		    mensaje_ent[k]=listado[numero-1][k+14];  // guarda mensaje elegido en mensaje_ent[]
						  }
					 }
  
	}                           // Fin de funcion F_Bruta


// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
              
                   // Funcion ordenar resultados de crakeo por puntuacion

void ordenamensaje(char mensaje_sal[10000],char listado[20][10000],float rak[7],int lm,char icv)
    {
    
	char mensaje[10000];
	int nresult=0,pos_fix=0,pos=0;
	int j,k,l;
	float ranking1,ranking2; 


	for(k=0;k<lm+14;k++)
        {
        mensaje[k]=mensaje_sal[k];     // carga mensaje_sal[] en mensaje[]
        }
    
	rank(mensaje,lm,rak,icv);  		      // funcion que calcula el valor de mensaje
	ranking1=rak[4];                   // primer valor de comparacion
	rak[0]=rak[4];                     // guarda primer valor de rak[4] en rak[0]

	pos_fix=0;
	j=0;
	do
      {                                 // busca el que es menor que mensaje_sal
	for(k=0;k<lm+14;k++)
          {
	      mensaje[k]=listado[j][k];        // carga en mensaje[] el registro j de listado[]
          }
            
		rank(mensaje,lm,rak,icv);         // llama otra vez a funcion ranking
		ranking2=rak[4];                  // segundo valor de comparacion
	  
      					               
	  
		if((ranking1>ranking2)&&(pos_fix==0))
					{             // cuando le encuentra 
			pos=j;                        // guarda posicion de insercion
			pos_fix=1;                    // activa flag para guardar posicion insertar 
			}
			j=j+1;
      
      
			}while((pos_fix==0)&&(j<20));


	if(pos_fix==1)                    // si se ha hallado una posicion de insercion
        {
		for(k=9;k>pos;k--)            // bucle del numero de ciclos de copia. Si pos=9 0 ciclos
										{
			for(l=0;l<lm+14;l++)
             {
				listado[k][l]=listado[k-1][l];   // ciclo de desplazamiento. Ej. pasa de 8 a 9 o 7 a 8
             }
								}
			for(k=0;k<lm+14;k++)
								{ 
				listado[pos][k]=mensaje_sal[k];        // carga mensaje_sal en posicion adecuada
            }
								}
    
	}

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

// calcula el ranking del mensaje decodificado, es decir, las posibilidades que tiene de ser correcto

void rank(char mensaje[10000],int lm, float rak[7],char icv)
		{

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

	int j,k;
	int maxlp,lp,lpc;
	float media,tanto;
	float voc,cons,num,punt,ranking,ranking1;
	
	media=1;
	if(icv=='e') media=float (1.16);  // Castellano
	if(icv=='i') media=float (1.50);  // Ingles
	if(icv=='f') media=float (1.37);  // Frances
	if(icv=='c') media=float (1.20);  // Catalan

	voc=0;
	for(j=14;j<lm+14;j++)     // Cuenta vocales  aei...AEI...
				{          
		for(k=0;k<10;k++)
							{
			if(mensaje[j]==vocales[k])
							{
		       voc=voc+1;
							}
							}
				}
       
		cons=0;
	for(j=14;j<lm+14;j++)     // Cuenta consonantes bcdf...BCDF...
				{          
		for(k=0;k<40;k++)
						{
			if(mensaje[j]==consonantes[k])
								{
			cons=cons+1;
								}
						}
		 	}
								
	num=0;
	for(j=14;j<lm+14;j++)      // Cuenta numeros 012345...
						{          
		for(k=0;k<10;k++)
								{
			if(mensaje[j]==numeracion[k])
								{
		        num=num+1;
								}
								}
					 			}

	punt=0;                       // Cuenta puntuacion ,.:; etc
	for(j=14;j<lm+14;j++)
								{          
		for(k=0;k<5;k++)
								{          
			if(mensaje[j]==puntuacion[k])
								{
		          punt=punt+1;
								}
								}
								}

	lpc=0;    // Flag que indica haber superado la longitud maxima de palabra
	lp=0;
	maxlp=20;
	for(j=14;j<lm+14;j++)         // cuenta longitud de palabra
										{          
		if(mensaje[j]==puntuacion[0]) lp=0;
		lp=lp+1;
		if(lp>maxlp) lpc=1;
										}
      

	voc=voc+float(0.0001);          // es para evitar problemas con las divisiones por 0
	cons=cons+float(0.0001);        // es para evitar problemas con las divisiones por 0
	ranking=(cons/voc);
	ranking1=ranking;
	if(ranking>(media*float(1.999))) ranking=media*float(1.999);
	if(ranking>media) 
         {
		ranking=media-(ranking-media);   // Hace de funcion campana en caso de exceso
         }
		tanto=((ranking*100)/media);
       
	if(tanto<0) tanto=0;
	if((voc<1)&&(cons<1)) tanto=0;
	if(lpc==1) tanto=tanto*float(0.8);   // resta puntos si se supera la maxlp
       
	rak[1]= cons;
	rak[2]= punt;
	rak[3]= num;
	rak[4]= tanto;
	rak[5]= ranking1;
	rak[6]= float (lpc);

       
  } 


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

        // Funcion suma a mensaje_sal una etiqueta identificativa frontal
        // ejemplo: TR ---34  significa metodo Tritemio y clave de encriptacion 34

void sumacadena(char mensaje_sal[10000],char m,int cod,int lm)
    {
    
	char etiqueta[14];
	char mensaje_buf[10000];
	int k;
	int divisor=10;
	int n1,n2,n3;

	for(k=0;k<14;k++)          // escribe espacios en etiqueta[]
						{
	etiqueta[k]=' ';
						}

    // escriben tipo de codificacion
    
	if(m=='s')                 
       {
       etiqueta[1]='J';
       etiqueta[2]='C';
       }
	if(m=='p')
       {
       etiqueta[1]='T';
       etiqueta[2]='R';
       }
	if(m=='c')
       {
       etiqueta[1]='A';
       etiqueta[2]='L';
       }

    // escriben en caracteres el codigo de encriptacion correspondiente

		n1=cod;
		for(k=12;k>3;k--)      // inicio de bucle de escritura de codigo
						{
		n2=n1/10;
						n3=n1-(n2*10);
						n1=n2;
				
		if(n3==0)
								{
	etiqueta[k]='0';
								}
	if(n3==1)
								{
		etiqueta[k]='1';
								}
	if(n3==2)
								{
		etiqueta[k]='2';
								}
	if(n3==3)
								{
		etiqueta[k]='3';
								}
	if(n3==4)
								{
		etiqueta[k]='4';
								}
	if(n3==5)
								{
		etiqueta[k]='5';
								}
	if(n3==6)
								{
		etiqueta[k]='6';
								}
	if(n3==7)
								{
		etiqueta[k]='7';
								}
	if(n3==8)
								{
		etiqueta[k]='8';
								}
	if(n3==9)
								{
		etiqueta[k]='9';
								}

						}  // final de bucle de escritura de codigo
						

	k=4;
	do
		{
		if(etiqueta[k]=='0')     // cambia los ceros a la derecha por -
			{
			etiqueta[k]='-';   
			}
		else
			{
		break;
			}
			k=k+1;
		 	}while(1==1);
			
		    for(k=0;k<lm+14;k++)
					{
			if(k<14)
				{
			mensaje_buf[k]=etiqueta[k]; // suma etiqueta al principio de mensaje_buf
            }
			if(k>=14)
              {
              mensaje_buf[k]=mensaje_sal[k-14];     // a continuacion le suma mensaje_sal
            }
            }
         
		for(k=0;k<lm+14;k++)
            {
            mensaje_sal[k]=mensaje_buf[k];     // carga mensaje_buf en mensaje_sal (ahora ampliado)
            }

    
  }

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

     
                             // 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

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