Trabalhando com encriptação e assinatura digital

Quer segurança nos seus dados? Então leia este artigo.

 Download do material relacionado ao tutorial

Trabalhando com encriptação e assinatura digital

Hoje em dia, na grande maioria das empresas, uma grande preocupação é questão com a segurança dos dados. Por se tratarem de dados importantíssimos para as companhias e seus clientes, é de fundamental importância garantir que eles estejam seguros e protegidos. Afinal, imagine a sua senha de acesso do Submarino sendo roubada? Seria um grande prejuízo para você e a empresa. 

A solução de parte desses problemas de segurança pode ser resolvida com a encriptação dos dados trafegados na rede, por meio de algorítmos de assinatura, com o DSA e RSA, além do uso de certificados digitais. 

Os certificados digitais são comumente usados para assinar os JARs dos Applets, para que eles possam ter acesso à máquina do cliente, ou mesmo em sites seguros, que trafegam dados como senhas, cartão de banco e etc. Estes certificados podem ter certificados conhecidos, fornecidos por grandes empresas de segurança, como a Thawte e a VeriSign, porém não há a necessidade, pois geralmente esses certificados são um pouco caros. 

Há pouco tempo eu tive um certo esforço para trabalhar com encriptação de dados e assinatura digital, para acessar um web services. Para resolver todo este problema eu utilizei um certificado digital, criado por mim mesmo e código Java para extração das chaves e geração da assinatura dos dados. 

Gerando o Certificado Digital 

Inicialmente precisamos ter um certificado digital, que será a base para encriptarmos e decriptarmos os dados. Esse certificado vai conter uma chave pública e privada. A privada é usada por você, para encriptar os dados. A chave pública você fornece para quem for decriptar os seus dados. 

No meu caso, eu assinava os dados de acesso ao Web service com a minha chave privada. O meu fornecedor do Web Service tinha uma cópia da minha chave pública, para que ele pudesse decriptar os dados que eu envei, e ele pudesse se certificar da minha autenticidade. 

O próprio JDK do Java fornece uma ferramente para gerar um certificado digital, o keytool. Não vamos explorar muito em detalhes esta ferramenta, mas vamos sim ver como gerar um simples certificado digital, que é a nossa intenção. 

A ferramente keytool recebe alguns argumentos na sua execução, que são as informações do certificado que vamos gerar. 

Para gerar o certificado, execute a seguinte linha de comando: 

keytool -genkey -alias guj -keyalg RSA -keypass guj123 -storepass guj123 -keystore C:/guj.jks -dname "cn=GUJ, ou=Artigo, o=GUJ, l=Sao Paulo, S=SP, c=BR" -validity 365

O comando acima, deve gerar o arquivo do certificado digital no caminho "C:\\guj.jks". 

Os argumentos passados para o keytool são: 

-genkey : para indicar que vamos gerar a chave. 
-alias : é o nome das chaves que serão armazenadas no keystore. No nosso caso é "guj". 
-keyalg : indica qual o algorítmo que vamos usar. No nosso caso RSA. O padrão é DSA. 
-keypass : indica a senha de proteção da chave no keystore. 
-storepass : é a senha de proteção do keystore. 
-keystore : indica onde as chaves serão armazenadas. Se nada for informado, por padrão (no Windows) é armazenada em user.home/.keystore. 
-dname : nome da entidade que vai gerar o par de chaves. Exemplo: cn = Nome Comun, ou = Unidade Organizacional (departamento ou divisão), o = Nome da Organização, l = localidade (cidade), s = Estado, c = País. 

Pronto! Agora já sabemos como criar nosso certificado digital, que possui um par de chaves privada e pública. 

Caso você necessite extrair a chave pública do seu certificado, para passar a alguém, você precisa do certificado para exportar a chave. Você deve executar o seguinte comando: 

keytool -export -alias guj -keystore C:/guj.jks -file C:/guj.x509

-export : informa que você vai exportar a chave. 
-alias : é o nome dados para a chave. 
-keystore : onde o certificado foi armazenado. 
-file : novo arquivo gerado, que é a chave pública exportada no formato X509. 

Existe uma ferramente visual para se criar e extrair os certificados digitais. Ela se chama KeyTool Explorer e pode ser encontrada em: http://www.lazgosoftware.com/kse/index.html 





Agora que temos o certificado, precisamos de uma maneira de extrair essas chaves, dentro do Java, para podermos utilizá-las para encriptação e decriptação dos dados. 

O método que simplifica a extração das chaves é o seguinte: 

01     public static PrivateKey getPrivateKeyFromFile( File cert, String alias, String password ) throws Exception { 02         KeyStore ks = KeyStore.getInstance ( "JKS" ); 03         char[] pwd = password.toCharArray(); 04         InputStream is = new FileInputStream( cert ); 05         ks.load( is, pwd ); 06         is.close(); 07         Key key = ks.getKey( alias, pwd ); 08         if( key instanceof PrivateKey ) { 09             return (PrivateKey) key; 10         } 11         return null; 12     } 13  14     /** 15      * Extrai a chave pública do arquivo. 16      */ 17     public static PublicKey getPublicKeyFromFile( File cert, String alias, String password ) throws Exception { 18         KeyStore ks = KeyStore.getInstance ( "JKS" ); 19         char[] pwd = password.toCharArray(); 20         InputStream is = new FileInputStream( cert ); 21         ks.load( is, pwd ); 22         Key key = ks.getKey( alias, pwd ); 23         Certificate c = ks.getCertificate( alias ); 24         PublicKey p = c.getPublicKey(); 25         return p; 26     }

Na chamada dos métodos informamos: 

File cert : Arquivo do certificado digital. 
String alias : alias das chaves no keystore. 
String password : senha das chaves. 

Para pegar uma instância do KeyStore, informamos JKS, que é o formato default na geração das chaves. Este é um tipo proprietário da implementação de keystore da Sun. 





Agora que já possuímos as chaves pública e privada, vamos ver como encriptar e decriptar (verificar) os dados. 

01     /** 02      * Retorna a assinatura para o buffer de bytes, usando a chave privada. 03      * @param key PrivateKey 04      * @param buffer Array de bytes a ser assinado. 05      */ 06     public static byte[] createSignature( PrivateKey key, byte[] buffer ) throws Exception { 07         Signature sig = Signature.getInstance( signatureAlgorithm ); 08         sig.initSign(key); 09         sig.update(buffer, 0, buffer.length); 10         return sig.sign(); 11     } 12  13     /** 14      * Verifica a assinatura para o buffer de bytes, usando a chave pública. 15      * @param key PublicKey 16      * @param buffer Array de bytes a ser verficado. 17      * @param sgined Array de bytes assinado (encriptado) a ser verficado. 18      */ 19     public static boolean verifySignature( PublicKey key, byte[] buffer, byte[] signed ) throws Exception { 20         Signature sig = Signature.getInstance( signatureAlgorithm ); 21         sig.initVerify(key); 22         sig.update(buffer, 0, buffer.length); 23         return sig.verify( signed ); 24     }

Os dois métodos são bem simples e nos fornecem maneiras de encriptar os dados, na forma de array de bytes e também fornece uma maneira de verificar o dado assinado. 




Para finalizar, vamos ver realmente como utilizar toda esta parafernalha. 

01     public static void main(String[] args) { 02         String txt = "String a ser encriptada"; 03  04         try { 05             File cert = new File("C:/guj.jks"); 06             String alias = "guj"; 07             String pwd = "guj123"; 08  09             PrivateKey privateKey = getPrivateKeyFromFile( cert, alias, pwd ); 10             PublicKey publicKey = getPublicKeyFromFile( cert, alias, pwd ); 11  12             byte[] txtAssinado = createSignature( privateKey, txt.getBytes() ); 13  14             System.out.println( txt2Hexa( txtAssinado ) ); 15  16             if( verifySignature( publicKey, txt.getBytes(), txtAssinado ) ) { 17                 System.out.println("Assinatura OK!"); 18             } else { 19                 System.out.println("Assinatura NOT OK!"); 20             } 21  22         } catch( Exception e ) { 23             e.printStackTrace(); 24         } 25     }

Criamos um File que representa para nosso arquivo de certificado em disco e em seguida extraimos as chaves privada e pública. 

Com o método createSignature() nós assinamos a String txt, que é o dado que desejamos encriptar (assinar). Em seguida, imprimimos na tela a representação hexadecimal da assinatura gerada. 

E, por fim, verificamos a assinatura com o método verifySignature(). O método verifica se o dado em txt é correspondente ao dado assinado (encriptado). 

O método para converter para a representação hexadecimal é o seguinte: 

01     /** 02      * Converte um array de byte em uma representação, em String, de seus hexadecimais. 03      */ 04     public static String txt2Hexa(byte[] bytes) { 05         if( bytes == null ) return null; 06         String hexDigits = "0123456789abcdef"; 07         StringBuffer sbuffer = new StringBuffer(); 08         for (int i = 0; i < bytes.length; i++) { 09             int j = ((int) bytes[i]) & 0xFF; 10             sbuffer.append(hexDigits.charAt(j / 16)); 11             sbuffer.append(hexDigits.charAt(j % 16)); 12         } 13         return sbuffer.toString(); 14     }

Conclusão 

A princípio a assinatura de dados utilizando certificado digital não parece muito simples ou trivial. Mas espero que, com este material, a vida de muitos, que precisam trabalhar com isso, possa se tornar mais fácil. 

Faça o download do arquivo Java completo deste tutorial. 

Abraços e até a próxima! 

Por Daniel Destro 
Fonte : http://www.guj.com.br/java.tutorial.artigo.141.1.guj