MiniCurso : Criptografia na plataforma .NET - Aula 5

  Chaves Assimétricas (Pública/Privada)

A criptografia de chave pública ou assimétrica é um método de criptografia que utiliza um par de chaves:

  1. Uma chave pública - É distribuída livremente para todos os participantes via email ou outras formas;

  2. Uma chave privada - A chave privada é conhecida apenas pelo seu proprietário;

Assim, em um algoritmo de criptografria assimétrica, uma mensagem cifrada com uma chave pública pode somente ser decifrada pela sua chave privada correspondente.

Maria envia a sua Chave Pública para João
1 - João cifra a mensagem com a Chave Pública de Maria e envia a mensagem para Maria
2 - Maria recebe e decifra a mensagem usando a sua chave privada.

Confidencialidade :  A chave pública é usada para cifrar mensagens.  Assim apenas o dono da chave privada pode decifrá-la.

Os algoritmos de criptografia de chave pública ou assimétricos, podem ser usados para superar as dificuldades associadas com a distribuição de forma segura da chave simétrica.

Ao invés de usar a mesma chave para cifrar de decifrar os dados, um algoritmo assimétrico utiliza duas chaves: uma pública e outra privada.

A chave pública pode ser distribuída livremente para qualquer pessoa ao passo que a chave privada deve ser guardada com segurança.

Em um cenário típico a chave pública é usada para cifrar os dados, e, a única forma que esses dados podem ser decifrados é usando a chave privada.

Esse processo garante a confidencialidade dos dados mas, como a chave pública ainda pode ser interceptada a autenticidade do remetente dos dados não pode ser confirmada.

A principal vantagem da criptografia de chaves assimétricas é que as chaves privadas nunca precisam ser transmitidas ou recebidas a ninguém e assim a chave não poderá ser interceptada por um intruso.

A desvantagem é que o método da chave pública é muito mais lento na cifragem do que o método da criptografia simétrica.

A seguir temos os algoritmos assimétricos incluídos na plataforma .NET (todos herdam da classe abstrata AsymmetricAlgorithm)

 Usando algoritmos Assimétricos

No exemplo eu vou mostrar como implementar a cifragem e decifragem usando o algoritmo assimétrico RSA.

A classe RSA é uma classe abstrata que estende a classe AsymmetricAlgorithm fornece suporte para o algoritmo RSA.

O algoritmo RSA da plataforma .NET suporta um tamanho de chave de criptografia que varia de 384 bits para 16.384 bits em incrementos de 8 bits usando o Microsoft Enhanced Cryptographic Provider e um tamanho de chave de criptografia que varia de 384 bits para 512 bits em incrementos de 8 bits usando a Microsoft Base Crystallographic Provider.

A classe RSACryptoServiceProvider estende a classe RSA e é a classe concreta o algoritmo RSA.

  

Vejamos a seguir uma aplicação prática fazendo a cifragem de dados usando uma chave pública na plataforma .NET.

Implementação da classe RSACryptoServiceProvider

Vamos criar uma aplicação do tipo Windows Forms Application  no Visual Studio Community 2015 chamada CriptografiaAssimetrica_RSA;

A seguir vamos criar uma classe chamada Criptografia em nosso projeto.

Nesta classe vamos implementar dois métodos estáticos (Shared) :

A seguir a implementação dos métodos RSACifra() e RSADecifra() no C# e no VB .NET:

using System;
using System.Security.Cryptography;

namespace CriptografiaAssimetrica_RSA
{
    public class Criptografia
    {
        static public byte[] RSACifra(byte[] byteCifrado, RSAParameters RSAInfo, bool isOAEP)
        {
            try
            {
                byte[] DadosCifrados;
                //Cria uma nova instância de RSACryptoServiceProvider.
                using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
                {
                    //Importa a informação da chave RSA. 
                    //Feito apenas para incluir a informação da chave pública
                    RSA.ImportParameters(RSAInfo);
                    //Cria o array de bytes e especifica o preenchimento OAEP
                    DadosCifrados = RSA.Encrypt(byteCifrado, isOAEP);
                }
                return DadosCifrados;
            }
            catch (CryptographicException e)
            {
                throw new Exception(e.Message);
            }
        }
        static public byte[] RSADecifra(byte[] byteDecifrado, RSAParameters RSAInfo, bool isOAEP)
        {
            try
            {
                byte[] DadosDecifrados;
                //Cria uma nova instância de RSACryptoServiceProvider.
                using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider())
                {
                    //Importa informação da chavev RSA
                    //Isso é preciso para incluir a informação da chave privada
                    RSA.ImportParameters(RSAInfo);
                    //Decifra o array de bytes e especifica o preenchimento OAEP.
                    DadosDecifrados = RSA.Decrypt(byteDecifrado, isOAEP);
                }
                return DadosDecifrados;
            }
            catch (CryptographicException e)
            {
                throw new Exception(e.Message);
            }
        }
    }
}

VB.NET

Imports System.Security.Cryptography
Public Class Criptografia
    Public Shared Function RSACifra(byteCifrado As Byte(), RSAInfo As RSAParameters, isOAEP As Boolean) As Byte()
        Try
            Dim DadosCifrados As Byte()
            'Cria uma nova instância de RSACryptoServiceProvider.
            Using RSA As New RSACryptoServiceProvider()
                'Importa a informação da chave RSA. 
                'Feito apenas para incluir a informação da chave pública
                RSA.ImportParameters(RSAInfo)
                'Cria o array de bytes e especifica o preenchimento OAEP
                DadosCifrados = RSA.Encrypt(byteCifrado, isOAEP)
            End Using
            Return DadosCifrados
        Catch e As CryptographicException
            Throw New Exception(e.Message)
        End Try
    End Function
    Public Shared Function RSADecifra(byteDecifrado As Byte(), RSAInfo As RSAParameters, isOAEP As Boolean) As Byte()
        Try
            Dim DadosDecifrados As Byte()
            'Cria uma nova instância de RSACryptoServiceProvider.
            Using RSA As New RSACryptoServiceProvider()
                'Importa informação da chavev RSA
                'Isso é preciso para incluir a informação da chave privada
                RSA.ImportParameters(RSAInfo)
                'Decifra o array de bytes e especifica o preenchimento OAEP.
                DadosDecifrados = RSA.Decrypt(byteDecifrado, isOAEP)
            End Using
            Return DadosDecifrados
        Catch e As CryptographicException
            Throw New Exception(e.Message)
        End Try
    End Function
End Class

Para testar a nossa implementação vamos incluir no formulário form1.vb  os seguintes controles:

Conforme o leiaute da figura abaixo:

A seguir defina o código abaixo para este formulário:

Imports System.Security.Cryptography
Imports System.Text
Public Class Form1
    Dim ByteConverter As New UnicodeEncoding()
    Dim RSA As New RSACryptoServiceProvider()
    Dim textoPlano As Byte()
    Dim textoCifrado As Byte()
    Dim textoDecifrado As Byte()
    Private Sub btnCifrar_Click(sender As Object, e As EventArgs) Handles btnCifrar.Click
        Try
            textoPlano = ByteConverter.GetBytes(txtTexto.Text)
            textoCifrado = Criptografia.RSACifra(textoPlano, RSA.ExportParameters(False), False)
            txtTextoCifrado.Text = ByteConverter.GetString(textoCifrado)
        Catch ex As Exception
            MessageBox.Show("Erro :" + ex.Message)
        End Try
    End Sub
    Private Sub bnDecifrar_Click(sender As Object, e As EventArgs) Handles bnDecifrar.Click
        Try
            'Enquando a Decifragem form True a informação da chave privada
            '(using RSACryptoServiceProvider.ExportParameters(true),
            textoDecifrado = Criptografia.RSADecifra(textoCifrado, RSA.ExportParameters(True), False)
            txtTextoDecifrado.Text = ByteConverter.GetString(textoDecifrado)
        Catch ex As Exception
            MessageBox.Show("Erro :" + ex.Message)
        End Try
    End Sub
End Class

Executando o projeto e realizando as operações de cifragem e decifragem iremos obter o seguinte resultado:

Pegue o projeto completo com as implementações feitas em CSharp e VB .NET aqui : CriptografiaAssimetrica_RSA.zip

Concluímos assim este mini-curso de criptografia .

Referências :

José Carlos Macoratti