C# e os Delegates.

Pensei em escrever algumas informações sobre Delegates aqui, mas como a filosofia da plataforma .net é não reinventar a roda, procurei e encontrei um artigo recém escrito sobre o tema e com certeza é uma das melhores explicações que encontrei.  Parabéns ao autor por este incrivel artigo.

Criptografia Rijndael em C#

Em diversos casos é necessário um processo de segurança em nossos dados.  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 o namespace de criptografia, assim:

 

using System.Security.Cryptography;

 

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)

   /// </summary>

   private const string cryptoKey = 

     

"Q3JpcHRvZ3JhZmlhcyBjb20gUmluamRhZWwgLyBBRVM=";

   // O Valor acima representa a transformação para base64 de

   // um conjunto de 32 caracteres (8 * 32 = 256bits)

   // A chave é: "Criptografias com Rijndael / AES"

 

   /// <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[] bText , bKey;

            bKey =

Convert.FromBase64String(cryptoKey);

            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 , IV) , 

                    

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>

   /// Metodo de descriptografia

   /// </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[] bText , bKey;

            bKey = Convert.FromBase64String(cryptoKey);

            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 ,   IV) , 

                       

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);

      }

   }

}

 

Acredito que o código esteja bem documentado.

Maiores informações sobre o algoritmo veja:
http://pt.wikipedia.org/wiki/AES

E uma animação MUITO BOA sobre o processo que o algoritmo faz pode ser encontrada em: http://blog.ultrassecreto.com/?p=17

Tipos de dados em C#

            Em C#, todo tipo é derivado da classe System.Object, que constitui o núcleo do sistema de tipos de C#. Entretanto, os projetistas da linguagem, e não apenas da linguagem, mas de .NET como um todo, sabem perfeitamente das implicações de ter um sistema de tipos onde tudo é um objeto: queda de desempenho. Para resolver este problema, eles organizaram o sistema de tipos de duas formas:

 

·    Tipos Valor: variáveis deste tipo são alocadas na pilha e têm como classe base System.ValueType, que por sua vez deriva de System.Object.

 

·    Tipos Referência: variáveis deste tipo são alocadas na memória heap e têm a classe System.Object como classe base.

 

            Veja a hierarquia de tipos do C#

 

Namespaces em C#

Namespaces são a forma lógica de organizar o código-fonte em .NET. Toda a biblioteca de classes da .NET está estruturada em uma hierarquia de namespaces que tem como base o namespace System, onde se encontram as classes básicas da .NET. Fisicamente, os namespaces são armazenados em assemblies, que, por sua vez, são armazenados no sistema de arquivos como DLLs (bibliotecas de ligação dinâmica) ou como arquivos executáveis (.exe) que correspondem a aplicações propriamente ditas no ambiente .NET.

Quando uma aplicação é organizada logicamente usando namespaces, este deve possuir pelo menos uma classe que implemente o método Main( ), para aplicações console, ou WinMain( ), para aplicações Windows. Por sua vez, uma biblioteca de classes é implementada usando namespaces, mas nenhuma das suas classes membros implementa o método Main( ) ou WinMain( ), e elas são usadas para implementar código reutilizável.

Assim como as classes contêm membros, os namespaces também, os quais podem ser dos seguintes tipos:

Outro namespace: namespaces aninhados

Classes: tipo class

Estruturas: tipo struct

Enumerados: tipo enum

Interfaces: tipo interface

Delegados: tipo delegates

Para usar um namespace a partir de uma aplicação ou de uma biblioteca, usamos a cláusula using seguida do nome do namespace, conforme temos feito em todos os exemplos neste livro. A inclusão de um namespace através de using é útil para evitar ter que digitar o nome completo do namespace para referenciar qualquer um dos seus membros.

 

Exemplo:

 

using System;

static void Main(string[ ] args)

{

  Console.WriteLine( );

  // chamada equivalente: System.Console.WriteLine( )

}

 

Ainda podemos usar a cláusula using para criar um alias de um namespace quando, ao incluirmos dois namespaces diferentes, a referência a um dos membros cujo identificador existe em ambos namespaces se torna ambígua pelo fato de que os nomes são idênticos. No exemplo a seguir, vamos assumir que o namespace1 e namespace2 contêm ambos uma classe chamada clA. Vejamos o código para entendermos melhor o problema:

using namespace1;
using namespace2;
clA ClasseA1 = new A( );
clA ClasseA2 = new A( );

Mas o problema é que o compilador não sabe a partir de qual classe desejamos criar uma instância, se a pertencente ao namespace1 ou ao namespace2. Podemos resolver esse problema de duas formas, vejamos:

Solução 1:

using namespace1;
using namespace2;
namespace1.clA ClasseA1 = new A( );
namespace2.clA ClasseA2 = new A( );

Resolvemos o problema qualificando completamente o nome da classe, ao incluirmos o nome do namespace ao qual pertence. O problema desta solução é que se o nome do namespace for muito grande, por exemplo System.Collections. Specialized, e a classe clA tiver muitos membros estáticos, teremos que digitar o nome do namespace a cada vez que quisermos referenciar a classe.

Solução 2:

using NA1 = namespace1;
using NA2 = namespace2 ;
NA1.clA ClasseA1 = new A( );
NA2.clA ClasseA2 = new A( );

Na solução 2 usamos um alias para o namespace e dessa forma resolvemos a chamada ambígua da classe clA.