CriptoUtils.java

/*
 * Created on 01/10/2004
 *
 * To change the template for this generated file go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
package br.com.centralit.citcorpore.util;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.security.GeneralSecurityException;
import java.security.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;

/**
 * @author CentralIT
 */
public final class CriptoUtils {
	private static final String hexDigits = "0123456789abcdef";
	/**
	 * Gera o codigo hash de uma string
	 * @param str
	 * @param algoritmo
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static String generateHash(String str, String algoritmo) throws NoSuchAlgorithmException{
		byte[] b = CriptoUtils.digest(str.getBytes(), algoritmo);
		String hash = CriptoUtils.byteArrayToHexString(b);	
		return hash;
	}
	public static String generateHash(byte[] bt, String algoritmo) throws NoSuchAlgorithmException{
		byte[] b = CriptoUtils.digest(bt, algoritmo);
		String hash = CriptoUtils.byteArrayToHexString(b);	
		return hash;
	}
	/**
	* Realiza um digest em um array de bytes atrav�s do algoritmo especificado
	* @param input - O array de bytes a ser criptografado
	* @param algoritmo - O algoritmo a ser utilizado
	* @return byte[] - O resultado da criptografia
	* @throws NoSuchAlgorithmException - Caso o algoritmo fornecido n�o seja
	* v�lido
	*/
	public static byte[] digest(byte[] input, String algoritmo)
		throws NoSuchAlgorithmException {
		MessageDigest md = MessageDigest.getInstance(algoritmo);
		md.reset();
		return md.digest(input);
	}

	/**
	 * Converte o array de bytes em uma representa��o hexadecimal.
	 * @param input - O array de bytes a ser convertido.
	 * @return Uma String com a representa��o hexa do array
	 */
	public static String byteArrayToHexString(byte[] b) {
		StringBuilder buf = new StringBuilder();

		for (int i = 0; i < b.length; i++) {
			int j = ((int) b[i]) & 0xFF; 
			buf.append(hexDigits.charAt(j / 16)); 
			buf.append(hexDigits.charAt(j % 16)); 
		}
     
		return buf.toString();
	}

	/**
	 * Converte uma String hexa no array de bytes correspondente.
	 * @param hexa - A String hexa
	 * @return O vetor de bytes
	 * @throws IllegalArgumentException - Caso a String n�o sej auma
	 * representa��o haxadecimal v�lida
	 */
	public static byte[] hexStringToByteArray(String hexa)
		throws IllegalArgumentException {

		//verifica se a String possui uma quantidade par de elementos
		if (hexa.length() % 2 != 0) {
			throw new IllegalArgumentException("String hexa inv�lida"); 
		}

		byte[] b = new byte[hexa.length() / 2];

		for (int i = 0; i < hexa.length(); i+=2) {
			b[i / 2] = (byte) ((hexDigits.indexOf(hexa.charAt(i)) << 4) |
				(hexDigits.indexOf(hexa.charAt(i + 1)))); 
		}
		return b;
	}
	
	public static void generateKeyPair(int keySize, String fileChavePublica, String fileChavePrivada) throws NoSuchAlgorithmException, FileNotFoundException, IOException{
	    KeyPairGenerator pairgen = KeyPairGenerator.getInstance("RSA");
	    SecureRandom random = new SecureRandom();
	    pairgen.initialize(keySize, random);
	    KeyPair keyPair = pairgen.generateKeyPair();
	    ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(fileChavePublica));
	    out.writeObject(keyPair.getPublic());
	    out.close();            
	    out = new ObjectOutputStream(new FileOutputStream(fileChavePrivada));
	    out.writeObject(keyPair.getPrivate());
	    out.close();  	
	}
	
	public static void encryptFile(String fileACriptografar, String fileCriptografado, String fileChavePublica) throws FileNotFoundException, IOException, ClassNotFoundException, GeneralSecurityException{
        // wrap with RSA public key
		FileInputStream keyIn = new FileInputStream(fileChavePublica);
        encryptFile(fileACriptografar, fileCriptografado, keyIn);
        keyIn.close();            

	}
	public static void encryptFile(String fileACriptografar, String fileCriptografado, InputStream publicKeyIn) throws FileNotFoundException, IOException, ClassNotFoundException, GeneralSecurityException{
		KeyGenerator keygen = KeyGenerator.getInstance("AES");
		SecureRandom random = new SecureRandom();
		keygen.init(random);
		SecretKey key = keygen.generateKey();
		
		// wrap with RSA public key
		ObjectInputStream keyIn = new ObjectInputStream(publicKeyIn);
		Key publicKey = (Key) keyIn.readObject();
		
		Cipher cipher = Cipher.getInstance("RSA");
		cipher.init(Cipher.WRAP_MODE, publicKey);
		byte[] wrappedKey = cipher.wrap(key);
		DataOutputStream out = new DataOutputStream(new FileOutputStream(fileCriptografado));
		out.writeInt(wrappedKey.length);
		out.write(wrappedKey);
		
		InputStream in = new FileInputStream(fileACriptografar);
		cipher = Cipher.getInstance("AES");
		cipher.init(Cipher.ENCRYPT_MODE, key);
		crypt(in, out, cipher);
		in.close();
		out.close();		
	}
	
	public static void decryptFile(String fileCriptografado, String fileDecriptografado, String fileChavePrivada) throws FileNotFoundException, IOException, ClassNotFoundException, GeneralSecurityException{
		if (arquivoExiste(fileCriptografado)){
			// wrap with RSA public key
			FileInputStream keyIn = new FileInputStream(fileChavePrivada);
	        decryptFile(fileCriptografado, fileDecriptografado, keyIn);
	        keyIn.close();  		
		}
	}
	
	public static void decryptFile(String fileCriptografado, String fileDecriptografado, InputStream privateKeyIn) throws FileNotFoundException, IOException, ClassNotFoundException, GeneralSecurityException{
		if (arquivoExiste(fileCriptografado)){
			DataInputStream in = new DataInputStream(new FileInputStream(fileCriptografado));
			int length = in.readInt();
			byte[] wrappedKey = new byte[length];
			in.read(wrappedKey, 0, length);
			
			// unwrap with RSA private key
			ObjectInputStream keyIn = new ObjectInputStream(privateKeyIn);
			Key privateKey = (Key) keyIn.readObject();
			
			Cipher cipher = Cipher.getInstance("RSA");
			cipher.init(Cipher.UNWRAP_MODE, privateKey);
			Key key = cipher.unwrap(wrappedKey, "AES", Cipher.SECRET_KEY);
			
			OutputStream out = new FileOutputStream(fileDecriptografado);
			cipher = Cipher.getInstance("AES");
			cipher.init(Cipher.DECRYPT_MODE, key);
			
			crypt(in, out, cipher);
			in.close();
			out.close();		
		}
	}
	
	  /**
    Uses a cipher to transform the bytes in an input stream
    and sends the transformed bytes to an output stream.
    @param in the input stream
    @param out the output stream
    @param cipher the cipher that transforms the bytes
	  */
	 private static void crypt(InputStream in, OutputStream out,
	    Cipher cipher) throws IOException, GeneralSecurityException{
	    int blockSize = cipher.getBlockSize();
	    int outputSize = cipher.getOutputSize(blockSize);
	    byte[] inBytes = new byte[blockSize];
	    byte[] outBytes = new byte[outputSize];
	
	    int inLength = 0;;
	    boolean more = true;
	    while (more)
	    {
	       inLength = in.read(inBytes);
	       if (inLength == blockSize)
	       {
	          int outLength = cipher.update(inBytes, 0, blockSize, outBytes);
	          out.write(outBytes, 0, outLength);
	       }
	       else more = false;         
	    }
	    if (inLength > 0)
	       outBytes = cipher.doFinal(inBytes, 0, inLength);
	    else
	       outBytes = cipher.doFinal();
	    out.write(outBytes);
	 }
	
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException, GeneralSecurityException{
		/*
		byte[] b = CriptoUtils.digest("DEMO".getBytes(), "SHA-1");
		String senhaCriptografada = CriptoUtils.byteArrayToHexString(b);
		
		System.out.println(" A SENHA CRIPTOGRAFADA EH: " + senhaCriptografada);
		*/
		
		/*
		try {
			CriptoUtils.generateKeyPair(512, "C:\\temp\\chavePublica.key", "C:\\temp\\chavePrivada.key");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		*/
		
		CriptoUtils.encryptFile("C:\\BancoBrasil\\PICT0016.AVI", "C:\\BancoBrasil\\PICT0016_CRIPTO.AVI", "C:\\temp\\chavePublica.key");
		CriptoUtils.decryptFile("C:\\BancoBrasil\\PICT0016_CRIPTO.AVI", "C:\\BancoBrasil\\PICT0016_DECRIPT.AVI", "C:\\temp\\chavePrivada.key");
	}
	
	public static boolean arquivoExiste(String arquivo){
		File file = new File(arquivo);
		if (file.exists()){
			return true;
		} else {
	    	return false;
	    }
	}
}