Posto abaixo um programa que escrevi faz alguns anos para servir de exemplo de uso das APIs de criptografia do Java. Dei uma reformatada (com o bom e velho Eclipse) e incluí alguns javadocs. Não é o jeito "correto" de usar as APIs, mas muita gente precisa de algo parecido com isso para trabalhos de escola, portanto divirtam-se!
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.cert.CertificateException;
import java.security.spec.RSAKeyGenParameterSpec;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
// Exemplo de criptografia RSA.
//
// Para criptografar um bloco de dados com RSA, gera-se uma chave aleatória para
// usar com um algoritmo simétrico (como o AES), e então criptografa-se essa chave
// com o algoritmo RSA usando-se a chave pública do destinatário.
//
// Para o destinatário decifrar os dados, ele deve decifrar a chave recebida com sua
// chave privada, e então usar a chave decifrada para decifrar os dados.
//
// Note que o modo correto de fazer isso é usar um formato padronizado, como o PKCS#7
// (ou CMS), e usar o BouncyCastle. Só faço isto para exemplificar as APIs do Java.
//
/**
* Efetua a parte da criptografia
*/
class Cifrador {
/**
* Cifra um bloco de dados com a chave pública.
*
* @param pub
* A chave pública.
* @param textoClaro
* O bloco de dados a ser cifrado.
* @return Dois arrays de bytes, sendo que o primeiro é o bloco cifrado, e o
* segundo é a chave gerada e cifrada. Não jogue fora nenhum deles.
* @throws NoSuchAlgorithmException
* Algoritmo (AES) não disponível na sua versão do JDK.
* @throws NoSuchPaddingException
* Padding (PKCS5Padding) não disponível na sua versão do JDK.
* @throws InvalidKeyException
* Se a chave pública for inválida.
* @throws IllegalBlockSizeException
* Não deve ocorrer.
* @throws BadPaddingException
* Não deve ocorrer.
* @throws InvalidAlgorithmParameterException
* Não deve ocorrer.
*/
public byte[][] cifra(PublicKey pub, byte[] textoClaro)
throws NoSuchAlgorithmException, NoSuchPaddingException,
InvalidKeyException, IllegalBlockSizeException,
BadPaddingException, InvalidAlgorithmParameterException {
byte[] textoCifrado = null;
byte[] chaveCifrada = null;
// -- A) Gerando uma chave simétrica de 128 bits
KeyGenerator kg = KeyGenerator.getInstance("AES");
kg.init(128);
SecretKey sk = kg.generateKey();
byte[] chave = sk.getEncoded();
// -- B) Cifrando o texto com a chave simétrica gerada
Cipher aescf = Cipher.getInstance("AES/CBC/PKCS5Padding");
IvParameterSpec ivspec = new IvParameterSpec(new byte[16]);
aescf.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(chave, "AES"),
ivspec);
textoCifrado = aescf.doFinal(textoClaro);
// -- C) Cifrando a chave com a chave pública
Cipher rsacf = Cipher.getInstance("RSA");
rsacf.init(Cipher.ENCRYPT_MODE, pub);
chaveCifrada = rsacf.doFinal(chave);
return new byte[][] { textoCifrado, chaveCifrada };
}
}
/**
* Efetua a parte da decifração
*/
class Decifrador {
/**
* Decifra o bloco de dados e a chave cifrada usando a chave privada do destinatário.
* @param pvk A chave privada.
* @param textoCifrado Os dados cifrados.
* @param chaveCifrada A chave cifrada.
* @return Os dados decifrados.
* @throws NoSuchAlgorithmException Algoritmo AES não disponível na sua versão do JDK.
* @throws NoSuchPaddingException PKCS5Padding não disponível na sua versão do JDK.
* @throws InvalidKeyException Se a chave passada for inválida.
* @throws IllegalBlockSizeException Não deve ocorrer.
* @throws BadPaddingException Se houver um erro de decifração (chave incorreta ou texto
* cifrado incorreto, por exemplo)
* @throws InvalidAlgorithmParameterException Não deve ocorrer.
*/
public byte[] decifra(PrivateKey pvk, byte[] textoCifrado,
byte[] chaveCifrada) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException,
IllegalBlockSizeException, BadPaddingException,
InvalidAlgorithmParameterException {
byte[] textoDecifrado = null;
// -- A) Decifrando a chave simétrica com a chave privada
Cipher rsacf = Cipher.getInstance("RSA");
rsacf.init(Cipher.DECRYPT_MODE, pvk);
byte[] chaveDecifrada = rsacf.doFinal(chaveCifrada);
// -- B) Decifrando o texto com a chave simétrica decifrada
Cipher aescf = Cipher.getInstance("AES/CBC/PKCS5Padding");
IvParameterSpec ivspec = new IvParameterSpec(new byte[16]);
aescf.init(Cipher.DECRYPT_MODE,
new SecretKeySpec(chaveDecifrada, "AES"), ivspec);
textoDecifrado = aescf.doFinal(textoCifrado);
return textoDecifrado;
}
}
/**
* Serve para carregar a chave pública de um arquivo. Não é o melhor jeito
* de guardar a chave (é melhor e mais seguro usar um keystore),
* mas faço isso só para simplificar.
*/
class CarregadorChavePublica {
/**
* Carrega a chave pública serializada de um arquivo.
* @param fPub O arquivo com a chave pública serializada.
* @return A chave pública
* @throws IOException Se não achar o arquivo, ou se houver algum problema
* ao efetuar a des-serialização.
* @throws ClassNotFoundException O objeto contido no arquivo é de uma classe não presente
* neste projeto.
*/
public PublicKey carregaChavePublica(File fPub) throws IOException,
ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fPub));
PublicKey ret = (PublicKey) ois.readObject();
ois.close();
return ret;
}
}
/**
* Serve para carregar a chave privada de um arquivo. Não é o melhor jeito
* de guardar a chave (é melhor e mais seguro usar um keystore),
* mas faço isso só para simplificar.
*/
class CarregadorChavePrivada {
/**
* Carrega a chave privada serializada de um arquivo.
* @param fPvk O arquivo com a chave privada serializada.
* @return A chave privada.
* @throws IOException Se não achar o arquivo, ou se houver algum problema
* @throws ClassNotFoundException O objeto contido no arquivo é de uma classe não presente
* neste projeto.
*/
public PrivateKey carregaChavePrivada(File fPvk) throws IOException,
ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fPvk));
PrivateKey ret = (PrivateKey) ois.readObject();
ois.close();
return ret;
}
}
/**
* Gera um par de chaves e as guarda em formato serializado.
* (não é o formato mais seguro - seria melhor usar um keystore, que pode ser protegido
* por senha), mas faço isto para simplificar a compreensão.
*/
class GeradorParChaves {
private static final int RSAKEYSIZE = 1024;
/**
* Gera um par de chaves e as guarda em formato serializado em arquivos.
* @param fPub O arquivo que irá conter a chave pública.
* @param fPvk O arquivo que irá conter a chave privada.
* @throws IOException Problemas de acesso/gravação do arquivo.
* @throws NoSuchAlgorithmException RSA não disponível nesta versão do JDK.
* @throws InvalidAlgorithmParameterException Não deve ocorrer.
* @throws CertificateException Não deve ocorrer.
* @throws KeyStoreException Não deve ocorrer.
*/
public void geraParChaves(File fPub, File fPvk) throws IOException,
NoSuchAlgorithmException, InvalidAlgorithmParameterException,
CertificateException, KeyStoreException {
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
kpg.initialize(new RSAKeyGenParameterSpec(RSAKEYSIZE,
RSAKeyGenParameterSpec.F4));
KeyPair kpr = kpg.generateKeyPair();
PrivateKey priv = kpr.getPrivate();
PublicKey pub = kpr.getPublic();
// -- Gravando a chave pública em formato serializado
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
fPub));
oos.writeObject(pub);
oos.close();
// -- Gravando a chave privada em formato serializado
// -- Não é a melhor forma (deveria ser guardada em um keystore, e
// protegida por senha),
// -- mas isto é só um exemplo
oos = new ObjectOutputStream(new FileOutputStream(fPvk));
oos.writeObject(priv);
oos.close();
}
}
/**
* A classe a seguir cifra a decifra a string "Hello, world!".
*/
class ExemploCriptografia {
/**
* Mostra um array de bytes como um "dump".
* @param b O array de bytes que deve ser mostrado em formato dump.
*/
static void printHex(byte[] b) {
if (b == null) {
System.out.println("(null)");
} else {
for (int i = 0; i < b.length; ++i) {
if (i % 16 == 0) {
System.out.print(Integer
.toHexString((i & 0xFFFF) | 0x10000)
.substring(1, 5)
+ " - ");
}
System.out.print(Integer.toHexString((b[i] & 0xFF) | 0x100)
.substring(1, 3)
+ " ");
if (i % 16 == 15 || i == b.length - 1) {
int j;
for (j = 16 - i % 16; j > 1; --j)
System.out.print(" ");
System.out.print(" - ");
int start = (i / 16) * 16;
int end = (b.length < i + 1) ? b.length : (i + 1);
for (j = start; j < end; ++j)
if (b[j] >= 32 && b[j] <= 126)
System.out.print((char) b[j]);
else
System.out.print(".");
System.out.println();
}
}
System.out.println();
}
}
/**
* O programa principal
* @param args Os argumentos são ignorados.
* @throws Exception Lanço uma Exception para não poluir muito o código de demonstração
* com tratamento de exceções. Em um programa "de verdade" você deveria
* tratar corretamente as exceções.
*/
public static void main(String[] args) throws Exception {
// -- Gera o par de chaves, em dois arquivos (chave.publica e
// chave.privada)
GeradorParChaves gpc = new GeradorParChaves();
gpc.geraParChaves(new File("chave.publica"), new File("chave.privada"));
// -- Cifrando a mensagem "Hello, world!"
byte[] textoClaro = "Hello, world!".getBytes("ISO-8859-1");
CarregadorChavePublica ccp = new CarregadorChavePublica();
PublicKey pub = ccp.carregaChavePublica(new File("chave.publica"));
Cifrador cf = new Cifrador();
byte[][] cifrado = cf.cifra(pub, textoClaro);
printHex(cifrado[0]);
printHex(cifrado[1]);
// -- Decifrando a mensagem
CarregadorChavePrivada ccpv = new CarregadorChavePrivada();
PrivateKey pvk = ccpv.carregaChavePrivada(new File("chave.privada"));
Decifrador dcf = new Decifrador();
byte[] decifrado = dcf.decifra(pvk, cifrado[0], cifrado[1]);
// System.out.println (new String (textoClaro, "ISO-8859-1"));
printHex(decifrado);
}
}
