Em diversos casos é necessário um processo de segurança em nossas informações.  Um dos algorítmos mais seguros e usados atualmente é o Rijndael, também conhecido com AES.
 
O Rijndael é um algoritmo simétrico de chave variável (os valores possíveis para o tamanho das chaves são: 128bits, 192bits, 256bits) o que dificulta muito o trabalho de quebra dos valores.  Ele está disponível a partir do .net framework 3.5.
 
Para utilizar este recurso é necessário importar alguns namespaces não esquecendo do de criptografia, assim:
 

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;


Abaixo segue a classe de criptografia utilizando esse recurso:


public class Criptografia
{
/// <summary>
/// Vetor de bytes utilizados para a criptografia (Chave Externa)
/// </summary>
private static byte[] bIV =
{ 0x50, 0x08, 0xF1, 0xDD, 0xDE, 0x3C, 0xF2, 0x18,
0x44, 0x74, 0x19, 0x2C, 0x53, 0x49, 0xAB, 0xBC };

/// <summary>
/// Representação de valor em base 64 (Chave Interna)
/// O Valor representa a transformação para base64 de
/// um conjunto de 32 caracteres (8 * 32 = 256bits)
/// A chave é: "Criptografias com Rijndael / AES"
/// </summary>
private const string cryptoKey =
"Q3JpcHRvZ3JhZmlhcyBjb20gUmluamRhZWwgLyBBRVM=";

/// <summary>
/// Metodo de criptografia de valor
/// </summary>
/// <param name="text">valor a ser criptografado</param>
/// <returns>valor criptografado</returns>
public static string Encrypt(string text)
{
try
{
// Se a string não está vazia, executa a criptografia
if (!string.IsNullOrEmpty(text))
{
// Cria instancias de vetores de bytes com as chaves
byte[] bKey = Convert.FromBase64String(cryptoKey);
byte[] bText = new UTF8Encoding().GetBytes(text);

// Instancia a classe de criptografia Rijndael
Rijndael rijndael = new RijndaelManaged();

// Define o tamanho da chave "256 = 8 * 32"
// Lembre-se: chaves possíves:
// 128 (16 caracteres), 192 (24 caracteres) e 256 (32 caracteres)
rijndael.KeySize = 256;

// Cria o espaço de memória para guardar o valor criptografado:
MemoryStream mStream = new MemoryStream();
// Instancia o encriptador
CryptoStream encryptor = new CryptoStream(
mStream,
rijndael.CreateEncryptor(bKey, bIV),
CryptoStreamMode.Write);

// Faz a escrita dos dados criptografados no espaço de memória
encryptor.Write(bText, 0, bText.Length);
// Despeja toda a memória.
encryptor.FlushFinalBlock();
// Pega o vetor de bytes da memória e gera a string criptografada
return Convert.ToBase64String(mStream.ToArray());
}
else
{
// Se a string for vazia retorna nulo
return null;
}
}
catch (Exception ex)
{
// Se algum erro ocorrer, dispara a exceção
throw new ApplicationException("Erro ao criptografar", ex);
}
}

/// <summary>
/// Pega um valor previamente criptografado e retorna o valor inicial
/// </summary>
/// <param name="text">texto criptografado</param>
/// <returns>valor descriptografado</returns>
public static string Decrypt(string text)
{
try
{
// Se a string não está vazia, executa a criptografia
if (!string.IsNullOrEmpty(text))
{
// Cria instancias de vetores de bytes com as chaves
byte[] bKey = Convert.FromBase64String(cryptoKey);
byte[] bText = Convert.FromBase64String(text);

// Instancia a classe de criptografia Rijndael
Rijndael rijndael = new RijndaelManaged();

// Define o tamanho da chave "256 = 8 * 32"
// Lembre-se: chaves possíves:
// 128 (16 caracteres), 192 (24 caracteres) e 256 (32 caracteres)
rijndael.KeySize = 256;

// Cria o espaço de memória para guardar o valor DEScriptografado:
MemoryStream mStream = new MemoryStream();

// Instancia o Decriptador
CryptoStream decryptor = new CryptoStream(
mStream,
rijndael.CreateDecryptor(bKey, bIV),
CryptoStreamMode.Write);

// Faz a escrita dos dados criptografados no espaço de memória
decryptor.Write(bText, 0, bText.Length);
// Despeja toda a memória.
decryptor.FlushFinalBlock();
// Instancia a classe de codificação para que a string venha de forma correta
UTF8Encoding utf8 = new UTF8Encoding();
// Com o vetor de bytes da memória, gera a string descritografada em UTF8
return utf8.GetString(mStream.ToArray());
}
else
{
// Se a string for vazia retorna nulo
return null;
}
}
catch (Exception ex)
{
// Se algum erro ocorrer, dispara a exceção
throw new ApplicationException("Erro ao descriptografar", ex);
}
}
}

 


Tentei manter o código o mais comentado possível.

 

Para ver o código em funcionamento, crie um console application e utilize o código abaixo


class Program
{
static void Main(string[] args)
{
String valor = "Novo valor";
String valorCriptografado = Criptografia.Encrypt(valor);
String valorDescriptografado = Criptografia.Decrypt(valorCriptografado);

Console.WriteLine(valor); //Novo valor
Console.WriteLine(valorCriptografado); //jM3IT3OZEy+1ha5XNL3Wfg==
Console.WriteLine(valorDescriptografado); //Novo valor
Console.ReadLine();
}
}

 

Lembre-se que Criptografia se refere principalmente a processos bidirecionais, ou seja, que permite a descriptografia do valor criptografado. Para nos referir a processos uniderecionais utilizamos a palavra Hash. 

 

Como exemplo de Hash, os mais conhecidos são o MD5 e o SHA1, mas isso fica para um próximo post.

 

Dois links para mais informações sobre o tema:

http://pt.wikipedia.org/wiki/AES

 

Aprofunde seus conhecimentos sobre este tema na comunidade C#

Exibições: 16482

Comentar

Você precisa ser um membro de DevBrasil para adicionar comentários!

Entrar em DevBrasil

Comentário de Alessandro Cagliostro Gonçalves em 5 setembro 2019 às 21:19

Gostaria de deixar um link do meu repositório, nele tem código-fonte C# e programa compilado para referência/uso, seguindo as melhores práticas/padrões de criptografia e segurança -> https://github.com/alecgn/crypthash-net

Comentário de Adriano em 20 junho 2019 às 19:48

Estou com esse mesmo problema. Não sei o que fazer. Alguém poderia me ajudar?

Comprimento inválido dos dados a serem descriptografados.

Comentário de Luiz Cherpers em 28 julho 2015 às 8:09

Olá,
Como gerar faço para gerar uma senha de 16 caracteres apenas?
No banco tenho campo sn com varchar 20.
Att
Luiz

Comentário de Juliano Marcon em 25 janeiro 2012 às 19:53

A exception :

  • Comprimento inválido dos dados a serem criptografados 

ou

  • Lenght of the data to decrypt is invalid

Acontece quando a chave de criptografia não tem um comprimento compatível com a propriedade KeySize do objeto encriptador.

Desculpe pela demora Heitor.

Comentário de Heitor Oliveira Gonçalves em 29 dezembro 2011 às 9:37

Muito bom  o post ,me tira uma duvida esta dando este erro o que pode ser

Comprimento inválido dos dados a serem descriptografados.

Comentário de Ruy Armando em 22 novembro 2011 às 16:47

Muito bom o Post ... Antes de participar tive que ficar procurando referencias até desenvolver.

Comentário de Henrich Natanael de Moraes em 4 maio 2011 às 8:56
Muito bom o Post! :D Parabéns!
Comentário de Marcela Mariotti Peres em 2 fevereiro 2011 às 12:15
Muito útil o post, Juliano.

© 2019   Criado por Ramon Durães.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço