package com.psp.exuf1;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.MessageDigest;
import java.security.PublicKey;
import java.security.spec.KeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Arrays;
import java.util.Scanner;

public class Ejercicio6 {

	// CONSTANTES
	private static String FORMATO = "UTF-8";
	private static String TIPO_CIFRADO = "AES";
	private static String FUNCION_CRIPTOGRAFICA = "SHA-256";

	public static void main(String[] args) throws FileNotFoundException {

		Scanner sc = new Scanner(System.in);
		int numPasswd;

			System.out.println("Dame una contraseña...1 La contraseña tiene que ser ebtre 1 y 99");
			numPasswd = sc.nextInt();

			if (numPasswd < 1 || numPasswd > 99) {
				do {
					System.out.println(
							"No has introducido el numero correcto, solo se puede cifrar con una contraseña del 1 al 99");
					numPasswd = sc.nextInt();
				} while (numPasswd < 1 || numPasswd > 99);
			}

			cifradoAutomatico(leerFichero(), numPasswd);
			sc.close();

	}

	public static String leerFichero() {
		File fichero = new File("D:\\Users\\Raul W\\Desktop\\DAM2\\M09 - PSP\\ficheros\\UF1\\examen\\examen.txt.txt");
		Scanner s = null;
		String linea = "";
		try {
			// Leemos el contenido del fichero
			System.out.println("... Leemos el contenido del fichero ...");
			s = new Scanner(fichero);

			// Leemos linea a linea el fichero
			while (s.hasNextLine()) {
				linea = s.nextLine(); // Guardamos la linea en un String
				System.out.println(linea); // Imprimimos la linea
			}
			return linea;
		} catch (Exception ex) {
			System.out.println("Mensaje: " + ex.getMessage());
		} finally {
			// Cerramos el fichero tanto si la lectura ha sido correcta o no
			try {
				if (s != null)
					s.close();
			} catch (Exception ex2) {
				System.out.println("Mensaje 2: " + ex2.getMessage());
			}
		}
		return null;
	}

	public static void intentoDescifrar(byte[] mensajeInterceptado) throws Exception {

		// **Generamos la posible contraseña y vamos probando dentro del bucle
		SecretKey posibleContraseñaSecreta = loadKey(
				"D:\\\\Users\\\\Raul W\\\\Desktop\\\\DAM2\\\\M09 - PSP\\\\ficheros\\\\UF1\\\\examen\\\\clau.txt");

		// **Descifrar en formato AES

		try {

			// desciframos el mensaje
			Cipher cigfradoManual = Cipher.getInstance("AES/ECB/PKCS5Padding");
			cigfradoManual.init(Cipher.DECRYPT_MODE, posibleContraseñaSecreta);
			byte[] datosPosiblesDescrifrados = cigfradoManual.doFinal(mensajeInterceptado);

			System.out.print("");

			String msgDescrifrado = new String(datosPosiblesDescrifrados, FORMATO);
			System.out.println("\n\n********************************************* \n" + "****** Desciframos: "
					+ msgDescrifrado + " ******\n" + "*********************************************");
		} catch (Exception ex) {

		}

	}

	public static byte[] cifradoAutomatico(String msgAEncriptar, int numPasswd) {

		String cadena;

		// **controlamos la contraseña para que si es menor a 10 le pongamos un cero, ya
		// que se necesita 2 bytes para la contraseña
		if (numPasswd >= 1 && numPasswd <= 9) {
			cadena = 0 + Integer.toString(numPasswd);
		} else {
			cadena = Integer.toString(numPasswd);
		}

		try {
			Cipher xifrado = Cipher.getInstance(TIPO_CIFRADO);
			xifrado.init(Cipher.ENCRYPT_MODE, genLlaveConPasswd(cadena, 192));
			byte[] msgEnBytes = msgAEncriptar.getBytes(FORMATO);
			byte[] msgXifradoEnByte = xifrado.doFinal(msgEnBytes);

			System.out.println("El mensaje cifrado es el siguiente(" + msgXifradoEnByte + ")");

			intentoDescifrar(msgXifradoEnByte);
			return msgXifradoEnByte;

		} catch (Exception e) {
			System.out.println("");
		}
		// **pasamos el texto a byte.
		return null;

	}

	public static SecretKey genLlaveConPasswd(String passwd, int laLlave) {

		SecretKey claveSecreta = null;

		// ** si la llave no contiene un formato UTF no la inicalizamos y damos un error
		// controlado.
		if ((laLlave == 192)) {

			try {
				// **Convertimos el String passwd con 2 bytes a un Array.

				byte[] data = passwd.getBytes(FORMATO);

				/*
				 * las lineas, se comprimen para conseguir una cantidad limitada de bytes,
				 * ademas copyOFF genera una llave de 16 posciones mediante el tamaño de
				 * "laLlave" que antes hemos generado
				 */
				MessageDigest md = MessageDigest.getInstance(FUNCION_CRIPTOGRAFICA);
				byte[] compresion = md.digest(data);
				byte[] llaveEnArray = Arrays.copyOf(compresion, laLlave / 8);
				claveSecreta = new SecretKeySpec(llaveEnArray, TIPO_CIFRADO);

				saveKey(claveSecreta, "D:\\Users\\Raul W\\Desktop\\DAM2\\M09 - PSP\\ficheros\\UF1\\examen\\clau.txt");

			} catch (Exception ex) {
				System.err.println("ERROR al generar la clave..." + ex);
			}
		}
		return claveSecreta;
	}

	private static void saveKey(SecretKey key, String fileName) throws Exception {

		byte[] publicKeyBytes = key.getEncoded();
		FileOutputStream fos = new FileOutputStream(fileName);
		fos.write(publicKeyBytes);
		fos.close();
	}

	// CARGAMOS EL FICHERO DE LA LLAVE PUBLICA
	private static SecretKey loadKey(String fileName) throws Exception {
		FileInputStream fis = new FileInputStream(fileName);
		int numBtyes = fis.available();
		byte[] bytes = new byte[numBtyes];
		fis.read(bytes);
		fis.close();

		SecretKey claveSecreta = new SecretKeySpec(bytes, TIPO_CIFRADO);

		return claveSecreta;
	}

}