com.cfs.util.AESCriptografia.java Source code

Introduction

Here is the source code for com.cfs.util.AESCriptografia.java

Source

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.cfs.util;

import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.security.Key;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;

/**
 *
 * @author GK Fujii
 */
public class AESCriptografia implements Serializable {

    public static void main(String[] args) {
        AESCriptografia aes = new AESCriptografia();
        String msg = "Teste4";
        String key = "8TScvUZRTmS8V6hd/cZt/A==";

        try {
            System.out.println("                 AES - " + aes.testeCifrar(msg, key));
            String teste = "AES/ECB/PKCS5PADDING";
            Cipher cipher = Cipher.getInstance(teste);
            cipher.init(Cipher.ENCRYPT_MODE, aes.gerarChave(key));
            byte[] original = msg.getBytes();
            byte[] cifrada = cipher.doFinal(original);
            byte[] retorno = Base64.encodeBase64(cifrada);

            System.out.println(teste + " - " + new String(retorno));
        } catch (Exception e) {
            System.out.println(Utilities.getInstance().getLineNumber() + e.getLocalizedMessage());
        }
    }

    public String gerarChaveRandomica() {
        String chave = null;
        try {
            /* Cria o gerador de chaves */
            KeyGenerator keygen = KeyGenerator.getInstance("AES");
            /* Inicializa o gerador de chaves */
            SecureRandom random = new SecureRandom();
            keygen.init(random);
            /* Cria uma chave */
            SecretKey key = keygen.generateKey();
            /* Captura a chave na forma de bytes */
            byte[] buffer = key.getEncoded();
            /* Codifica a chave gerada */
            byte[] chaveGerada = Base64.encodeBase64(buffer);
            /* Converte a chave para texto */
            chave = new String(chaveGerada, "UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        }
        /* Retorna a chave */
        return chave;
    }

    public String gerarSalt() {
        /* Tamanho do buffer do Salt */
        final int SALT_LENGTH = 16;
        /* Criao do buffer do Salt */
        byte[] salt = new byte[SALT_LENGTH];
        /* Criao do gerador de Salt */
        SecureRandom aleatorio = new SecureRandom();
        /* Gerao de um Salt aleatrio */
        aleatorio.nextBytes(salt);
        /* Encoda o salt gerado */
        String retorno = Base64.encodeBase64String(salt);
        /* Retorna o salt gerado */
        return retorno;
    }

    private Key gerarChave(String chave) {
        byte[] chaveDecode = Base64.decodeBase64(chave.getBytes());
        Key key = new SecretKeySpec(chaveDecode, "AES");
        return key;
    }

    public String cifrar(String textoOriginal, String chave) {
        try {
            byte[] original = textoOriginal.getBytes();
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, gerarChave(chave));
            byte[] cifrada = cipher.doFinal(original);
            byte[] retorno = Base64.encodeBase64(cifrada);
            return new String(retorno);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public String decifrar(String textoCifrado, String chave) {
        try {
            byte[] cifrado = Base64.decodeBase64(textoCifrado.getBytes());
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, gerarChave(chave));
            byte[] decifrado = cipher.doFinal(cifrado);
            return new String(decifrado);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public void cifrarObjeto(Object objeto) {
        try {
            String chave = null;
            Method[] metodos = objeto.getClass().getMethods();
            for (Method metodo : metodos) {
                if (metodo.getName().startsWith("getKey")) {
                    chave = String.valueOf(metodo.invoke(objeto));
                }
            }

            Field[] campos = objeto.getClass().getDeclaredFields();
            for (Field campo : campos) {
                campo.setAccessible(true);
                if (campo.getType().equals(String.class)) {
                    if (campo.getName().equals("key")) {
                        campo.set(objeto, campo.get(objeto));
                    } else {
                        campo.set(objeto, cifrar(String.valueOf(campo.get(objeto)), chave));
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void decifrarObjeto(Object objeto) {
        try {
            String chave = null;
            Method[] metodos = objeto.getClass().getMethods();
            for (Method metodo : metodos) {
                if (metodo.getName().startsWith("getKey")) {
                    chave = String.valueOf(metodo.invoke(objeto));
                }
            }

            Field[] campos = objeto.getClass().getDeclaredFields();
            for (Field campo : campos) {
                campo.setAccessible(true);
                if (campo.getType().equals(String.class)) {
                    if (campo.getName().equals("key")) {
                        campo.set(objeto, campo.get(objeto));
                    } else {
                        campo.set(objeto, decifrar(String.valueOf(campo.get(objeto)), chave));
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void decifrarObjetoComKey(Object objeto, String key) {
        try {
            Field[] campos = objeto.getClass().getDeclaredFields();
            //            System.out.println("DEPURATION MASTER: START !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
            for (Field campo : campos) {
                campo.setAccessible(true);
                if (campo.getType().equals(String.class)) {
                    if (campo.getName().equals("key")) {
                        campo.set(objeto, campo.get(objeto));
                    } else {
                        if (campo.get(objeto) == null) {
                            campo.set(objeto, "null");
                            System.out.println("[SET-NULL] " + campo.getName() + " = " + campo.get(objeto));
                        } else {
                            campo.set(objeto, decifrar(String.valueOf(campo.get(objeto)), key));
                            //                            System.out.println("[SET] " + campo.getName() + " = " + campo.get(objeto));
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void cifrarObjetoComKey(Object objeto, String key) {
        try {
            Field[] campos = objeto.getClass().getDeclaredFields();
            for (Field campo : campos) {
                campo.setAccessible(true);
                if (campo.getType().equals(String.class)) {
                    if (campo.getName().equals("key")) {
                        campo.set(objeto, campo.get(objeto));
                    } else {
                        campo.set(objeto, cifrar(String.valueOf(campo.get(objeto)), key));
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public String testeCifrar(String msg, String key) {
        try {
            byte[] original = msg.getBytes();
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, gerarChave(key));
            byte[] cifrada = cipher.doFinal(original);
            byte[] retorno = Base64.encodeBase64(cifrada);
            return new String(retorno);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public String testeDecifrar(String msg, String key) {
        try {
            byte[] cifrado = Base64.decodeBase64(msg.getBytes());
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, gerarChave(key));
            byte[] decifrado = cipher.doFinal(cifrado);
            return new String(decifrado);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}/**/