Um dos posts que mais foram acessados e comentados em meu blog foi um escrito sobre Criptografia em Java utilizando Hashs criptográficos.
Depois de receber alguns pedidos resolvi escrever este novo post utilizando no exemplo uma criptografia do tipo Triple DES, com esta criptografia podemos encriptografar e descriptografar informações utilizando Java.
Triple DES é a mais segura versão do algoritmo original Data Encryption Standard (DES) e você pode saber sobre este algoritmo aqui.
Agora vamos a implementação do algoritmo, eu criei uma classe simples que fornece dois métodos de instância para encriptografar e descriptografar uma String.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
package br.com.rodrigolazoti;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/**
* Class that supplies a criptography of triple type DES.
* @author Rodrigo Lazoti
* @since 05/07/2009
*/
public class CryptographyTripleDES {
private Cipher cipher;
private byte[] encryptKey;
private KeySpec keySpec;
private SecretKeyFactory secretKeyFactory;
private SecretKey secretKey;
/**
* Method that create a new instance of class.
* @return
* @throws InvalidKeyException
* @throws UnsupportedEncodingException
* @throws NoSuchAlgorithmException
* @throws NoSuchPaddingException
* @throws InvalidKeySpecException
*/
public static CryptographyTripleDES newInstance() throws InvalidKeyException, UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeySpecException {
return new CryptographyTripleDES();
}
/**
* Default Constructor.
* @throws UnsupportedEncodingException
* @throws NoSuchAlgorithmException
* @throws NoSuchPaddingException
* @throws InvalidKeyException
* @throws InvalidKeySpecException
*/
private CryptographyTripleDES() throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, InvalidKeySpecException {
String key = "http://www.rodrigolazoti.com.br";
encryptKey = key.getBytes( "UTF-8" );
cipher = Cipher.getInstance( "DESede" );
keySpec = new DESedeKeySpec( encryptKey );
secretKeyFactory = SecretKeyFactory.getInstance( "DESede" );
secretKey = secretKeyFactory.generateSecret( keySpec );
}
/**
* Method that encrypts a value.
* @param value
* @return
* @throws InvalidKeyException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
* @throws UnsupportedEncodingException
*/
public String encrypt( String value ) throws InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
cipher.init( Cipher.ENCRYPT_MODE, secretKey );
byte[] cipherText = cipher.doFinal( value.getBytes( "UTF-8" ) );
BASE64Encoder encoder = new BASE64Encoder();
return encoder.encode( cipherText );
}
/**
* Methot that decrypts a value.
* @param value
* @return
* @throws InvalidKeyException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
* @throws IOException
*/
public String decrypt( String value ) throws InvalidKeyException, IllegalBlockSizeException, BadPaddingException, IOException {
cipher.init( Cipher.DECRYPT_MODE, secretKey );
BASE64Decoder dec = new BASE64Decoder();
byte[] decipherText = cipher.doFinal( dec.decodeBuffer( value ) );
return new String( decipherText );
}
}
A seguir criei uma pequena classe para realizar um teste:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package br.com.rodrigolazoti;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
public class TestCryptographyTripleDES {
public static void main( String[] args ) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeySpecException, IllegalBlockSizeException, BadPaddingException, IOException {
CryptographyTripleDES cryptography = CryptographyTripleDES.newInstance();
String value = "Rodrigo Lazoti";
System.out.println( "Valor utilizado => " + value );
String encryptedValue = cryptography.encrypt( value );
System.out.println( "Valor criptografado => " + encryptedValue );
String decryptedValue = cryptography.decrypt( encryptedValue );
System.out.println( "Valor descriptografado => " + decryptedValue );
}
}
O resultado do teste é:
1
2
3
Valor utilizado => Rodrigo Lazoti
Valor criptografado => RgYlMeQBUcyx6419bKlqRw==
Valor descriptografado => Rodrigo Lazoti
Com isso já temos uma boa base de como utilizar este tipo de criptografia em aplicações Java.