Come eseguire la crittografia e la decodifica AES con Python

Python è un linguaggio di programmazione flessibile che consente di implementare facilmente algoritmi di crittografia avanzati come AES (Advanced Encryption Standard). In questo articolo, spiegherò in dettaglio le basi della crittografia AES e fornirò esempi pratici di codice. Se desideri rafforzare la sicurezza dei tuoi dati e proteggere informazioni sensibili, questo articolo ti guiderà passo dopo passo. Alla fine, acquisirai le competenze per costruire un sistema pratico di crittografia e decodifica.

Indice

Concetti di base della crittografia AES

AES (Advanced Encryption Standard) è un algoritmo di crittografia a blocchi stabilito dal National Institute of Standards and Technology (NIST) degli Stati Uniti, che offre elevata sicurezza ed efficienza. I dati vengono suddivisi in blocchi di dimensione fissa (di solito 128 bit) e criptati. AES è un algoritmo a chiave simmetrica, il che significa che la stessa chiave viene utilizzata per la crittografia e la decodifica.

Modalità di funzionamento di AES

AES supporta diverse modalità di funzionamento, ognuna adatta a casi d’uso specifici. Le modalità principali sono le seguenti:

ECB (Electronic Codebook): modalità di crittografia semplice, ma meno sicura poiché i pattern possono essere esposti.
CBC (Cipher Block Chaining): migliora la sicurezza aggiungendo il risultato della crittografia del blocco precedente a ciascun blocco successivo.
CFB (Cipher Feedback): utilizza continuamente i risultati della crittografia e può essere utilizzato come cifrario a flusso.
GCM (Galois/Counter Mode): modalità che offre, oltre alla crittografia, la verifica dell’integrità dei dati.

Dimensioni delle chiavi di AES

AES supporta tre dimensioni di chiave:

128 bit (16 byte): la dimensione più comune, offre una sicurezza standard.
192 bit (24 byte): utilizzata quando è necessaria una sicurezza più elevata.
256 bit (32 byte): adatta quando è richiesta una sicurezza molto elevata.

La dimensione della chiave viene scelta in base ai requisiti di sicurezza. Una chiave da 128 bit è generalmente sufficiente per usi comuni, mentre per una sicurezza maggiore si consiglia una chiave da 256 bit.

Caratteristiche di AES

AES è uno degli algoritmi di crittografia più utilizzati per i seguenti motivi:

Efficienza: funziona rapidamente su hardware e software.
Affidabilità: la sua sicurezza è stata provata nel tempo grazie a un uso prolungato.
Flessibilità: offre diverse modalità di funzionamento, adatte a vari usi.

Utilizzare AES rende facile implementare una protezione avanzata dei dati, motivo per cui viene utilizzato in numerosi casi pratici, anche con Python.

Installazione delle librerie Python necessarie

Per implementare la crittografia e la decodifica AES in Python, è necessario utilizzare una libreria specializzata nella crittografia. Una delle librerie più raccomandate è PyCryptodome, una libreria potente e facile da usare che estende il modulo “Crypto” della libreria standard di Python.

Installazione di PyCryptodome

Per installare PyCryptodome, usa il seguente comando:

pip install pycryptodome

Verifica dell’installazione

Per verificare che l’installazione sia andata a buon fine, avvia l’interprete Python e inserisci il seguente comando:

from Crypto.Cipher import AES
print("PyCryptodome è stato installato correttamente!")

Se non vengono mostrati errori, l’installazione è stata completata con successo.

Principali funzionalità di PyCryptodome

PyCryptodome offre le seguenti funzionalità di crittografia:

Crittografia a chiave simmetrica (AES, DES, ecc.)
Crittografia a chiave asimmetrica (RSA, ECC, ecc.)
Codici di autenticazione del messaggio (HMAC, ecc.)
Funzioni di hash (SHA256, SHA3, ecc.)

Per la crittografia e la decodifica AES, useremo il modulo Crypto.Cipher.AES di questa libreria.

Altre opzioni

Oltre a PyCryptodome, ci sono altre librerie che possono essere utilizzate per la crittografia AES:

cryptography: fornisce operazioni di crittografia ad alto livello. Il comando di installazione è pip install cryptography.
m2crypto: libreria Python che avvolge la libreria C OpenSSL.

Tuttavia, PyCryptodome è la scelta migliore per i principianti e per chi vuole imparare e implementare la crittografia AES. In questo articolo, spiegherò come utilizzare PyCryptodome.

Preparativi per la crittografia

Per eseguire la crittografia AES, è necessario preparare alcuni elementi in anticipo. In particolare, è fondamentale la chiave di crittografia (key) e il vettore di inizializzazione (IV: Initialization Vector). Senza una corretta configurazione di questi, la crittografia e la decodifica non funzioneranno correttamente.

Generazione della chiave di crittografia

La chiave di crittografia è molto importante in AES. La lunghezza della chiave deve essere una delle seguenti: 128 bit (16 byte), 192 bit (24 byte) o 256 bit (32 byte). Ecco un esempio di come generare una chiave in Python:

from Crypto.Random import get_random_bytes

# Genera una chiave da 256 bit (32 byte)
key = get_random_bytes(32)  
print("Chiave generata:", key)

Questo codice genera una chiave sicura e casuale da utilizzare nella crittografia.

Generazione del vettore di inizializzazione (IV)

Il vettore di inizializzazione (IV) è un dato casuale utilizzato per rendere uniche le sessioni di crittografia. In modalità come CBC di AES, è particolarmente necessario. La lunghezza dell’IV deve essere uguale alla dimensione del blocco di AES (di solito 16 byte). Ecco un esempio di come generare un IV usando PyCryptodome:

# Genera un IV da 16 byte
iv = get_random_bytes(16)  
print("IV generato:", iv)

Come salvare la chiave e l’IV

La chiave e l’IV generati devono essere conservati in modo sicuro, poiché sono necessari per la crittografia e la decodifica. Ecco alcune linee guida:

Luogo sicuro di archiviazione: la chiave deve essere salvata in un luogo sicuro, come un modulo di sicurezza hardware (HSM), o in forma cifrata nel filesystem o in un database.
Non condividerla: non condividere la chiave con terzi, altrimenti i dati criptati potrebbero essere facilmente decifrati.
Evitare la rigenerazione: per crittografare e decodificare gli stessi dati, è necessario utilizzare la stessa chiave e IV.

Preparativi conclusi

Ora che la chiave e l’IV sono pronti, possiamo procedere con l’implementazione della crittografia AES.

Implementazione della crittografia AES con Python

Per implementare la crittografia AES in Python, utilizziamo il modulo Crypto.Cipher.AES. In questa sezione, vedremo come cifrare i dati utilizzando la chiave e l’IV preparati.

Processo di crittografia

Ecco un esempio pratico di codice per cifrare i dati con PyCryptodome:

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from Crypto.Random import get_random_bytes

# Genera la chiave e l'IV per la crittografia
key = get_random_bytes(32)  # Chiave a 256 bit
iv = get_random_bytes(16)   # IV di dimensione del blocco AES

# Dati da crittografare
data = "Questo è un messaggio da criptare"
# Converti i dati in formato byte
data_bytes = data.encode('utf-8')

# Prepara la crittografia
cipher = AES.new(key, AES.MODE_CBC, iv)  # Utilizza AES in modalità CBC
# Aggiungi padding per adattare i dati alla dimensione del blocco
encrypted_data = cipher.encrypt(pad(data_bytes, AES.block_size))

# Stampa i risultati
print("Dati criptati:", encrypted_data)
print("Chiave:", key)
print("IV:", iv)

Spiegazione del codice

Generazione di chiave e IV

Usiamo get_random_bytes per generare chiavi e IV casuali.
La chiave è di 256 bit (32 byte), ma può essere cambiata in base alle esigenze.

Preparazione dei dati

I dati da cifrare sono in formato stringa e vengono convertiti in byte usando encode('utf-8').

Configurazione di AES

Impostiamo la crittografia AES con AES.new e specifichiamo la modalità CBC con AES.MODE_CBC.

Aggiunta di padding

AES lavora con blocchi di dimensione fissa (16 byte), quindi i dati devono essere aggiustati con la funzione pad.

Esito della crittografia

Usiamo cipher.encrypt per crittografare i dati.

Gestione dei dati criptati

I dati criptati vengono restituiti come una sequenza di byte. Quando li trasmetti o salvi, è utile utilizzare una codifica Base64:

import base64

# Codifica i dati criptati in Base64
encoded_data = base64.b64encode(encrypted_data).decode('utf-8')
print("Dati criptati codificati in Base64:", encoded_data)

Questo ti permetterà di gestire in modo sicuro i dati criptati, specialmente se devi trasmetterli o salvarli. Nella prossima sezione, vedremo come decifrare questi dati.

Implementazione della decodifica AES con Python

Per decifrare i dati, è necessario utilizzare la stessa chiave e IV impiegati nella crittografia. In questa sezione, vedremo come implementare la decodifica AES con PyCryptodome.

Processo di decodifica

Ecco un esempio di codice per decifrare i dati criptati con AES:

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad
import base64

# Dati criptati (in formato Base64)
encrypted_data_base64 = "Inserisci qui i dati criptati in Base64"
encrypted_data = base64.b64decode(encrypted_data_base64)  # Decodifica in Base64

# Chiave e IV necessari per la decodifica (gli stessi usati durante la crittografia)
key = b"Inserisci qui la chiave di crittografia"  # Chiave a 32 byte (esempio: b'key12345678901234567890123456789')
iv = b"Inserisci qui l'IV di crittografia"   # IV a 16 byte

# Esegui la decodifica
cipher = AES.new(key, AES.MODE_CBC, iv)
decrypted_data = unpad(cipher.decrypt(encrypted_data), AES.block_size)

# Stampa i dati decodificati come stringa
print("Dati decodificati:", decrypted_data.decode('utf-8'))

Spiegazione del codice

Gestione dei dati criptati

Se i dati criptati sono in formato Base64, decodificali prima con base64.b64decode.
Se i dati sono già in formato byte, questa operazione non è necessaria.

Impostazione della chiave e dell’IV

Per decodificare correttamente, la chiave e l’IV devono essere gli stessi utilizzati durante la crittografia.

Configurazione della decodifica

Impostiamo la decodifica con AES.new e specifichiamo la modalità CBC.

Esito della decodifica

Usiamo cipher.decrypt per decodificare i dati, quindi applichiamo unpad per rimuovere il padding.

Stampa dei dati decodificati

Con decode('utf-8') possiamo stampare i dati decodificati come stringa.

Esempio di decodifica con dati di esempio

Ecco un esempio di decodifica utilizzando i dati criptati direttamente nel codice:

# Dati criptati di esempio
encrypted_data = b"\x93\x4e\x8b\x12\xab..."  # Sequenza di byte criptati (esempio)
key = b"key12345678901234567890123456789"  # Chiave a 32 byte
iv = b"iv12345678901234"  # IV a 16 byte

# Decodifica
cipher = AES.new(key, AES.MODE_CBC, iv)
decrypted_data = unpad(cipher.decrypt(encrypted_data), AES.block_size)
print("Dati decodificati:", decrypted_data.decode('utf-8'))

Gestione degli errori

Durante la decodifica potrebbero verificarsi alcuni errori. Ecco i principali:

ValueError: Padding is incorrect.
Questo errore si verifica se la chiave o l’IV non corrispondono a quelli utilizzati per la crittografia.
Potrebbe anche indicare che i dati sono stati manomessi.
TypeError: Object type cannot be passed to the function.
Questo errore si verifica se i dati non sono nel formato corretto (byte invece di stringa o viceversa).

Con questi suggerimenti, sarai in grado di risolvere i problemi comuni durante la decodifica AES e garantire una gestione sicura dei dati criptati.

Gestione sicura dei file con AES

La crittografia AES può essere utilizzata non solo per proteggere i dati di testo, ma anche interi file. In questa sezione, vedremo come cifrare e decifrare i file con Python.

Processo di crittografia dei file

Ecco un esempio di codice Python per cifrare un file:

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
from Crypto.Random import get_random_bytes

# Percorsi dei file
input_file_path = 'input.txt'  # File da cifrare
encrypted_file_path = 'encrypted.bin'  # File cifrato

# Genera la chiave e l'IV
key = get_random_bytes(32)  # Chiave a 256 bit
iv = get_random_bytes(16)   # IV

# Leggi i dati dal file e cifrali
with open(input_file_path, 'rb') as input_file:
    file_data = input_file.read()
    cipher = AES.new(key, AES.MODE_CBC, iv)
    encrypted_data = cipher.encrypt(pad(file_data, AES.block_size))

# Salva i dati cifrati
with open(encrypted_file_path, 'wb') as encrypted_file:
    encrypted_file.write(iv + encrypted_data)

print(f"Il file '{input_file_path}' è stato cifrato e salvato come '{encrypted_file_path}'.")

Processo di decodifica dei file

Successivamente, vediamo come decifrare il file criptato:

from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

# Percorsi dei file
encrypted_file_path = 'encrypted.bin'  # File cifrato
decrypted_file_path = 'decrypted.txt'  # File decifrato

# Chiave (la stessa usata per la crittografia)
key = b"qui inserisci la chiave di crittografia"  # Chiave a 32 byte

# Decifra il file
with open(encrypted_file_path, 'rb') as encrypted_file:
    file_data = encrypted_file.read()
    iv = file_data[:16]  # Estrai l'IV
    encrypted_data = file_data[16:]  # Estrai i dati cifrati
    cipher = AES.new(key, AES.MODE_CBC, iv)
    decrypted_data = unpad(cipher.decrypt(encrypted_data), AES.block_size)

# Salva i dati decifrati
with open(decrypted_file_path, 'wb') as decrypted_file:
    decrypted_file.write(decrypted_data)

print(f"Il file '{encrypted_file_path}' è stato decifrato e salvato come '{decrypted_file_path}'.")

Punti chiave del codice

Salvataggio della chiave e IV

Il codice di esempio non include la gestione sicura di chiave e IV. Quando li salvi nel file cifrato, fai attenzione a non condividerli con terzi.

Gestione delle dimensioni del blocco

I file di solito non sono multipli della dimensione del blocco, quindi usiamo la funzione pad per adattare i dati.

Salvataggio separato di chiave e IV

Per motivi di sicurezza, è consigliato gestire chiave e IV separatamente dal file cifrato.

Gestione sicura dei file criptati

La crittografia dei file è essenziale per proteggere informazioni sensibili. Tuttavia, la gestione sicura delle chiavi e l’integrazione di meccanismi di rilevamento delle manomissioni (come HMAC) sono fondamentali per garantire la sicurezza.

Con questo, hai appreso come cifrare e decifrare file in modo sicuro utilizzando AES in Python. La prossima sezione affronterà considerazioni di sicurezza per una gestione ottimale dei dati criptati.

Considerazioni di sicurezza

Per implementare correttamente AES in modo sicuro, ci sono alcune precauzioni importanti da prendere. Senza una corretta implementazione, i dati criptati potrebbero essere vulnerabili a attacchi. In questa sezione discuteremo le principali precauzioni da prendere in considerazione.

1. Gestione delle chiavi

La gestione sicura delle chiavi è fondamentale per la sicurezza di un sistema di crittografia. La perdita della chiave o una gestione inadeguata potrebbe compromettere la sicurezza dei dati.

Scegliere un luogo sicuro per l’archiviazione
Non salvare la chiave in chiaro nel filesystem, ma crittografarla e gestirla in modo sicuro.
Si consiglia di utilizzare moduli di sicurezza hardware (HSM) o servizi di gestione delle chiavi cloud come AWS KMS o Azure Key Vault.
Rotazione periodica delle chiavi
Modificare regolarmente la chiave per ridurre i rischi di sicurezza a lungo termine.

2. Gestione del vettore di inizializzazione (IV)

La gestione dell’IV è altrettanto importante per la sicurezza di AES. Un IV gestito male potrebbe compromettere la sicurezza del sistema.

Assicurarsi che l’IV sia unico
Non utilizzare lo stesso IV per più operazioni di crittografia.
Si consiglia di generare casualmente un IV per ogni operazione di crittografia e di salvarlo insieme ai dati cifrati.
Gestire IV separatamente dalla chiave
Non conservare IV e chiave nello stesso luogo, in quanto un attaccante potrebbe facilmente ottenere entrambi.

3. Scelta della modalità di funzionamento

AES supporta diverse modalità di funzionamento. È importante scegliere quella che offre la maggiore sicurezza.

Modalità consigliata: GCM
GCM (Galois/Counter Mode) offre non solo la crittografia, ma anche la verifica dell’integrità dei dati.
Se si utilizza la modalità CBC, si consiglia di aggiungere un meccanismo di rilevamento delle manomissioni come HMAC.

4. Resistenza agli attacchi

Per ridurre il rischio che i dati crittografati vengano violati, prendi in considerazione le seguenti precauzioni:

Protezione contro gli attacchi temporali
Progetta l’implementazione in modo che tutte le operazioni abbiano una durata di esecuzione costante.
Uniformità della lunghezza dei dati criptati
Per impedire che un attaccante possa dedurre informazioni sulla lunghezza dei dati, assicurati che i dati cifrati abbiano una lunghezza costante.

5. Verifica dell’integrità dei dati

La crittografia nasconde i dati, ma non fornisce meccanismi di verifica dell’integrità. È importante aggiungere una protezione contro le manomissioni.

Aggiungi HMAC
Utilizza HMAC (Hash-based Message Authentication Code) per verificare che i dati non siano stati manomessi.
Esempio di HMAC con PyCryptodome:
python from Crypto.Hash import HMAC, SHA256 h = HMAC.new(key, digestmod=SHA256) h.update(encrypted_data) mac = h.hexdigest()

6. Generazione delle chiavi basata su password

Quando la chiave di crittografia è basata su una password fornita dall’utente, è fondamentale utilizzare un algoritmo sicuro per generare la chiave.

Algoritmo consigliato: PBKDF2
PBKDF2 combina il sale e il numero di iterazioni per rendere la generazione delle chiavi sicura.
Esempio con PyCryptodome:
python from Crypto.Protocol.KDF import PBKDF2 salt = get_random_bytes(16) key = PBKDF2("password", salt, dkLen=32, count=100000)

7. Aggiornamento delle librerie

Le vulnerabilità delle librerie di crittografia possono compromettere la sicurezza. Assicurati di utilizzare sempre l’ultima versione della libreria:

pip install --upgrade pycryptodome

8. Eliminazione sicura dei dati criptati

I dati criptati non più necessari e i file contenenti chiavi devono essere eliminati in modo sicuro. Utilizza un metodo di eliminazione che impedisca il recupero dei dati.

Sommario

La sicurezza di un sistema AES dipende dalla corretta implementazione. In particolare, la gestione sicura delle chiavi e degli IV, la prevenzione degli accessi non autorizzati e la verifica dell’integrità dei dati sono aspetti cruciali. Con queste precauzioni, puoi costruire un sistema di crittografia pratico e sicuro.

Sommario finale

In questo articolo, abbiamo spiegato come implementare AES per la crittografia e la decodifica utilizzando Python. Abbiamo coperto i concetti di base, le librerie necessarie, i passi per cifrare e decifrare dati e file, e le precauzioni di sicurezza fondamentali.

Con una gestione sicura delle chiavi e degli IV, l’integrazione di meccanismi di protezione dell’integrità dei dati e pratiche di gestione sicura, puoi sfruttare appieno le potenti funzionalità di AES per proteggere i dati sensibili.