Gravando informações criptografadas

6 minuto(s) de leitura

01

Fala pessoal, tudo bem?! 🔑

Proteção de dados

Esses dias estava lendo algo sobre uma lei de proteção de dados que foi estabelecida pelo parlamento Europeu, O link sobre a lei está AQUI.

Foi aberto uma Issue sobre isso no projeto do EF Core, para que forneça suporte ao SQL sempre criptografado, se você tiver interesse em acompanhar o progresso, acesse a URL abaixo, onde está sendo rastreado. https://github.com/aspnet/EntityFrameworkCore/issues/9193


Criptografia usando EF Core

Até que isso seja resolvido da forma mais adequada, estarei mostrando como armazenar e ler seus dados criptografados usando EF Core.

Irei usar uma criptografia básica como exemplo.

Usaremos o TripleDESCryptoServiceProvider para criptografar e descriptografar nossas informações, para mais informações sobre TripleDESCryptoServiceProvider, acesse essa URL.


Classe criptografia

public class Criptografia
{
    // Nossa frase secreta
    private static byte[] _chave = Encoding.UTF8.GetBytes("#ef");

    public static string Encrypt(string texto)
    {
        using (var hashProvider = new MD5CryptoServiceProvider())
        {
            var encriptar = new TripleDESCryptoServiceProvider
            {
                Mode = CipherMode.ECB,
                Key = hashProvider.ComputeHash(_chave),
                Padding = PaddingMode.PKCS7
            };

            using (var transforme = encriptar.CreateEncryptor())
            {
                var dados = Encoding.UTF8.GetBytes(texto);
                return Convert.ToBase64String(transforme.TransformFinalBlock(dados, 0, dados.Length));
            }
        }
    }

    public static string Decrypt(string texto)
    {
        using (var hashProvider = new MD5CryptoServiceProvider())
        {
            var descriptografar = new TripleDESCryptoServiceProvider
            {
                Mode = CipherMode.ECB,
                Key = hashProvider.ComputeHash(_chave),
                Padding = PaddingMode.PKCS7
            };

            using (var transforme = descriptografar.CreateDecryptor())
            {
                var dados = Convert.FromBase64String(texto.Replace(" ", "+"));
                return Encoding.UTF8.GetString(transforme.TransformFinalBlock(dados, 0, dados.Length));
            }
        }
    }
}

Nosso DBContext

public class ExemploContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer(@"Data Source=.\Sistemas;Initial Catalog=TesteCriptografia;Integrated Security=True");
        optionsBuilder.UseLoggerFactory(new LoggerFactory().AddConsole());
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Teste>(p=>
        {
            p.Property(x => x.Informacoes)
                .HasConversion(v => Criptografia.Encrypt(v), v => Criptografia.Decrypt(v));
        });
    }
}
Observação:
A partir da versão 2.1* teremos o método HasConversion que podemos utilizar pra escrever conversões personalizadas, ou seja, podemos dizer como o EF irá gravar as informações no banco de dados e como ele irá ler as informações também.

Nosso Programs.cs

class Program
{
    static void Main(string[] args)
    {
        using (var db = new ExemploContext())
        {
            db.Database.EnsureDeleted();
            db.Database.EnsureCreated();

            var dados = new[]
            {
                new Teste
                {
                    Informacoes = "Informação 01"
                },
                new Teste
                {
                    Informacoes = "Informação 02"
                },
                new Teste
                {
                    Informacoes = "Informação 03"
                }
            };

            db.Set<Teste>().AddRange(dados);
            db.SaveChanges();

            var registros = db
                .Set<Teste>()
                .AsNoTracking()
                .ToList();

            // Leitura feita pelo EF Core
            Console.WriteLine("Leitura EF Core:");

            foreach (var reg in registros)
            {
                Console.WriteLine($"{reg.Id}-{reg.Informacoes}");
            }

            // Leitura feita via ADO.NET
            Console.WriteLine("\nLeitura ADO.NET:");
            using (var cmd = db.Database.GetDbConnection().CreateCommand())
            {
                db.Database.OpenConnection();
                cmd.CommandText = "SELECT [Id],[Informacoes] FROM [Teste]";
                using (var ler = cmd.ExecuteReader())
                {
                    while (ler.Read())
                    {
                        Console.WriteLine($"{ler.GetInt32(0)}-{ler.GetString(1)}");
                    }
                }
            }
        }

        Console.ReadKey();
    }
}


Veja como foi gravado no banco

Após persistir as informações observe que os valores da coluna Informacoes foram criptografadas automaticamente.

01

Leitura dos dados

Veja que as informações carregadas pelo EF Core, automaticamente são descriptografadas, pelo motivo de termos mapeado nossa propriedade usando o HasConversion, já quando fazemos a leitura usando o ADO ele simplesmente nos devolve as informações criptografadas de forma fiel ao banco.


01

Próximo artigo:
Estarei criando um exemplo e mostrando como utilizar com propriedades customizadas por atributos.


Url projeto: https://github.com/ralmsdeveloper/ExemplosArtigos

Pessoal, fico por aqui #+1dica!

Categorias:

Atualizado em:

Deixe um comentário