criptografia rsa em java

What is classpath? Membro desde: 04/04/2007 22:08:06 Mensagens: 8 Offline

dudes...parabens pelo site em primeiro lugar!
To fazendo um tcc na area de criptografia, e preciso implementar um software. O sistema que eu escolhi foi o rsa, mas nao manjo quase nada de programação. Alguem pode me indicar um site que eu ache um algoritmo pronto para o netbeans?? Obrigado!!

Pesquise aqui mesmo no fórum que já tem exemplos...

Moderador Membro desde: 29/07/2004 16:10:13 Mensagens: 17543 Offline

Não use criptografia RSA para criptografar mais que 100 bytes.
Normalmente RSA é usado para criptografar chaves, não dados.
Eis um exemplo (grave este programa em um arquivo chamado "ExemploCriptografia.java", compile-o e o rode com:
java -cp . ExemploCriptografia
)

import java.io.*;
import java.util.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.*;
import java.security.spec.*;
import java.security.cert.*;

class Cifrador {
    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 };
    }
}

class Decifrador {
    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;
    }
}

class CarregadorChavePublica {
    public PublicKey carregaChavePublica (File fPub) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream (new FileInputStream (fPub));
        PublicKey ret = (PublicKey) ois.readObject();
        ois.close();
        return ret;
    }
}

class CarregadorChavePrivada {
    public PrivateKey carregaChavePrivada (File fPvk) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream (new FileInputStream (fPvk));
        PrivateKey ret = (PrivateKey) ois.readObject();
        ois.close();
        return ret;
    }
}

class GeradorParChaves {
    private static final int RSAKEYSIZE = 1024;
    
    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();
        
    }
}

class ExemploCriptografia {
    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();
        }
    }    
    
    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"));
    }
}

What is classpath? Membro desde: 04/04/2007 22:08:06 Mensagens: 8 Offline

putz...valeu ai galera, mas acho que em breve vou precisar de mais ajuda. Abraços

Debugger Membro desde: 18/03/2008 10:27:26 Mensagens: 67 Offline

thingol,

Estou estudando um pouco de Criptografia, pois terei de usá-lo para criptografar e descriptografar uma base de dados, e nos exemplos que encontrei na net, o seu foi o mais claro e eficiente q encontrei, parabéns...

Porém gostaria de saber se vc pode me ajudar... o código funciona perfeitamente, porém qdo eu separo as classes e vou utilizar o "Decifrador" separadamente do "Cifrador" para descriptografar um txt previamente criptografado com este código, este dá o seguinte erro:

Para descriptografar este arquivo, eu mudei a linha 151 do seu código, ficando da seguinte forma:

Visto que eu não quero chamar a criptografia novamente, antes de descriptografar...

Você pode me orientar para saber oq está ocorrendo?

Desde já agradeço.

Moderador Membro desde: 29/07/2004 16:10:13 Mensagens: 17543 Offline

Uai, não sei onde é que pode dar esse erro. Rodei meu programa novamente (mas com um conjunto de dados bem maior) e ele funciona corretamente. Qual foi a modificação que você fez no meu código?

Moderador Membro desde: 29/07/2004 16:10:13 Mensagens: 17543 Offline

Uai, como é que você vai decifrar algo decifrado? Vai dar pau mesmo.

Debugger Membro desde: 18/03/2008 10:27:26 Mensagens: 67 Offline

Bom, vou separar as variáveis pra ficar mais claro...

Mais na verdade o "textoClaro" é o que está criptografado no arquivo txt.

segue pra ficar amis claro:

File bdOne = new File(System.getProperty("user.dir").concat(
        				"\\IF001.fdb"));
        	File bdTwo = new File(System.getProperty("user.dir").concat(
        				"\\IF002.fdb"));
        
        	FileInputStream in = new FileInputStream(bdOne);
        
        	InputStreamReader conversor = new InputStreamReader(in);
        
        	BufferedReader bf = new BufferedReader(conversor);
        
        	RandomAccessFile random = new RandomAccessFile(bdTwo, "r");
        
        	int i = 0;
        	
        	while ((linha = bf.readLine()) != null) {
        	    i++;
        	
        		content = linha.split(" ");
        		Long convert = new Long(content[1]);
        
        		random.seek(convert.parseLong(content[1]));
        		random.readLine();
        
        		conteudo = random.readLine();
        		byte[] textoCifrado = conteudo.getBytes();
        
        		CarregadorChavePublica ccp = new CarregadorChavePublica();
        		PublicKey pub = ccp.carregaChavePublica(new File(System.getProperty("user.dir").concat("\\chave.publica")));
        		
        		// -- Decifrando a mensagem
        		CarregadorChavePrivada ccpv = new CarregadorChavePrivada();
        		PrivateKey pvk = ccpv.carregaChavePrivada(new File(System.getProperty("user.dir").concat("\\chave.privada")));
        		Decifrador dcf = new Decifrador();
        		
			byte[] decifrado = dcf.decifra(pvk, textoCifrado , pub.getEncoded());
        
        		System.out.println(new String(decifrado));
        
        	}

Moderador Membro desde: 29/07/2004 16:10:13 Mensagens: 17543 Offline

Ah, é que não ficou muito claro no programa que eu mostrei.

A rotina "cifra" retorna 2 arrays de bytes: um deles com os dados cifrados, e outro deles com a chave simétrica (AES) cifrada com a chave assimétrica (RSA).
Quando você vai guardar esses dados, você precisa guardar os 2 arrays, não só um deles. Se você não guardar a chave simétrica cifrada com a chave assimétrica, então você nunca conseguirá decifrar os dados cifrados. Não é perigoso guardar a chave simétrica cifrada, porque ela só poderá ser decifrada por alguém que tiver a chave privada disponível.

Quando você for decifrar os dados, você precisa passar a chave privada (primeiro parâmetro), os dados cifrados (segundo parâmetro), e a chave simétrica cifrada com a chave assimétrica (terceiro parâmetro).

Se você acha isso esquisito, é o jeito correto de fazer, que é usado no padrão PKCS#7 signedData, e no padrão S/MIME (usado para mandar e-mails criptografados pelo MS Outlook, MS Outlook Express, Eudora, Mozilla Thunderbird, etc. )

Debugger Membro desde: 18/03/2008 10:27:26 Mensagens: 67 Offline

Obrigada pela paciência e grande ajuda thingol, mais assim, eu estou passando sim os três parâmetros... o estranho é q o programa funciona perfeitamente qdo rodo ele cifrando e decifrando logo em seguida, assim como está seu programa...

Agora se eu separo as classes, cifro um conteúdo e guardo em um arquivo, e depois só rodo o decifrar, ele emite esse erro... porém não entendo, pq eu estou guardando os arquivos com as chaves e lendo as duas, a pública e a privada e tbm leio no arquivo o conteúdo a ser decifrado, porém emite esse erro...

fiz algunst estes e o problema está justamente na linha

Eu não mantive da forma original, pois este envocava antes a classe para cifrar, e não é oq eu quero, pois este já está no arquivo, eu gostaria apenas de decifrar o conteúdo deste arquivo.

Desde já agradeço novamente...

Moderador Membro desde: 29/07/2004 16:10:13 Mensagens: 17543 Offline

lilirc wrote:
byte[] decifrado = dcf.decifra(pvk, textoCifrado, pub.getEncoded());

O primeiro parâmetro é a chave privada (ok)
O segundo é o texto cifrado (ok)
O terceiro não é a chave pública e sim a chave simétrica cifrada. (No programa acima era o elemento cifrado[1] do array de arrays retornado por "cifra".)

Debugger Membro desde: 18/03/2008 10:27:26 Mensagens: 67 Offline

Sim, exatamente isso, mais o "Decifra" não tem a função de tbm pegar essa chave pública criptografada, e descriptografar esta chave e com ela, tbm decifrar o texto?

Eu não queria ter de chamar o cifra, pois eu quero apenas decifrar....chamando o cifra para obter a chave, eu criptografo novamente um conteúdo q já está criptografado, e não é isso q eu quero....

O problema é que o Decifra recebe a chave pública como um array de bytes e não como um objeto PublicKey, com isso, eu não consigo transformar este objeto PublicKey em um array de bytes, caso conseguisse fazer isso, creio q resolveria meu problema.

como poderia fazer para utilizar somente o decifra, utilizando uma chave pública previamente criada e armazenada em um arquivo? Já repliquei o método cifra e tirei a parte de cifrar o texto e deixei a parte da chave para tentar utilizá-la separadamente, já tentei transformar a chave em um array de bytes, já tentei um pouco de tudo e obti diversos erros, não sei mais oq posso fazer.... conto com a sua ajuda...

Agradeço a disposição em ajudar.... Obrigada

Debugger Membro desde: 18/03/2008 10:27:26 Mensagens: 67 Offline

Existem poucos tópicos aquí a respeito de criptografia, e este está off, mais será que ninguém mais pode me ajudar?

Moderador Membro desde: 29/07/2004 16:10:13 Mensagens: 17543 Offline

Calma, vou explicar tudo de novo. Pegue a sua cadeirinha e sente-se.

Normalmente, quando se quer cifrar uma grande quantidade de dados (ou seja, mais de 100 bytes), usa-se sempre criptografia normal (ou simétrica, onde a mesma chave que serve para cifrar um dado serve para decifrá-la. Ou seja, é uma chave "secreta" ou "simétrica").
As vantagens da criptografia simétrica são:
- Muito mais rápida
- Segura para pequenas ou grandes quantidades de dados.
O algoritmo recomendado hoje em dia é o AES ou Rijndael (com força de 128, 192 ou 256 bits); usei no exemplo o AES com chave de 128 bits.
Entretanto, para você mandar um dado criptografado com criptografia simétrica, é necessário que ambas as partes (remetente e destinatário) conheçam a chave simétrica. Você deve saber muito bem que é difícil mandar essa chave a menos que você pessoalmente apareça com um envelope e o dê nas mãos da pessoa (é modo de dizer); você não pode mandá-la pelo telefone, e muito menos via sockets.
A criptografia assimétrica veio para ajudar a resolver esse problema. Se você conhecer a chave PÚBLICA do destinatário, você pode mandar um dado (com menos de 100 bytes) para ele, criptografado com a chave PÚBLICA, de modo que o destinatário use a chave PRIVADA para decifrá-la.
Dados com mais bytes não devem ser criptografados com criptografia assimétrica (por exemplo, RSA), porque isso expõe uma vulnerabilidade nesses algoritmos que só se manifesta quando a quantidade de dados é grande e os dados criptografados podem ser conhecidos. Por exemplo, se você criptografasse uma mensagem - como uma página HTML - integralmente com o algoritmo RSA, ela tem alguns valores conhecidos em vários pontos, como o começo, que normalmente é "<HTML>".
E como o meu programa faz isso? Ele gera uma chave simétrica, que será usada para criptografar os dados a serem enviados. O remetente tem de mandar para o destinatário:
- Os dados criptografados com a chave simétrica gerada pelo remetente (algoritmo AES)
- A chave simétrica criptografada com a chave pública do destinatário (algoritmo RSA)
O destinatário, para decifrar a mensagem, deve obter:
- Os dados criptografados com a chave simétrica gerada pelo remetente (algoritmo AES)
- A chave simétrica criptografada (algoritmo RSA)
O que ele tem de fazer com os dados recebidos:
- Tem de decifrar a chave simétrica criptografada com a chave privada do destinatário (usando o algoritmo RSA)
- Uma vez decifrada essa chave simétrica, deve usá-la para decifrar os dados recebidos (usando o algoritmo AES)
Note que nesse processo o destinatário NÃO PRECISA da própria chave pública. O destinatário só precisa da CHAVE PRIVADA.

Debugger Membro desde: 18/03/2008 10:27:26 Mensagens: 67 Offline

Obrigada pela paciência thingol... muitas coisas eu já havia entendido, e algumas outras ficaram mais claras para mim...

Vamos lá:

O remetente tem de mandar para o destinatário:
- Os dados criptografados com a chave simétrica gerada pelo remetente (algoritmo AES)
- A chave simétrica criptografada com a chave pública do destinatário (algoritmo RSA)

Ok, isso eu entendi... que em código seria:

O destinatário, para decifrar a mensagem, deve obter:
- Os dados criptografados com a chave simétrica gerada pelo remetente (algoritmo AES)
- A chave simétrica criptografada (algoritmo RSA)

que em código:

O que ele tem de fazer com os dados recebidos:
- Tem de decifrar a chave simétrica criptografada com a chave privada do destinatário (usando o algoritmo RSA)
- Uma vez decifrada essa chave simétrica, deve usá-la para decifrar os dados recebidos (usando o algoritmo AES)

Certo, que isto seria o papel do Decifrar

Note que nesse processo o destinatário NÃO PRECISA da própria chave pública. O destinatário só precisa da CHAVE PRIVADA.

Se ele não precisa da chave pública, o que seria o pub na linha 4 do código acima... ?

Pois, para decifrar, vc passa os seguintes parâmetros:

byte[] textoCifrado = conteudo.getBytes();
        
        		CarregadorChavePublica ccp = new CarregadorChavePublica();
			PublicKey pub = ccp.carregaChavePublica(new File(System.getProperty("user.dir").concat("\\chave.publica")));
			Cifrador cf = new Cifrador();
//////////////////////////////////////////////////////////////////////////
			byte[][] cifrado = cf.cifra(pub, textoCifrado);
//////////////////////////////////////////////////////////////////////////
        		
        		// -- Decifrando a mensagem
        		CarregadorChavePrivada ccpv = new CarregadorChavePrivada();
        		PrivateKey pvk = ccpv.carregaChavePrivada(new File(System.getProperty("user.dir").concat("\\chave.privada")));
        		
        		Decifrador dcf = new Decifrador();
        
//////////////////////////////////////////////////////////////////////////////////////
        		byte[] decifrado = dcf.decifra(pvk, cifrado[0], cifrado[1]);
///////////////////////////////////////////////////////////////////////////////////////

Onde nas linhas destacadas pvk = chave privada, cifra[0] = textoCifrado e cifrado[1] = pub, que seria a chave Pública que é obtida seu eu chamo o cifra, sendo q eu quero apenas decifrar a mensagem e não cifrá-la novamente para depois decifrá-la.

Porém, partindo do princício, se eu modificar a linha destacada do código acima, da seguinte forma:

Não é possível fazer de tal forma pq o pub é um objeto tipo PublicKey e o decifra espera um parâmetro array de bytes...

Este está sendo o meu problema... eu não sei se estou sendo clara...

Peço desculpas caso eu tenha feito muita confusão, mas o conceito de criptografar e descriptografar creio que entendi, porém não sei ao certo então o que seria a variável pub no meio de tudo isso senão a chave pública.

Obrigada pela ótima e detalhada explicação thingol, porém ainda estou um pouco confusa, como tentei explicar acima....

Abraços...

Notícias, artigos e o maior fórum brasileiro sobre Java