Pratica - Criptografia
Pratica - Criptografia
Pratica - Criptografia
//criptografar
Cipher cif = Cipher.getInstance("AES");
cif.init(Cipher.ENCRYPT_MODE, chave);
cif.init(Cipher.DECRYPT_MODE, chave);
buffer = cif.doFinal(buffer);
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
/**
*
* @author larodrigues
*/
public class Assimetrica {
//criptografar
Cipher cif = Cipher.getInstance("RSA");
cif.init(Cipher.ENCRYPT_MODE, chave.getPrivate());
cif.init(Cipher.DECRYPT_MODE, chave.getPublic());
buffer = cif.doFinal(buffer);
}
3. Hash MD5 e SHA-1
MD5
● hash de 128 bits = 16 bytes
● muito utilizado por softwares com protocolo P2P, verificação de integridade e logins.
SHA-256
● hash de 256 bits = 32 bytes
● Faz parte da família SHA-2 (224, 256, 384 ou 512 bits) adotada em 2010
● Usado numa grande variedade de aplicações e protocolos de segurança, incluindo TLS, SSL,
PGP, SSH, S/MIME e IPSec, BitCoin
Para que se possa gerar textos criptografados, é necessário seguir os seguintes passos.
1. Obter uma instância do algoritmo a ser usado.
2. Passar a informação que se deseja criptografar para o algoritmo.
3. Efetuar a criptografia.
MessageDigest md = MessageDigest.getInstance("MD5");
MessageDigest md = MessageDigest.getInstance("SHA-1");
MessageDigest md = MessageDigest.getInstance("SHA-256");
Após a chamada a getInstance(), você possui uma referência a um objeto pronto para
criptografar seus dados utilizando o algoritmo especificado. Neste caso o MD5.
2 https://docs.oracle.com/javase/8/docs/api/java/security/MessageDigest.html
Finalmente, para gerar a chave criptografada, você invoca o método digest().
byte[] digest();
byte[] digest(byte[] input);
import java.security.MessageDigest;
import java.util.Base64;
String chave = "The quick brown fox jumps over the lazy dog";
byte[] buffer = md.digest(chave.getBytes());
System.out.println(buffer.length+":
"+Base64.getEncoder().encodeToString(buffer));
String chave2 = "The quick brown fox jumps over the lazy cog";
buffer = md.digest(chave2.getBytes());
System.out.println(buffer.length+":
"+Base64.getEncoder().encodeToString(buffer));
} catch (Exception e) {
e.printStackTrace();
}
}
}
4. Assinaturas Digitais
Assinaturas digitais servem para autenticar o dado sendo transmitido. Junto com o dado, uma
assinatura digital é enviada. Comparada a uma chave pública, a assinatura é validada ou rejeitada.
A classe responsável no java por gerar as assinaturas digitais é chamada, não coincidentemente, de
Signature3.
Objetos signature são criados atavés da chamada ao método da classe Signature chamado.
A geração das chaves é possível através da classe KeyPairGenerator. Assim como a classe
Signature, a KeyPairGenerator necessita de um algoritmo para gerar as chaves.
Note que tanto as chaves quanto a assinatura devem ser geradas utilizando-se o mesmo algoritmo de
3 https://docs.oracle.com/javase/8/docs/api/java/security/Signature.html
criptografia. Após a obtenção de um KeyPairGenerator, devemos inicializa-lo através do método
initialize().
A classe responsável por nos fornecer esse numero aleatório é chamada de SecureRandom. Ela gera
números aleatórios que dificilmente se repetirão. O tamanho da chave deve ser compatível com o
algoritmo sendo usado. no caso do DSA, podemos usar um tamanho de 512, 768 ou 1024.
De posse de nossa chave privada, podemos utilizá-la para inicializar nosso objeto signature:
sig.initSign(priKey);
A partir de agora, podemos utilizar o método update() para passar ao algoritmo os dados a serem
criptografados. Após o dado ser fornecido, o método sign() deve ser chamado para geração da
assinatura.
Nota: o método sign reseta o status do algoritmo ao seu estado inicial.
String mensagem = "The quick brown fox jumps over the lazy dog";
//Gerar assinatura
sign.update(mensagem.getBytes());
byte[] assinatura = sign.sign();
Aqui terminam as responsabilidades do remetente. Tudo o que ele precisa fazer agora é fornecer a
chave pública juntamente com o dado a ser enviado e a assinatura correspondente.
O destinatário dos dados sendo enviados deverá receber a assinatura digital e ter acesso a chave
pública. Ele então poderá validar a assinatura junto ao dado recebido utilizando sua chave pública.
Geração de Assinaturas com Chave publica e privada – DSA
public static void main(String args[]) {
try {
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("DSA");
SecureRandom secRan = new SecureRandom();
keyGen.initialize(512, secRan);
KeyPair keyP = keyGen.generateKeyPair();
PublicKey pubKey = keyP.getPublic();
PrivateKey priKey = keyP.getPrivate();
System.out.println("publica: "+pubKey);
System.out.println("privada: "+priKey);
//Obtem algoritmo para geração da assinatura
Signature geradorAss = Signature.getInstance("DSA");
//Inicializar geração
geradorAss.initSign(priKey);
String mensagem = "The quick brown fox jumps over the lazy dog";
//Gerar assinatura
geradorAss.update(mensagem.getBytes());
byte[] assinatura = geradorAss.sign();
//Grava a mensagem num arquivo properties
Properties p = new Properties();
p.put("mensagem", mensagem);
p.put("assinatura", byteArrayToHexString(assinatura));
p.store(new FileOutputStream("dado.properties"), null);
if (clientSig.verify(assinatura)) {
//Mensagem assinada corretamente
} else {
//Mensagem não pode ser validada
}