MENU
  1. Início
  2. SQL
  3. Como usar funções de hash no SQL para criptografar e transformar dados

Como usar funções de hash no SQL para criptografar e transformar dados

SQL

Explicaremos como usar funções de hash no SQL para criptografar e transformar dados a fim de melhorar a segurança. As funções de hash são unidirecionais, tornando difícil restaurar os dados originais, o que as torna adequadas para proteger senhas e informações confidenciais. Este artigo começa com os conceitos básicos das funções de hash e apresenta uma abordagem prática para proteção de dados com exemplos de implementação em SQL.

Índice

O que é uma função de hash?

Uma função de hash é uma função que converte dados de entrada em uma string de comprimento fixo. Essa conversão é unidirecional, o que torna praticamente impossível restaurar os dados originais a partir do valor hash gerado. Funções de hash são usadas para várias finalidades de segurança, como verificar a integridade dos dados e proteger senhas.

Principais funções de hash usadas no SQL

As funções de hash comumente usadas no SQL incluem as seguintes:

MD5

É uma função que gera um valor hash de 128 bits e tem sido amplamente utilizada há anos, mas vulnerabilidades de segurança foram apontadas.

SHA-1

Gera um valor hash de 160 bits e é mais forte que o MD5, mas vulnerabilidades recentes foram descobertas, e seu uso não é mais recomendado.

SHA-256

Gera um valor hash de 256 bits e oferece maior segurança que o SHA-1, sendo amplamente recomendado atualmente.

Vantagens da criptografia de dados usando funções de hash

As vantagens de segurança ao usar funções de hash incluem:

Confidencialidade dos dados

Como as funções de hash transformam irreversivelmente os dados, mesmo que os dados vazem, seu conteúdo será difícil de interpretar.

Integridade dos dados

O valor hash funciona como uma impressão digital única dos dados, mudando se os dados forem adulterados, o que ajuda a verificar a integridade.

Proteção de senhas

Ao armazenar senhas de usuários em formato de hash, você pode evitar que as senhas sejam diretamente expostas caso o banco de dados seja comprometido.

Eficiência

As funções de hash são rápidas e eficientes, permitindo o processamento ágil de grandes volumes de dados.

Exemplos de uso de funções de hash no SQL

Aqui, apresentamos como usar funções de hash no SQL para proteger dados, usando o SHA-256 para hashear senhas de usuários.

Criação de tabela de usuários

Primeiro, crie uma tabela de usuários.

CREATE TABLE Users (
    UserID INT PRIMARY KEY,
    Username VARCHAR(50) NOT NULL,
    PasswordHash VARCHAR(64) NOT NULL
);

Hash e inserção de senha

Ao adicionar um novo usuário, a senha é hasheada usando SHA-256 antes de ser inserida.

INSERT INTO Users (UserID, Username, PasswordHash)
VALUES (1, 'exampleUser', CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', 'examplePassword'), 2));

Verificação da senha hasheada

Recupere os dados do usuário para verificar a senha hasheada.

SELECT * FROM Users;

Assim, o uso de funções de hash no SQL permite fortalecer a segurança dos dados.

Uso de funções de hash para verificação de integridade de dados

As funções de hash também são eficazes para verificar a integridade dos dados. Ao calcular e armazenar o valor hash dos dados originais, você pode compará-lo posteriormente para confirmar se os dados não foram alterados.

Criação de tabela para armazenar valores de hash de dados

Primeiro, crie uma tabela para armazenar os dados e seus valores hash.

CREATE TABLE DataIntegrity (
    DataID INT PRIMARY KEY,
    OriginalData NVARCHAR(MAX),
    DataHash NVARCHAR(64)
);

Inserção de dados e cálculo de hash

Ao inserir novos dados, o valor hash é calculado e armazenado.

DECLARE @data NVARCHAR(MAX) = 'dados importantes';
DECLARE @hash NVARCHAR(64) = CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', @data), 2);

INSERT INTO DataIntegrity (DataID, OriginalData, DataHash)
VALUES (1, @data, @hash);

Verificação de integridade dos dados

Para verificar se os dados foram alterados, recalculamos o valor hash dos dados e o comparamos com o valor armazenado.

DECLARE @dataToCheck NVARCHAR(MAX) = 'dados importantes';
DECLARE @originalHash NVARCHAR(64);

SELECT @originalHash = DataHash FROM DataIntegrity WHERE DataID = 1;

IF @originalHash = CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', @dataToCheck), 2)
    PRINT 'Os dados não foram alterados.';
ELSE
    PRINT 'Os dados foram adulterados.';

Esse método permite verificar facilmente a integridade dos dados e detectar adulterações.

Uso de funções de hash com sal

Usar funções de hash com sal (salt) pode aumentar ainda mais a segurança. Salt é um valor aleatório adicionado aos dados originais antes da aplicação da função de hash, gerando valores de hash diferentes mesmo para dados idênticos, tornando difícil para os invasores reverterem os valores de hash para os dados originais.

Vantagens do uso de salt

Usar salt tem as seguintes vantagens:

  • Gera valores de hash diferentes para senhas idênticas
  • Previne ataques de rainbow table
  • Protege outros dados mesmo que parte do banco de dados seja comprometida

Procedimento de geração de salt e hash

Mostramos como gerar um salt e usá-lo para hashear uma senha.

Geração de salt

O salt é gerado aleatoriamente e armazenado junto com os dados.

DECLARE @salt NVARCHAR(32) = CONVERT(NVARCHAR(32), NEWID());
DECLARE @password NVARCHAR(50) = 'examplePassword';
DECLARE @hashedPassword NVARCHAR(64);

-- Combine o salt com a senha e aplique a função hash
SET @hashedPassword = CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', @salt + @password), 2);

-- Armazene o salt e a senha hasheada
INSERT INTO Users (UserID, Username, PasswordHash, Salt)
VALUES (1, 'exampleUser', @hashedPassword, @salt);

Verificação de senha

Quando o usuário fizer login, o salt armazenado será usado para hashear a senha e compará-la com o valor de hash armazenado.

DECLARE @inputPassword NVARCHAR(50) = 'examplePassword';
DECLARE @storedSalt NVARCHAR(32);
DECLARE @storedHash NVARCHAR(64);
DECLARE @inputHash NVARCHAR(64);

-- Recupera o salt e o valor de hash armazenado
SELECT @storedSalt = Salt, @storedHash = PasswordHash FROM Users WHERE Username = 'exampleUser';

-- Hashea a senha inserida com o salt
SET @inputHash = CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', @storedSalt + @inputPassword), 2);

-- Comparação dos valores de hash
IF @inputHash = @storedHash
    PRINT 'A senha está correta.';
ELSE
    PRINT 'A senha está incorreta.';

O uso combinado de sal e funções de hash aumenta significativamente a segurança de senhas e outros dados confidenciais.

Exemplo de implementação de salt no SQL

Aqui está um exemplo concreto de como implementar salt no SQL. Explicamos como hashear uma senha com salt ao registrar e autenticar um usuário.

Criação de tabela de usuários

Crie uma tabela de usuários para armazenar o salt e a senha hasheada.

CREATE TABLE Users (
    UserID INT PRIMARY KEY,
    Username VARCHAR(50) NOT NULL,
    PasswordHash VARCHAR(64) NOT NULL,
    Salt VARCHAR(32) NOT NULL
);

Hash e inserção de senha com salt

Ao registrar um novo usuário, a senha é hasheada com salt e armazenada.

-- Geração de senha e salt para o usuário
DECLARE @password NVARCHAR(50) = 'examplePassword';
DECLARE @salt NVARCHAR(32) = CONVERT(NVARCHAR(32), NEWID());
DECLARE @hashedPassword NVARCHAR(64);

-- Combine a senha com o salt e aplique a função hash
SET @hashedPassword = CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', @salt + @password), 2);

-- Insira na tabela de usuários
INSERT INTO Users (UserID, Username, PasswordHash, Salt)
VALUES (1, 'exampleUser', @hashedPassword, @salt);

Verificação de senha durante a autenticação

Ao fazer login, o salt armazenado é usado para hashear a senha inserida e compará-la com o valor de hash armazenado.

-- Senha inserida pelo usuário
DECLARE @inputPassword NVARCHAR(50) = 'examplePassword';
DECLARE @storedSalt NVARCHAR(32);
DECLARE @storedHash NVARCHAR(64);
DECLARE @inputHash NVARCHAR(64);

-- Recupera o salt e o valor de hash armazenado
SELECT @storedSalt = Salt, @storedHash = PasswordHash FROM Users WHERE Username = 'exampleUser';

-- Combine o salt com a senha inserida e aplique a função hash
SET @inputHash = CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', @storedSalt + @inputPassword), 2);

-- Comparação dos valores de hash
IF @inputHash = @storedHash
    PRINT 'A senha está correta.';
ELSE
    PRINT 'A senha está incorreta.';

Essa implementação permite o hash e a verificação de senhas com salt, aumentando a segurança das senhas e protegendo os usuários mesmo em caso de comprometimento do banco de dados.

Conclusão

Usar funções de hash no SQL permite criptografar e transformar dados de forma eficaz. Funções de hash são essenciais para proteger senhas e verificar a integridade dos dados, e, com o uso de salt, a segurança é ainda mais reforçada. Compreenda como implementar funções de hash e salt por meio dos exemplos de código SQL apresentados e aplique essas práticas para proteger a segurança do seu banco de dados, garantindo a confidencialidade e integridade dos dados e protegendo o sistema contra ataques.

SQL
Criptografia de Dados Função de Hash Integridade de Dados Proteção de Senhas Sal Segurança SHA-256 SQL
Índice