Pesquisa personalizada

Iniciamos há algumas semanas nossa série sobre criptografia de dados. Na coluna em http://www.bufaloinfo.com.br/artigos/coluna08.asp explicamos detalhes sobre as metodologias de criptografia de dados e no artigo em http://www.bufaloinfo.com.br/artigos/artigo2405.asp explicamos o funcionamento da metodologia de hash.

Neste artigo vamos ver detalhes sobre mais uma das metodologias de criptografia, a criptografia simétrica.

A criptografia simétrica consiste em, basicamente, criptografar informações com uma senha (chave) e um algorítimo. Para descriptografar aquele que recebe a informação deverá utilizar a mesma chave e o mesmo algorítimo.

Portanto a criptografia simétrica depende do transmissor e receptor já terem entrado em acordo com relação a chave a ser utilizada, utilizando algum meio seguro para trocarem a chave entre si.

O processo de realização da criptografia é feito dividindo-se a mensagem em pequenos blocos e aplicando a senha e o algorítimo a cada bloco da mensagem. Claro que alguns métodos existentes nas classes que implementam a criptografia fazem esse trabalho para nós, simplificando o processo.

Mas para garantir a segurança da criptografia simétrica é necessário mais do que a chave. Imagine que tenhamos a palavra "computador" dentro de um texto, se repetindo inúmeras vezes. Aplicando sempre o mesmo algorítimo e a mesma chave a palavra "computador" sempre aparecerá criptografada da mesma forma. Isso permite que alguém, tentando decifrar a mensagem, comece a fazer análise da estrutura das palavras contidas na mensagem e, se descobrir que determinada palavra significa "computador", descobrirá a senha e decifrará a mensagem.

Para evitar isso, além de aplicar a senha e o algorítimo a cada bloco da mensagem que estará sendo criptografado, aplica-se também um valor resultante de um cálculo com o bloco de dados anterior. Com isso a palavra "computador" aparecerá de forma diferente a cada ocorrência dentro da mensagem, impossibilitando que se consiga descobrir a senha.

O primeiro bloco de dados, porém, ficaria sem a aplicação de um valor de bloco anterior (pois não existe). Para resolver este problema os algorítimos simétricos utilizam um initialization vector - IV - vetor de inicialização, que determina um conjunto de bytes inicial que o algorítimo aplicará ao primeiro bloco que estará sendo criptografado e, a partir dai, esse vetor mudará a cada bloco calculado.

As classes que implementam os algorítimos de criptografia são capazes de fazer a geração automática tanto da chave para criptografia como do Initialization Vector. Ambos, porém, precisam ser passados para o receptor para que o receptor possa descriptografar as mensagens recebidas. Então o transmissor precisa gerar a chave e o vetor de inicialização e passa-los de forma segura para o receptor. Podemos criar uma pequena aplicação que faça a geração de chaves para fazer parte deste trabalho.

Antes de começar, vamos dar uma olhada nas classes do .NET que implementam criptografia sincrona :

Vamos então criar um formulário Windows com 2 caixas de texto e um botão. Vamos fazer com que o botão, ao ser clicado, gere a chave de criptografia e o initialization vector.

Para exibir as chaves nas textbox, vamos fazer com que esta aplicação monte uma string com uma instrução dim, definindo uma variável para conter as chaves, algo +/- assim :

Dim chave as byte()= {1,2,3,4}
       

Então precisaremos de uma função que a partir do byte array da chave (sempre gerada no formato de byte array) gere a instrução dim correspondente.

 Private Function montarinstrucao(ByVal b As Byte()) As String

   Dim s As String
   Dim by As Byte
   s = "{"
   For Each by In b
   s &= by.ToString & ","
   Next
   s = Microsoft.VisualBasic.Left(s, Len(s) - 1)
   s &= "}"

   s = "Dim vetor as byte() = " & s
   Return (s)
 End Function
       

Como vemos acima, trata-se de um código simples para fazer a montagem da instrução dim a partir de um byte array. O passo seguinte é montarmos o código do botão para fazermos a geração das chaves :

 Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
    Dim obj As New RC2CryptoServiceProvider

    Dim b As Byte()

    obj.GenerateIV()
    b = obj.IV

    TextBox2.Text = montarinstrucao(b)
    obj.GenerateKey()
    b = obj.Key
    TextBox1.Text = montarinstrucao(b)
 End Sub
       

O objeto responsável por realizar a criptografia possui os métodos generateIV e generateKey . Tendo executado esses métodos podemos recuperar os valores de Key e IV e utilizar nossa função para realizar a exibição destes valores.

Vamos então montar uma pequena aplicação para testar a criptografia e descriptografia. Vamos criar um formulário windows com 3 textbox e 2 botões.

A primeira textbox servirá para digitarmos a mensagem a ser criptografada. A 2a textbox exibirá o resultado da criptografia e a 3a textbox exibirá a mensagem novamente, depois de ser descriptografada. Já os dois botões servirão um para criptografar e outro para descriptografar a mensagem.

Vamos manter o objeto para realização da criptografia a nível de formulário e, no load, vamos configura-lo. Veja como fica :

   Dim obj As New RC2CryptoServiceProvider
   Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

       Dim chave As Byte() = {242, 186, 54, 173, 133, 182, 147, 252, 77, 181, 139, 132, 80, 110, 159, 21}
       Dim vetor As Byte() = {137, 220, 146, 142, 243, 0, 169, 32}
       obj.IV = vetor
       obj.Key = chave
   End Sub
       

Observe que no load estamos utilizando duas definições de variáveis criadas pela primeira aplicação que fizemos neste artigo. atribuimos as chaves nas respectivas propriedades da classe para criptografia.

Veja como fica o botão para criptografar :

   Dim b As Byte()
   Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        Dim enc As ICryptoTransform
        enc = obj.CreateEncryptor()
        b = enc.TransformFinalBlock(ASCII.GetBytes(TextBox1.Text), 0, Len(TextBox1.Text))
        TextBox2.Text = ASCII.GetString(b)
   End Sub
       

A partir da classe que implementa o algorítimo de criptografia utilizamos o método createEncryptor, que gera um objeto que implementa a interface ICryptoTransform e, desta forma, realiza o processo de criptografia.

O botão para descriptografar é praticamente identico, veja :

 Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
   Dim enc As ICryptoTransform
   enc = obj.CreateDecryptor()
   b = enc.TransformFinalBlock(b, 0, b.Length)
   TextBox3.Text = ASCII.GetString(b)
 End Sub

No artigo anterior, sobre utilização de algorítimos de Hash, utilizamos uma classe chamada clsHashHelper para auxiliar no processo de criptografia de uma mensagem em um webService e descriptografia no client.

Da mesma forma, podemos ter uma classe clCryptoHelper para nos auxiliar com a criptografia simétrica. A criptografia simétrica é mais simples do que o Hash, pois não precisa da comparação entre os hashs. Porém, da mesma forma que ocorre com o Hash, precisamos formatar a mensagem criptografada na forma de um conjunto de bytes para podermos realizar a transmissão via HTTP, caso contrário alguns caracteres seriam inválidos para o XML.

Vamos então fazer uma classe para realizar essa formatação, da mesma forma que fizemos na classe de Hash. Veja como fica :

Imports System.Security.Cryptography
   Imports System.Text.ASCIIEncoding
   Public Class clCryptoHelper
       Dim obj As New RC2CryptoServiceProvider
       dim vchave as byte()
       dim vIV as byte()
   
       Private Function InterpretarMensagem(ByVal mensagem As String) As mensagem
          Dim r As Byte()
          Dim ar As String() = mensagem.Split(" ")
          Dim a As Integer
          r = New Byte(ar.Length - 1) {}
          For a = 0 To r.Length - 1
             r(a) = Byte.Parse(ar(a), System.Globalization.NumberStyles.HexNumber)
          Next
          Return (r.tostring)
      End Function

      Private Function formatarMensagem(ByVal mensagem As Byte()) As String
         Dim r As String
         Dim a As Integer
         For a = 0 To hash.Length - 1
             r &= Hex(mensagem(a)) & " "
         Next
         Return (Trim(r))
      End Function

      Private Function Criptografar(ByVal mensagem As String) As String

         Dim enc As ICryptoTransform
         obj.key=vchave
         obj.iv=vIV
         enc = obj.CreateEncryptor()
         b = enc.TransformFinalBlock(ASCII.GetBytes(mensagem), 0, Len(mensagem))
         return(formatarmensagem(b))

     End Function
       

      Private Function DesCriptografar(ByVal mensagem As String) As String
         Dim enc As ICryptoTransform
         enc = obj.CreateDecryptor()
         obj.key=vchave
         obj.iv=vIV
         b = enc.TransformFinalBlock(interpretarmensagem(mensagem), 0, len(mensagem))
         return(ASCII.GetString(b))
      End Function
       

      Public Property chave() As Byte()
         Get
            Return (vchave)
         End Get
         Set(ByVal Value As Byte())
            vchave = Value
         End Set
     End Property

     Public Property IV() As Byte()
        Get
          Return (vIV)
        End Get
        Set(ByVal Value As Byte())
          vIV = Value
        End Set
   End Property

 End Class
       

Podemos observar que temos nesta classe 2 métodos principais, criptografar e descriptografar. Esses métodos fazem uso das funções internas de formatação, encapsulando esta necessidade e desta forma simplificando o processo de criptografia. Com isso fica bem mais simples gerar um webService com transmissão criptografada.

Da mesma forma como no artigo anterior, para montar o webService precisaremos de uma classe personalizada para a devolução dos dados, mas a classe será um pouco diferente desta vez. Veja o exemplo :

 <WebMethod()> _
   Public Function RetornaClientes() As Retorno
      Dim obj As New Retorno
      dim cripto as new clCryptoHelper

      cripto.key = {242, 186, 54, 173, 133, 182, 147, 252, 77, 181, 139, 132, 80, 110, 159, 21}
      Cripto.IV = {137, 220, 146, 142, 243, 0, 169, 32}

      DA.Fill(Ds1)
           
      obj.dados = cripto.Criptografar(Ds1.GetXml)
      Return (obj)
   End Function

 <Serializable()> _
   Public Class Retorno
      Public dados As string
   End Class

O client precisará utilizar a mesma classe para descriptografar as informações. Veja como fica :

 Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _
   Handles Button1.Click
   Dim obj As New srvDados.Service1
   Dim ret As srvDados.Retorno
   dim dados as dataset

   dim cripto as new clCryptoHelper

   cripto.key = {242, 186, 54, 173, 133, 182, 147, 252, 77, 181, 139, 132, 80, 110, 159, 21}
   Cripto.IV = {137, 220, 146, 142, 243, 0, 169, 32}
       

   ret = obj.RetornaClientes
   dados.readxml(cripto.descriptografar(ret.dados))

   DG.DataSource = dados.tables(0)
 End Sub
       


DENNES TORRES
MCAD,MCSD,MCSE,MCDBA

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Conheça mais sobre o nosso site :

• Visite nossa área de artigos técnicos
• Conheça nossas dicas técnicas (mais de 300 dicas)
• Conheça nosso fórum de discussões
• Conheça nossa área de download com muitos componentes e códigos úteis
• Conheça nosso treinamento de lógica de programação on-line
• Conheça nossa prova de certificação em VB (oferecemos certificado aos aprovados)

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::