Como criar uma Assinatura Digital em Java

A assinatura digital tem como função oferecer a garantia da procedência de um documento e se este documento sofreu alguma alteração não autorizada. Com a ocorrência cada vez maior dos crimes digitais e dada a importância dos documentos e arquivos para pessoas e organizações torna-se cada mais importante a sua segurança.

Devido o grande número de pessoas e empresas que utilizam a assinatura digital foram realizadas formas de organizar e padronizar as operações. Com isso a ICP-Brasil realizou toda essa organização e padronização por meio da certificação digital e das suas autoridades certificadoras. Por isso as assinaturas digitais hoje são consideradas bastante seguras.

Portanto, a assinatura digital garante que um documento não foi modificado e realmente procede a identidade de quem diz ter enviado certo documento.

No restante do artigo veremos como funciona a assinatura digital em Java, o que é o algoritmo DSA utilizado para assinatura digital e por fim faremos um exemplo completo em Java demonstrando como implementa-lo na prática.

Como Funciona a Assinatura Digital em Java

Veremos nesta seção como se dá o suporte provido pela API Java para a criptografia e a verificação de dados através de assinaturas digitais.

Todo o suporte necessário para implementarmos a assinatura digital em Java é provido pela API padrão do Java. Dessa forma, não necessitaremos recorrer a bibliotecas externas.

O Java traz dois métodos para os desenvolvedores que querem trabalhar com assinaturas digitais, são eles: os Message Digest e as Assinaturas digitais. O Message Digest são funções hash que geram código de tamanho fixo e unidirecional, ou seja, a partir de dados de um tamanho qualquer teremos como resultado um hash que não poderá mais ser revertido de volta para a mensagem original. Por isso quando estamos trabalhando com hashs deveremos gerar um hash de uma mensagem e comparar com o hash anterior. A API Java implementa dois algoritmos de Message Digest, são eles o MD5 e a família SHA; O outro método é o de Assinaturas Digitais que serve para autenticar o remetente da informação e oferecer a garantia de que o dado é confiável. As assinaturas digitais trabalham com a assinatura em si, uma chave pública e uma chave privada. O remetente é quem deve gerar a assinatura, a chave pública e a chave privada e, além disso, também deve fornecer a chave pública aos destinatários de suas mensagens.

Quando o remetente deseja enviar um dado ele gera uma assinatura usando a chave privada. O destinatário receberá a mensagem e a assinatura e com isso fará a validação da informação usando a chave pública. Se a validação for realizada com sucesso o destinatário tem a garantia que a mensagem foi enviada por um remetente confiável, possuidor da chave privada.

Para utilizar o Message Digest basta obter uma instância do algoritmo a ser utilizado, passar a informação que desejamos criptografar e por fim realizar a criptografia.

Para obter a instância do algoritmo podemos utilizar o código da Listagem 1.

MessageDigest md5 = MessageDigest.getInstance("MD5");

Após isso, podemos utilizar o método update() passando os dados a serem criptografados. Para o algoritmo voltar ao estado original utilizamos o método reset(). Por fim, utilizamos digest() para gerar a chave criptografada.

Uma assinatura possui duas propriedades: a primeira propriedade diz que através da chave pública (correspondente à chave privada usada para geração da assinatura digital) podemos verificar a autenticidade e a integridade dos dados que estão sendo transmitidos; e a outra propriedade diz que a assinatura digital e a chave pública não revelam a chave privada.

A classe Java responsável por gerar as assinaturas digitais é a Signature. Para criar um objeto Signature utilizamos a chamada presente na Listagem 2.

Signature signature = Signature.getInstance("DSA");

No exemplo acima estamos utilizando o algoritmo DSA.

Para gerar as chaves públicas e privadas utilizamos a classe KeyPairGenerator. KeyPairGenerator também necessita de um algoritmo para gerar as chaves. Segue na Listagem 3 um exemplo de como podemos gerar as chaves:

KeyPairGenerator kpg = KeyPairGenerator.getInstance("DSA");

Tanto as chaves quanto a assinatura devem ser geradas utilizando-se o mesmo algoritmo (no exemplo o DSA). Após obtermos as chaves do KeyPairGenerator devemos inicializa-lo através do método initialize() que recebe um tamanho de chave e um número aleatório através da classe SecureRandom. Segue na Listagem 4 como podemos gerar as chaves.

KeyPairGenerator kpg = KeyPairGenerator.getInstance("DSA");  
SecureRandom secureRan = new SecureRandom();  
kpg.initialize(512, secureRan);  
KeyPair kp = keyGen.generateKeyPair();  
PublicKey pubKey = kp.getPublic();  
PrivateKey priKey = kp.getPrivate();

Agora que temos a nossa chave privada podemos utilizá-la no nosso objeto Signature, segue o código da Listagem 5.

signature.initSign(priKey);

Nesse momento já podemos utilizar o método update() para que a informação possa ser assinada ou verificada, como mostra a Listagem 6.

String mensagem = "Exemplo de mensagem";
signature.update(mensagem.getBytes());

E por fim chamamos o método sign() para a geração da assinatura, conforme mostra o exemplo da Listagem 7.

byte[] assinatura = signature.sign();

Com isso, o remetente agora precisa fornecer a chave pública juntamente com o dado a ser enviado e a assinatura correspondente.

O destinatário receberá a assinatura digital e deve ter acesso à chave pública para então validar a assinatura junto com o dado recebido utilizando a chave pública. Segue na Listagem 8 um exemplo de como isso pode ser feito.

Signature signature = Signature.getInstance("DSA");  
signature.initVerify(pubKey);  
signature.update(mensagem.getBytes());  
      
if (signature.verify(assinatura)) {  
         //Mensagem assinada corretamente  
} else {  
         //Mensagem não pode ser validada
}

Algoritmo DSA

A assinatura digital traz ao público de segurança de dados algoritmos como o DSA, que foi proposto pelo National Institute of Standards and Technology (NIST) e mais tarde padronizado. O DSA pode ser combinado com um algoritmo de criptografia, como, por exemplo, o RSA, e com alguma das funções hash como o MD5, o MD2, a família SHA, entre outros.

O DSA (Digital Signature Algorithm) é um algoritmo utilizado para assinatura digital, não sendo utilizado para criptografar dados. O algoritmo DSA foi criado no NSA (National Security Agency), a agência de segurança dos Estados Unidos com funções relacionadas a inteligência de sinais incluindo a interceptação e criptoanálise, e é patenteado pelo governo dos Estados Unidos. O NIST, uma agência governamental não regulatória da administração de tecnologia do Departamento de Comércio dos Estados Unidos que tem como missão promover a inovação e competitividade industrial dos Estados Unidos, aprovou o DSA como um padrão de assinatura digital federal.

Antes de verificarmos melhor o DSA devemos saber a relação entre o DSS e o DSA. O Digital Signature Standard (DSS) ou Padrão de Assinatura Digital é baseado em um método de criptografia com chave pública que utiliza o Digital Signature Algorithm (DSA) ou Algoritmo de Assinatura Digital. DSS é o formato das assinaturas digitais apoiado pelo governo dos Estados Unidos. O algoritmo DSA consiste de uma chave privada que somente o criador do documento (assinante) conhece e de uma chave pública.

Inicialmente quando o DSA foi proposto pela primeira vez, a Indústria RSA de Segurança de Dados e as companhias que já haviam autorizado o algoritmo RSA lançaram uma campanha contra o algoritmo DSA. Essa campanha contra o DSA foi por causa de uma possível "porta de armadilha" que poderia permitir ao governo dos Estados Unidos quebrar o DSA. A insatisfação foi com relação a velocidade do algoritmo e o tamanho da chave.

Quando o padrão foi proposto o tamanho da chave era de 512 bits, que é considerado pequeno. O padrão final permite chaves de até 1025 bits, que é mais do que o suficiente para necessidades de segurança.

As matemáticas são muito diferentes do RSA, mas a segurança é semelhante para chaves de tamanhos semelhantes. Por isso, qualquer grande avanço na quebra do RSA também implicará um avanço semelhante na quebra do RSA e vice-versa.

Em termos de velocidade e eficiência entre o DSA e o RSA as publicações realizadas pela Indústria RSA de Segurança de Dados mostram que o RSA é melhor que o DAS. Já as publicações realizadas pelo NIST mostram que o DSA é melhor que o RSA. Em termos gerais utilizando o RSA temos um tempo maior para assinar uma mensagem do que verificar uma assinatura. Com o DSA tanto a operação de assinatura quanto a operação de verificação levam a mesma quantidade de tempo.

O funcionamento do algoritmo não é muito complicado conforme veremos nos próximos passos a serem seguidos.

A primeira parte do algoritmo DSA é a geração da chave pública e da chave privada, conforme descrito abaixo:

• Escolher um número primo q, que é chamado de divisor primo.
• Escolher outro número primo p, tal que p-1 mod q=0. p é chamado de módulo principal.
• Escolher um inteiro g, tal que 1 < g < p, g**q mod p = 1 e g = h**((p–1)/q) mod p.
• Escolher um inteiro, tal que 0 < x < q.
• Computar y como g**x mod p.
• Empacotar a chave pública como {p, q, g, y}.
• Empacotar a chave privada como {p, q, g, x}.

A segunda parte do algoritmo DSA é a geração da assinatura e a verificação da assinatura, que pode serão descritas em dois passos principais.

Para gerar uma assinatura de uma mensagem, o remetente pode seguir estes passos:

• Gerar o Message Digest h, usando um algoritmo de hash como SHA1.
• Gerar um número aleatório k, tal que 0 < k < q.
• Computar r como (g**k mod p) mod q. Se r = 0, selecionar um k diferente.
• Computar i, tal que k*i mod q = 1.
• Computar s = i*(h+r*x) mod q. Se s=0, selecionar um k diferente.
• Empacotar a assinatura digital como {r,s}.

Para verificar uma assinatura de mensagem, o receptor da mensagem e da assinatura digital pode seguir os seguintes passos:

• Gerar o Message Digest h, usando o mesmo algoritmo de hash.
• Computar w, tal que s*w mod q = 1.
• Computar u1 = h*w mod q.
• Computar u2 = r*w mod q.
• Computar v = (((g**u1)*(y**u2)) mod p) mod q.
• Se v==r, a assinatura digital é válida.

Para demonstrar um exemplo simples do funcionamento do DSA, vamos tentar com o menor divisor primo q = 3 e um módulo primo p = 7.

O processo de geração da chave pública e da chave privada é ilustrada abaixo:

• q = 3, onde o divisor primo é selecionado;
• p = 7, módulo primo computado: (p-1) mod q = 0;
• g = 4, computado através de 1 < g < p, g**q mod p = 1 e g = h**((p–1)/q) mod p, assim 4**3 mod 7 = 1: 64 mod 7 = 1;
• x = 5, selecionado: 0 < x < q;
• y = 2, computado: y = g**x mod p = 4**5 mod 7;
• {7,3,4,2}, a chave pública: {p,q,g,y}.
• {7,3,4,5}, a chave privada: {p,q,g,x}.

Com a chave privada {p,q,g,x}={7,3,4,5}, o processo de geração da assinatura digital de uma mensagem de valor de hash h = 3 pode ser ilustrado como:

• h = 3, valor do hash;
• k = 2, selecionado: 0 < k < q;
• r = 2, onde temos que r = (g**k mod p) mod q = (4**2 mod 7) mod 3;
• i = 5, onde temos que k*i mod q = 1: 2*i mod 3 = 1;
• s = 2, onde temos que s = i*(h+r*x) mod q = 5*(3+2*5) mod 3;
• {2,2}, que é a assinatura digital.

O processo de verificação da assinatura digital {r, s} = {2,2} com a chave pública {p, q, g, y} = {7,3,4,2} pode ser ilustrado como:

• h = 3, o valor do hash;
• w = 5, onde temos que s*w mod q = 1: 2*w mod 3 = 1;
• u1 = 0, onde temos que u1 = h*w mod q = 3*5 mod 3 = 0;
• u2 = 1, onde temos que u2 = r*w mod q = 2*5 mod 3 = 1;
• v = 2, onde temos que v = (((g**u1)*(y**u2)) mod p) mod q que é igual a (((4**0)*(2**1)) mod 7) mod 3 = 2;
• v == r, portanto a verificação está Ok.

Dessa forma, o valor de verificação corresponde ao valor esperado.

O autor William Stallings provou através de um teorema que o DSA é legítimo e tem fundamento, portanto ele realmente funciona. Para quem estiver mais interessado sobre o assunto pode visitar o site e verificar como Stallings provou o correto funcionamento do DSA.

Exemplificando a Assinatura Digital em Java

Primeiramente mostraremos abaixo a parte do remetente que é responsável por gerar uma mensagem e enviar a mensagem com uma assinatura digital e a chave pública para o destinatário. Segue na Listagem 9 o código do remetente.

import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;
import java.security.SignatureException;


public class RemetenteAssiDig {

     private PublicKey pubKey;
     
     public PublicKey getPubKey() {
           return pubKey;
     }

     public void setPubKey(PublicKey pubKey) {
           this.pubKey = pubKey;
     }
     

     public byte[] geraAssinatura(String mensagem) throws NoSuchAlgorithmException, 
     InvalidKeyException, SignatureException {
           Signature sig = Signature.getInstance("DSA");
         
         //Geração das chaves públicas e privadas
         KeyPairGenerator kpg = KeyPairGenerator.getInstance("DSA");
         SecureRandom secRan = new SecureRandom();  
         kpg.initialize(512, secRan);  
         KeyPair keyP = kpg.generateKeyPair();  
         this.pubKey = keyP.getPublic();  
         PrivateKey priKey = keyP.getPrivate();
         
         //Inicializando Obj Signature com a Chave Privada
         sig.initSign(priKey);
         
         //Gerar assinatura
         sig.update(mensagem.getBytes());  
         byte[] assinatura = sig.sign(); 
         
         return assinatura;
     }
     
}

Também devemos criar o destinatário que é quem vai receber a mensagem, a assinatura digital e a chave pública para fazer a validação da mensagem recebida. Segue na Listagem 10 o código do destinatário.

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;


public class DestinatarioAssiDig {

   public void recebeMensagem(PublicKey pubKey, String mensagem, byte[] assinatura) throws 
   NoSuchAlgorithmException, InvalidKeyException, SignatureException {
       Signature clientSig = Signature.getInstance("DSA");  
       clientSig.initVerify(pubKey);  
       clientSig.update(mensagem.getBytes());  
         
       if (clientSig.verify(assinatura)) {  
           //Mensagem corretamente assinada
          System.out.println("A Mensagem recebida foi assinada corretamente.");
       } else {
           //Mensagem não pode ser validada
          System.out.println("A Mensagem recebida NÃO pode ser validada.");
       }  
   }
   
}

Agora podemos testar os códigos através de uma classe principal que gera diferentes tipos de mensagens, assinaturas e chaves para validar a mensagem por um destinatário. Segue na Listagem 11 o código.

import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.PublicKey;
import java.security.SignatureException;


public class AssinaturaDigital {

 public static void main(String args[]) throws NoSuchAlgorithmException, 
 InvalidKeyException, SignatureException {
     //Remetente Gera Assinatura Digital para uma Mensagem
       RemetenteAssiDig remetenteAssiDig = new RemetenteAssiDig();
       String mensagem = "Exemplo de mensagem.";
     byte[] assinatura = remetenteAssiDig.geraAssinatura(mensagem);
     //Guarda Chave Pública para ser Enviada ao Destinatário
     PublicKey pubKey = remetenteAssiDig.getPubKey();

     //Destinatário recebe dados correto
     DestinatarioAssiDig destinatarioAssiDig = new DestinatarioAssiDig();
     destinatarioAssiDig.recebeMensagem(pubKey, mensagem, assinatura);
     
     //Destinatário recebe mensagem alterada
     String msgAlterada = "Exemplo de mensagem alterada.";
     destinatarioAssiDig.recebeMensagem(pubKey, msgAlterada, assinatura);

     //Criando outra Assinatura
       String mensagem2 = "Exemplo de outra mensagem.";  
     byte[] assinatura2 = remetenteAssiDig.geraAssinatura(mensagem2);
     //Guarda Chave Pública para ser Enviada ao Destinatário
     PublicKey pubKey2 = remetenteAssiDig.getPubKey();

     //Destinatário recebe outra assinatura
     destinatarioAssiDig.recebeMensagem(pubKey, mensagem, assinatura2);
     
     //Destinatário recebe outra chave pública
     destinatarioAssiDig.recebeMensagem(pubKey2, mensagem, assinatura);


 }
 
}

Para o código acima temos o resultado abaixo como saída:

A Mensagem recebida foi assinada corretamente.
A Mensagem recebida NÃO pode ser validada.
A Mensagem recebida NÃO pode ser validada.
A Mensagem recebida NÃO pode ser validada.

Neste artigo procuramos focar mais no algoritmo DSA que é bastante utilizado na indústria e conforme havia sido solicitado pelos leitores. Nos próximos artigos sobre o assunto falaremos mais sobre o Elliptic Curve Digital Signature Algorithm (ECDSA) e analisamos algumas das suas vantagens e diferenças em relação ao DSA. Aproveito o espaço para informar que estamos abertos a sugestões dos leitores aqui neste espaço ou por e-mail.