Criptografia em .NET: utilizando a classe Rijndael

Ataques envolvendo tentativas de roubo ou, at� mesmo, a modificaç�o indevida de informaç�es representam uma ameaça constante em sistemas dos mais variados tipos. Senhas, mensagens de conte�do sigiloso e n�meros de cart�es de cr�dito s�o apenas alguns exemplos de dados bastante visados pelos respons�veis em levar a cabo estas aç�es.

Diante de um cen�rio em que o acesso n�o autorizado a informaç�es pode resultar em consequ�ncias imprevis�veis, muitas organizaç�es empreendem grandes esforços buscando garantir a segurança de seus dados.

A criptografia �, sem sombra de d�vidas, uma das pr�ticas mais difundidas para assegurar a integridade e a confidencialidade de informaç�es. O conceito de integridade refere-se � garantia de que dados n�o ser�o alterados de forma acidental ou, mesmo, deliberadamente, em processos que envolvam a transmiss�o de informaç�es de uma fonte a outra. J� a ideia de confidencialidade remete � noç�o de que elementos sem autorizaç�o n�o possuir�o o acesso a dados classificados como restritos.

Basicamente, o processo de criptografia consiste na criaç�o de uma codificaç�o que protege um conjunto de informaç�es, empregando para isto alguma esp�cie de algoritmo e configuraç�es conhecidos apenas por um sistema (ou ainda, por prov�veis aplicaç�es relacionadas a este �ltimo).

Diversos algoritmos computacionais foram desenvolvidos ao longo do tempo. Tais m�todos podem ser agrupados em duas formas de se proceder com a criptografia de dados:

Sim�trica: envolve o uso de uma chave privada, a qual � compartilhada pelo mecanismo que gera um conjunto de dados criptografados, assim como por aquele que receber� tais informaç�es. Na pr�tica, isto significa que uma mesma chave ser� empregada tanto para encriptar, quanto para converter os dados protegidos ao seu estado original;
Assim�trica: emprega duas chaves de criptografia (p�blica e privada) e que est�o relacionadas matematicamente entre si. Normalmente, informaç�es s�o encriptadas por meio da chave p�blica, ao passo que a chave privada relacionada serve de base para se reverter a criptografia. A criptografia assim�trica oferece maior segurança que m�todos sim�tricos, embora esteja normalmente associada � utilizaç�o de certificados digitais (o que envolver� custos adicionais para a aquisiç�o deste tipo de serviço).

A plataforma .NET suporta nativamente os dois tipos de criptografia aqui descritos. Os diferentes recursos que permitem a proteç�o de informaç�es seguindo estes princ�pios encontram-se no namespace System.Security.Cryptography. A classe Rijndael represente um bom exemplo de algoritmo sim�trico .

O objetivo deste artigo � justamente demonstrar como o tipo Rijndael pode ser utilizado na criptografia de informaç�es em aplicaç�es .NET. Para isto ser� constru�do um projeto de testes, com funcionalidades que possibilitam encriptar e decodificar strings fornecidas por um usu�rio.

Criando a aplicaç�o de exemplo

A soluç�o apresentada neste artigo foi criada no .NET framework 4.5, atrav�s da utilizaç�o do Microsoft Visual Studio 2012 Professional.

Para gerar o projeto de testes ser� necess�rio, dentro do Visual Studio, acessar o menu File, opç�o New, sub opç�o Project. Dentro da tela New Project (Figura 1) selecionar o template Windows Forms Application, informando no campo Name o nome da aplicaç�o a ser gerada (�TesteCriptografia�, neste caso); no campo Location � poss�vel ainda definir o diret�rio no qual ser�o criados os arquivos para este projeto.

Figura 1: Criando um projeto Windows Forms para testes

Criaç�o da classe utilizada para encriptar/decriptar textos

Com o projeto TesteCriptografia criado, ser� necess�rio prosseguir com a implementaç�o das classe respons�vel por criptografar/descriptografar sequ�ncias de texto (este tipo ser� chamado de �CriptografiaHelper�).

A fim de gerar o arquivo necess�rio � codificaç�o da classe CriptografiaHelper, clicar dentro do Solution Explorer com o bot�o direito do mouse sobre a aplicaç�o TesteCriptografia, escolhendo em seguida no menu de atalho a opç�o Add, sub opç�o New Item. Neste momento ser� exibida a tela Add New Item (Figura 2); preencher o campo Name com �CriptografiaHelper.cs�.

Figura 2: Criando o arquivo para implementaç�o da classe CriptografiaHelper

Foram definidos no tipo est�tico CriptografiaHelper (Listagem 1) as seguintes operaç�es envolvendo t�cnicas de criptografia sim�trica:

CriarInstanciaRijndael: respons�vel pela criaç�o de novas inst�ncias da classe Rijndael (namespace System.Security.Cryptography);
Encriptar: realiza a criptografia de texto normal, devolvendo como resultado uma string em que os diferentes bytes encriptados est�o representados no formato hexadecimal;
ArrayBytesToHexString: converte um array de bytes em uma string, com cada elemento tendo sido transformado em um valor correspondente em texto hexadecimal;
Decriptar: efetua a decriptaç�o de uma string, partindo do pressuposto que o valor a ser convertido � formado por uma sequ�ncia de caracteres representando o equivalente hexadecimal de um conjunto de bytes;
HexStringToArrayBytes: converte uma string com valores hexadecimais em um array cujos itens ser�o do tipo byte.

OBSERVAÇ�O: A fim de evitar problemas decorrentes da manipulaç�o de caracteres especiais, optou-se pela convers�o dos bytes criptografados para uma string no formato hexadecimal. Caso n�o se fizesse isto, haveria a probabilidade de ocorrerem erros ao se tentar decriptar uma string gerada anteriormente.

O m�todo privado CriarInstanciaRijndael permite a geraç�o de novos objetos do tipo Rijndael (atrav�s de uma chamada ao m�todo est�tico Create), com essas inst�ncias sendo utilizadas pelas operaç�es Encriptar e Decriptar.

A classe Rijndael � baseada em um algoritmo de mesmo nome e tamb�m conhecido como �Advanced Encryption Standard� (ou simplesmente �AES�); este padr�o depende de uma chave e de um vetor de inicializaç�o para a execuç�o de operaç�es de criptografia.

Um vetor de inicializaç�o nada mais � do que um array de bytes que reforça, por meio de operaç�es rand�micas, a segurança em um processo de criptografia. O objetivo disto � dificultar o sucesso de ataques que buscam descobrir a chave que est� sendo utilizada; normalmente, tais situaç�es envolveriam a an�lise de diversas tentativas de encriptaç�o/decriptaç�o, procurando desse modo identificar algum padr�o e assim se checar ao "segredo" empregado.

CriarInstanciaRijndael recebe como par�metros duas strings, com a primeira destas correspondendo � chave de criptografia, ao passo que o segundo valor refere-se ao vetor de inicializaç�o.

Ambos os par�metros declarados em CriarInstanciaRijndael ser�o convertidos em arrays de bytes, invocando-se para isto o m�todo GetBytes da propriedade ASCII, a qual pertence � classe est�tica Encoding (namespace System.Text). O conte�do em bytes da chave ser� ent�o associado � propriedade Key, j� o valor do vetor de inicializaç�o ser� atribu�do � propriedade IV (sigla do ingl�s "Initialization Vector").

O algoritmo Rijndael suporte chaves de 128, 192 ou 256 bits; j� para um vetor de inicializaç�o, espera-se um valor formado por 128 bits. Pelo fato de cada caractere corresponder no padr�o ASCII a 8 bits ou 1 byte, est�o sendo efetuadas consist�ncias para se garantir que a chave possua 16, 24 ou 32 caracteres, al�m do vetor de inicializaç�o se basear em uma string com 16 caracteres.

Caber� � operaç�o Encriptar executar a criptografia de textos utilizando inst�ncias da classe Rijndael. Este m�todo recebe como par�metros strings contendo a chave, o vetor de inicializaç�o e um valor a ser encriptado.

Conforme pode ser observado, o processo de encriptaç�o envolve as seguintes atividades:

Criaç�o de uma inst�ncia da classe Rijndael (vari�vel �algoritmo�), a qual � obtida realizando-se uma chamada ao m�todo CriarInstanciaRijndael;
A invocaç�o do m�todo CreateEncryptor a partir da vari�vel �algoritmo� ir� gerar um objeto (refer�ncia �encryptor�) baseado na interface ICryptoTransform (namespace System.Security.Cryptography). Essa construç�o (interface ICryptoTransform) torna poss�vel a execuç�o de operaç�es b�sicas de encriptaç�o/decriptaç�o;
A instanciaç�o de um objeto (vari�vel �streamResultado�) do tipo MemoryStream (namespace System.IO), de forma a possibilitar operaç�es sobre um stream armazenado em mem�ria. Stream � uma sequ�ncia de dados de qualquer tamanho; este tipo de estrutura representa a base a partir da qual a plataforma .NET permite a manipulaç�o de arquivos e outros agrupamentos de informaç�es;
A geraç�o de uma refer�ncia ("csStream") da classe CryptoStream (namespace System.Security.Cryptography), empregando para isto os objetos do tipos MemoryStream e ICryptoTransform; al�m disso � utilizado o valor Write do enumeration CryptoStreamMode (namespace System.Security.Cryptography), indicando assim que o processo de criptografia proceder� com a escrita de dados criptografados no objeto MemoryStream;
Uma inst�ncia do tipo StreamWriter � criada (vari�vel �writer�), repassando-se ao construtor da mesma o objeto CryptoStream gerado no passo anterior; a invocaç�o do m�todo Write far� ent�o que o valor associado ao par�metro �textoNormal� seja criptografado;
Uma chamada ao m�todo ArrayBytesToHexString, visando com isto converter um array de bytes (obtido atrav�s da operaç�o ToArray do objeto MemoryStream) para uma string, em que cada posiç�o equivale a um valor hexadecimal correspondente. Esta �ltima aç�o encerra o processo de criptografia, retornando a quem invocou a operaç�o Encriptar um texto j� convertido.

Sobre o m�todo privado ArrayBytesToHexString, � poss�vel notar no mesmo a exist�ncia de uma chamada ao m�todo est�tico ConvertAll da classe Array (namespace System). Este procedimento far� com que um array de bytes seja convertido numa construç�o equivalente, por�m empregando o tipo string; o uso do formato "X2" permite a transformaç�o de cada byte em uma string hexadecimal equivalente. Por fim, os itens do array de string s�o concatenados, gerando-se assim um texto criptografado.

O c�digo da operaç�o Decriptar � bastante semelhante � implementaç�o do m�todo Encriptar, contando apenas com algumas diferenças em virtude de se tratar de uma funcionalidade de decriptaç�o:

Inicialmente � verificado se o texto a ser decriptado (par�metro �textoEncriptado�) n�o corresponde a uma string vazia, bem como se o comprimento deste � valido (cada byte corresponde a duas posiç�es de texto representado no formato hexadecimal; logo o tamanho da string em quest�o deve ser um n�mero par);
Um objeto do tipo ICryptoTransform � ent�o criado, acionando-se para isto o m�todo CreateDecryptor a partir de uma inst�ncia da classe Rijndael;
Um MemoryStream tamb�m � gerado, baseando-se para isso num array de bytes obtido atrav�s da convers�o do par�metro "textoEncriptado" via m�todo HexStringToArrayBytes;
Tamb�m ser� instanciado um objeto CryptoStream, utilizando neste caso as refer�ncias j� criadas para os tipos MemoryStream e ICryptoTransform;
Finalmente, � gerada uma inst�ncia do tipo StreamReader (namespace System.IO), fornecendo-se ao construtor da mesma a refer�ncia CryptoStream obtida no passo anterior. A invocaç�o do m�todo ReadToEnd sobre o objeto StreamReader produzir� como resultado uma string cujo conte�do j� se encontra decriptado.

Quanto ao m�todo HexStringToArrayBytes, esta operaç�o recebe como par�metro uma string criptografada e cujos bytes encontram-se representados no formato hexadecimal. HexStringToArrayBytes devolver� como resultado de seu processamento um array de bytes. Cada conjunto de 2 caracteres corresponde a um byte, de forma que esta informaç�o � convertida atrav�s do m�todo ToByte da classe Convert (repassando-se como par�metros a esta �ltima uma string de 2 caracteres, bem como o valor 16 que indica que se est� sendo considerado um n�mero na base hexadecimal).

Listagem 1: Classe CriptografiaHelper


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace TesteCriptografia
{
    public static class CriptografiaHelper
    {
        private static Rijndael CriarInstanciaRijndael(
            string chave, string vetorInicializacao)
        {
            if (!(chave != null && 
                  (chave.Length == 16 ||
                   chave.Length == 24 ||
                   chave.Length == 32)))
            {
                throw new Exception(
                    "A chave de criptografia deve possuir " +
                    "16, 24 ou 32 caracteres.");
            }

            if (vetorInicializacao == null ||
                vetorInicializacao.Length != 16)
            {
                throw new Exception(
                    "O vetor de inicializaç�o deve possuir " +
                    "16 caracteres.");
            }

            Rijndael algoritmo = Rijndael.Create();
            algoritmo.Key =
                Encoding.ASCII.GetBytes(chave);
            algoritmo.IV = 
                Encoding.ASCII.GetBytes(vetorInicializacao);

            return algoritmo;
        }

        public static string Encriptar(
            string chave,
            string vetorInicializacao,
            string textoNormal)
        {
            if (String.IsNullOrWhiteSpace(textoNormal))
            {
                throw new Exception(
                    "O conte�do a ser encriptado n�o pode " +
                    "ser uma string vazia.");
            }

            using (Rijndael algoritmo = CriarInstanciaRijndael(
                chave, vetorInicializacao))
            {
                ICryptoTransform encryptor =
                    algoritmo.CreateEncryptor(
                        algoritmo.Key, algoritmo.IV);

                using (MemoryStream streamResultado =
                       new MemoryStream())
                {
                    using (CryptoStream csStream = new CryptoStream(
                        streamResultado, encryptor,
                        CryptoStreamMode.Write))
                    {
                        using (StreamWriter writer =
                            new StreamWriter(csStream))
                        {
                            writer.Write(textoNormal);
                        }
                    }

                    return ArrayBytesToHexString(
                        streamResultado.ToArray());
                }
            }
        }

        private static string ArrayBytesToHexString(byte[] conteudo)
        {
            string[] arrayHex = Array.ConvertAll(
                conteudo, b => b.ToString("X2"));
            return string.Concat(arrayHex);
        }

        public static string Decriptar(
            string chave,
            string vetorInicializacao,
            string textoEncriptado)
        {
            if (String.IsNullOrWhiteSpace(textoEncriptado))
            {
                throw new Exception(
                    "O conte�do a ser decriptado n�o pode " +
                    "ser uma string vazia.");
            }

            if (textoEncriptado.Length % 2 != 0)
            {
                throw new Exception(
                    "O conte�do a ser decriptado � inv�lido.");
            }


            using (Rijndael algoritmo = CriarInstanciaRijndael(
                chave, vetorInicializacao))
            {
                ICryptoTransform decryptor =
                    algoritmo.CreateDecryptor(
                        algoritmo.Key, algoritmo.IV);

                string textoDecriptografado = null;
                using (MemoryStream streamTextoEncriptado =
                    new MemoryStream(
                        HexStringToArrayBytes(textoEncriptado)))
                {
                    using (CryptoStream csStream = new CryptoStream(
                        streamTextoEncriptado, decryptor,
                        CryptoStreamMode.Read))
                    {
                        using (StreamReader reader =
                            new StreamReader(csStream))
                        {
                            textoDecriptografado =
                                reader.ReadToEnd();
                        }
                    }
                }

                return textoDecriptografado;
            }
        }

        private static byte[] HexStringToArrayBytes(string conteudo)
        {
            int qtdeBytesEncriptados =
                conteudo.Length / 2;
            byte[] arrayConteudoEncriptado =
                new byte[qtdeBytesEncriptados];
            for (int i = 0; i < qtdeBytesEncriptados; i++)
            {
                arrayConteudoEncriptado[i] = Convert.ToByte(
                    conteudo.Substring(i * 2, 2), 16);
            }

            return arrayConteudoEncriptado;
        }
    }
}

Implementando a tela para testes

Conclu�da a codificaç�o da classe CriptografiaHelper, ser� preciso agora renomear o formul�rio principal da aplicaç�o. Isto � feito, dentro da janela Solution Explorer, clicando com o bot�o direito sobre o arquivo Form1.cs e selecionando a opç�o Rename: alterar ent�o este nome de arquivo para FormPrincipal.cs. Tal procedimento far� com que a identificaç�o da classe que corresponde ao formul�rio principal da aplicaç�o tamb�m passe a ser FormPrincipal. Al�m disso, modificar por meio da janela Properties do Visual Studio a propriedade Text de FormPrincipal para �Teste de Criptografia - Utilizando a Classe Rijndael�.

Adicionar a este formul�rio os controles que se encontram listados na Tabela 1.

Tipo do Controle	Nome do Controle
GroupBox	grpConfiguracoes
Label	lblChave
TextBox	txtChave
Label	lblVetorInicializacao
TextBox	txtVetorInicializacao
GroupBox	grpEncriptacao
Label	lblTextoAEncriptar
TextBox	txtTextoAEncriptar
Button	btnEncriptar
Label	lblResultadoEncriptacao
TextBox	txtResultadoEncriptacao
GroupBox	grpDecriptacao
Label	lblTextoADecriptar
TextBox	txtTextoADecriptar
Button	btnDecriptar
Label	lblResultadoDecriptacao
TextBox	txtResultadoDecriptacao
Button	btnSair

Tabela 1: Controles a serem adicionados ao formul�rio FormPrincipal

J� a Tabela 2 lista algumas propriedades dos componentes adicionados a FormPrincipal que precisar�o ser alteradas.

Nome do Controle	Propriedade	Valor
grpConfiguracoes	Text	Configuraç�es
lblChave	Text	Chave:
txtChave	MaxLength	32
lblVetorInicializacao	Text	Vetor de Inicializaç�o:
txtVetorInicializacao	MaxLength	16
grpEncriptacao	Text	Encriptaç�o
lblTextoAEncriptar	Label	Texto a ser ncriptado:
btnEncriptar	Text	&Encriptar
lblResultadoEncriptacao	Text	Resultado:
txtResultadoEncriptacao	ReadOnly	True
grpDecriptacao	Text	Decriptaç�o
lblTextoADecriptar	Label	Texto a ser decriptado:
btnDecriptar	Text	&Decriptar
lblResultadoDecriptacao	Text	Resultado:
txtResultadoDecriptacao	ReadOnly	True
btnSair	Button	&Sair

Tabela 2: Propriedades a serem alteradas nos controles adicionados a FormPrincipal

OBSERVAÇ�O: Para efeitos de simplificaç�o, ser�o omitidos deste artigo os valores de propriedades de controles que definam tamanhos (Size, por exemplo) ou posicionamento (Location, por exemplo).

A Figura 3 demonstra um exemplo, em termos gerais, de como ficaria o formul�rio FormPrincipal ao t�rmino da configuraç�o dos controles que foram adicionados ao mesmo. Esta imagem foi gerada dentro do Visual Studio, por meio do editor visual desta ferramenta.

Figura 3: Formul�rio FormPrincipal em modo Design com todos os controles j� configurados

Por fim, na Listagem 2 � apresentado o c�digo-fonte em que se definem os diferentes m�todos de FormPrincipal:

btnEncriptar_Click: evento que � acionado ao se clicar no bot�o �btnEncriptar�, de maneira que se efetue a criptografia de uma string (via m�todo Encriptar de CriptografiaHelper), levando em conta a chave e o vetor de inicializaç�o informados por um usu�rio;
btnDecriptar_Click: evento Click do bot�o �btnDecriptar�. Possibilita a convers�o de uma string criptografada anteriormente para texto normal (por meio da operaç�o Decriptar do tipo CriptografiaHelper), empregando para isto a mesma chave e o vetor de inicializaç�o utilizados durante a encriptaç�o;
btnSair_Click: evento disparado ao se clicar no bot�o �btnSair�.

Listagem 2: Classe FormPrincipal


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace TesteCriptografia
{
    public partial class FormPrincipal : Form
    {
        public FormPrincipal()
        {
            InitializeComponent();
        }

        private void btnEncriptar_Click(object sender, EventArgs e)
        {
            try
            {
                txtResultadoEncriptacao.Text =
                    CriptografiaHelper.Encriptar(
                        txtChave.Text,
                        txtVetorInicializacao.Text,
                        txtTextoAEncriptar.Text);
            }
            catch (Exception ex)
            {
                txtResultadoEncriptacao.Text =
                    "Erro: " + ex.Message;
            }
        }

        private void btnDecriptar_Click(object sender, EventArgs e)
        {
            try
            {
                txtResultadoDecriptacao.Text =
                    CriptografiaHelper.Decriptar(
                        txtChave.Text,
                        txtVetorInicializacao.Text,
                        txtTextoADecriptar.Text);
            }
            catch (Exception ex)
            {
                txtResultadoDecriptacao.Text =
                    "Erro: " + ex.Message;
            }
        }

        private void btnSair_Click(object sender, EventArgs e)
        {
            Close();
        }
    }
}

Executando a aplicaç�o de testes

Iniciando a execuç�o da soluç�o implementada neste artigo, ser� apresentada uma tela como aquela que consta na Figura 4.

Figura 4: Projeto TesteCriptografia em execuç�o

Preencher agora a chave e o vetor de inicializaç�o. Informar uma string a ser criptografada, executando na sequ�ncia a opç�o �Encriptar�. Como resultado disso. o texto ser� convertido para um valor que j� se encontra encriptado (Figura 5); copiar tal valor para a mem�ria, j� que o mesmo ser� utilizado mais adiante.

Figura 5: Encriptando um valor

Fornecer agora um novo valor a ser criptogrado, repetindo os mesmos passos do teste anterior (Figura 6).

Figura 6: Executando um segundo teste de criptografia

Preencher agora o campo �Texto a ser decriptado� com a string que foi gerada no primeiro teste. Acionar o bot�o �Decriptar�: neste momento, o texto encriptado ser� convertido para o seu valor original (Figura 7).

Figura 7: Decriptando texto

Conclus�o

Conforme discutido ao longo deste artigo, a plataforma .NET oferece um amplo suporte na implementaç�o de funcionalidades que dependam de mecanismos de encriptaç�o. Os principais algoritmos de criptografia (tanto sim�tricos, quanto assim�tricos) contam com classes pr�prias no .NET Framework, sendo um bom exemplo disto o tipo Rijndael.

Por mais que a criptografia contribua para uma maior proteç�o de dados sens�veis, a adoç�o desta pr�tica n�o garante que uma aplicaç�o estar� livre de ataques. A segurança de informaç�es � um assunto bastante amplo e, frequentemente, exigir� que as organizaç�es combinem diversas t�cnicas a fim de alcançarem os resultados esperados.

Espero que o conte�do aqui apresentado tenha sido �til. At� uma pr�xima oportunidade!