MENU
  1. ホーム
  2. SQL
  3. Come utilizzare le funzioni hash in SQL per crittografare e trasformare i dati

Come utilizzare le funzioni hash in SQL per crittografare e trasformare i dati

SQL

In questo articolo spiegheremo come utilizzare le funzioni hash in SQL per crittografare e trasformare i dati, migliorando la sicurezza. Le funzioni hash sono funzioni unidirezionali che rendono difficile recuperare i dati originali, risultando adatte alla protezione di password e informazioni sensibili. Cominceremo con le nozioni di base delle funzioni hash e passeremo ad esempi pratici di implementazione in SQL, mostrando un approccio concreto alla protezione dei dati.

Indice

Cosa sono le funzioni hash

Le funzioni hash sono funzioni che trasformano i dati di input in stringhe di lunghezza fissa. Questa trasformazione è unidirezionale e recuperare i dati originali dal valore hash generato è quasi impossibile. Le funzioni hash sono utilizzate per vari scopi di sicurezza, tra cui la verifica dell’integrità dei dati e la protezione delle password.

Le principali funzioni hash utilizzate in SQL

Le principali funzioni hash comunemente utilizzate in SQL includono:

MD5

Una funzione che genera un valore hash a 128 bit. Sebbene sia stata ampiamente utilizzata, sono state identificate vulnerabilità di sicurezza.

SHA-1

Una funzione che genera un valore hash a 160 bit. È più sicura di MD5, ma di recente sono state scoperte vulnerabilità, quindi non è più raccomandata.

SHA-256

Una funzione che genera un valore hash a 256 bit. È considerata più sicura rispetto a SHA-1 e attualmente è ampiamente raccomandata.

Vantaggi della crittografia dei dati tramite funzioni hash

I vantaggi di utilizzare le funzioni hash per la sicurezza dei dati includono:

Confidenzialità dei dati

Le funzioni hash trasformano irreversibilmente i dati originali, rendendo difficile comprendere il loro contenuto anche in caso di fuga di informazioni.

Integrità dei dati

Il valore hash è come un’impronta unica dei dati: se i dati vengono alterati, anche il valore hash cambia, aiutando a verificare l’integrità dei dati.

Protezione delle password

Conservare le password degli utenti come valori hash aiuta a prevenire la fuoriuscita diretta delle password nel caso di violazione del database.

Efficienza

Le funzioni hash sono rapide nei calcoli, permettendo un’elaborazione efficiente anche su grandi quantità di dati.

Esempi di utilizzo delle funzioni hash in SQL

Di seguito mostriamo come utilizzare le funzioni hash in SQL per crittografare i dati. L’esempio seguente illustra come hashare le password degli utenti utilizzando SHA-256.

Creazione della tabella utenti

Per prima cosa, creiamo una tabella degli utenti.

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

Hashing e inserimento della password

Quando si aggiunge un nuovo utente, la password viene hashata con SHA-256 prima di essere inserita.

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

Verifica della password hashata

Recuperiamo i dati degli utenti e verifichiamo la password hashata.

SELECT * FROM Users;

In questo modo, utilizzando funzioni hash in SQL, è possibile migliorare la sicurezza dei dati.

Utilizzo delle funzioni hash per la verifica dell’integrità dei dati

Le funzioni hash sono efficaci anche per verificare l’integrità dei dati. Mostriamo come calcolare e salvare il valore hash di dati originali per verificarne eventuali alterazioni successivamente.

Creazione della tabella per conservare il valore hash dei dati

Per prima cosa, creiamo una tabella per salvare i dati e i relativi valori hash.

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

Inserimento dei dati e calcolo del valore hash

Quando si aggiungono nuovi dati, si calcola e salva il valore hash dei dati originali.

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

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

Verifica dell’integrità dei dati

Per verificare che i dati non siano stati alterati, si ricalcola il valore hash dei dati e lo si confronta con il valore hash memorizzato.

DECLARE @dataToCheck NVARCHAR(MAX) = 'dati importanti';
DECLARE @originalHash NVARCHAR(64);

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

IF @originalHash = CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', @dataToCheck), 2)
    PRINT 'I dati non sono stati alterati.';
ELSE
    PRINT 'I dati sono stati alterati.';

In questo modo, è possibile verificare facilmente l’integrità dei dati e rilevare eventuali alterazioni.

Uso combinato di funzioni hash e salt

Combinando l’uso delle funzioni hash con il salt, si può rafforzare ulteriormente la sicurezza. Il salt è un valore casuale aggiunto ai dati prima dell’hashing, che permette di generare hash diversi anche per dati identici, rendendo più difficile per gli aggressori indovinare i dati originali.

Vantaggi del salt

I vantaggi di utilizzare il salt includono:

  • Generazione di hash diversi per la stessa password
  • Prevenzione degli attacchi tramite tabelle arcobaleno (rainbow table)
  • Protezione degli altri dati in caso di fuga parziale delle informazioni

Procedura di generazione del salt e hash

Vediamo come generare il salt e utilizzarlo per hashare le password.

Generazione del salt

Il salt viene generato in modo casuale e salvato insieme ai dati.

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

-- Hash del salt combinato con la password
SET @hashedPassword = CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', @salt + @password), 2);

-- Salvataggio del salt e della password hashata
INSERT INTO Users (UserID, Username, PasswordHash, Salt)
VALUES (1, 'exampleUser', @hashedPassword, @salt);

Verifica della password

Quando un utente accede, si utilizza il salt memorizzato per hashare la password e confrontarla con il valore hash salvato.

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

-- Recupero del salt e dell'hash memorizzati
SELECT @storedSalt = Salt, @storedHash = PasswordHash FROM Users WHERE Username = 'exampleUser';

-- Hash della password inserita combinata con il salt
SET @inputHash = CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', @storedSalt + @inputPassword), 2);

-- Confronto dell'hash
IF @inputHash = @storedHash
    PRINT 'La password è corretta.';
ELSE
    PRINT 'La password è errata.';

In questo modo, combinando l’uso del salt con le funzioni hash, è possibile migliorare significativamente la sicurezza delle password e dei dati sensibili.

Esempio di implementazione del salt in SQL

Mostriamo un esempio pratico di implementazione del salt in SQL. Vedremo come hashare una password utilizzando il salt durante la registrazione e la verifica dell’utente.

Creazione della tabella utenti

Creiamo una tabella utenti per salvare il salt e le password hashate.

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

Hashing e inserimento della password con salt

Quando si registra un nuovo utente, la password viene hashata insieme al salt e salvata.

-- Generazione della password utente e del salt
DECLARE @password NVARCHAR(50) = 'examplePassword';
DECLARE @salt NVARCHAR(32) = CONVERT(NVARCHAR(32), NEWID());
DECLARE @hashedPassword NVARCHAR(64);

-- Hash del salt combinato con la password
SET @hashedPassword = CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', @salt + @password), 2);

-- Inserimento nella tabella utenti
INSERT INTO Users (UserID, Username, PasswordHash, Salt)
VALUES (1, 'exampleUser', @hashedPassword, @salt);

Verifica della password durante l’autenticazione

Quando l’utente accede, il salt memorizzato viene utilizzato per hashare la password inserita e confrontarla con l’hash memorizzato.

-- Password inserita dall'utente
DECLARE @inputPassword NVARCHAR(50) = 'examplePassword';
DECLARE @storedSalt NVARCHAR(32);
DECLARE @storedHash NVARCHAR(64);
DECLARE @inputHash NVARCHAR(64);

-- Recupero del salt e dell'hash memorizzati
SELECT @storedSalt = Salt, @storedHash = PasswordHash FROM Users WHERE Username = 'exampleUser';

-- Hash della password inserita combinata con il salt
SET @inputHash = CONVERT(VARCHAR(64), HASHBYTES('SHA2_256', @storedSalt + @inputPassword), 2);

-- Confronto dell'hash
IF @inputHash = @storedHash
    PRINT 'La password è corretta.';
ELSE
    PRINT 'La password è errata.';

Questa implementazione permette di eseguire l’hashing e la verifica delle password utilizzando il salt. In questo modo, si migliora la sicurezza delle password, anche in caso di violazione del database.

Conclusione

L’utilizzo delle funzioni hash in SQL consente di crittografare e trasformare i dati in modo efficace. Le funzioni hash sono essenziali per la protezione delle password e la verifica dell’integrità dei dati, e combinandole con il salt si possono ottenere misure di sicurezza ancora più potenti. Attraverso esempi di codice SQL pratici, abbiamo visto come implementare le funzioni hash e il salt per migliorare la sicurezza del database. Così facendo, si può garantire la confidenzialità e l’integrità dei dati e proteggere il sistema dagli attacchi.

SQL
Crittografia dei Dati Funzione di Hash Integrità dei Dati Protezione delle Password Sale SHA-256 sicurezza SQL
Indice