Impostazioni
Consegna rapida
Spedizione gratuita
Incoterms
Modalità di pagamento
Prodotto Marketplace
Nozioni di base sulla sicurezza IoT - Parte 1: Uso della crittografia
Contributo di Editori nordamericani di DigiKey
2020-06-03
Nota del redattore: questa serie in più parti funge da guida pratica per aiutare gli sviluppatori a seguire fin dall'inizio le best practice. In questa Parte 1 sono discussi gli algoritmi di crittografia alla base di progetti sicuri. La Parte 2 tratta il ruolo delle chiavi private, la gestione delle chiavi e lo storage sicuro in sistemi sicuri. La Parte 3 esamina i meccanismi incorporati nei processori sicuri per mitigare le minacce destinate a sovvertire l'esecuzione del software di sistema e applicativo sui dispositivi IoT. La Parte 4 identifica e mostra come applicare i meccanismi di sicurezza nei processori avanzati per garantire l'isolamento necessario al fine di mitigare gli attacchi all'ambiente di runtime dei dispositivi IoT. La Parte 5 descrive come la sicurezza IoT continua dai dispositivi IoT attraverso misure di sicurezza di alto livello utilizzate per connettere tali dispositivi alle risorse cloud IoT.
La rapida crescita della dipendenza dalle applicazioni IoT nei settori industriale , medicale, dei trasporti e in altre applicazioni critiche ha modificato radicalmente il panorama della sicurezza. A differenza delle precedenti applicazioni aziendali con risorse prontamente disponibili per l'elaborazione di algoritmi di sicurezza, le applicazioni IoT di livello enterprise sono vulnerabili a una serie crescente di minacce dirette a reti in espansione di dispositivi IoT con risorse limitate. Nella fretta di rispondere alle opportunità IoT che si stanno rapidamente delineando, spesso le aziende implementano dispositivi IoT funzionalmente incapaci di supportare misure di sicurezza di base per la protezione dei dati memorizzati e dello scambio di dati e comandi attraverso reti vulnerabili.
Fino a che punto devono spingersi gli sviluppatori per garantire la sicurezza di un progetto dipende naturalmente da molteplici fattori. Ogni applicazione deve far fronte a una propria serie di minacce e richiede una valutazione appropriata dei rischi che ne derivano. Poiché i dispositivi connessi devono far fronte un numero inusuale di minacce, qualsiasi dispositivo IoT richiede almeno alcune misure di sicurezza minime.
Per alcuni, l'implementazione di robuste misure di sicurezza per un semplice dispositivo IoT potrebbe sembrare esagerato, ma anche semplici dispositivi con sensori di temperatura che mancano di protezione sufficiente possono fornire agli hacker un punto di ingresso nelle reti aziendali[1]. Infatti, la sicurezza IoT deve affrontare sfide costanti a causa della combinazione tra la connettività pervasiva fornita dalle applicazioni IoT e i dispositivi con risorse limitate alla base di queste applicazioni. Anche nei progetti di dispositivi IoT con risorse sufficienti per eseguire algoritmi di crittografia nel software, le applicazioni possono rimanere vulnerabili a causa di lievi errori nell'implementazione di tali algoritmi.
Questo articolo descrive le classi di base degli algoritmi di crittografia ed esplora il loro ruolo nella sicurezza. Mostra quindi come gli sviluppatori possano trarre vantaggio da processori e dispositivi specializzati - di Maxim Integrated, Microchip Technology e Texas Instruments - progettati per accelerare questi algoritmi, migliorando diversi aspetti della sicurezza e semplificandone l'implementazione.
I vari tipi di algoritmi crittografici e i loro ruoli
Gli algoritmi di crittografia rientrano in tre grandi categorie che riguardano i principi fondamentali di sicurezza: riservatezza, autenticazione (verificare l'origine del messaggio), non ripudio (dimostrare che il mittente ha creato un messaggio cifrato o firmato) e integrità.
- Algoritmi a chiave simmetrica, dove l'algoritmo o cifrario, utilizza la stessa chiave segreta per cifrare un messaggio leggibile dall'uomo (testo in chiaro) in una versione protetta (testo cifrato) e successivamente per decifrare il testo cifrato in chiaro. I cifrari a chiave simmetrica sono tipicamente utilizzati per garantire la riservatezza. Gli algoritmi di crittografia simmetrica comuni includono:
- Triple DES (standard di cifratura dati), noto anche come 3DES o ufficialmente come Triple Data Encryption Algorithm (TDEA) del National Institute of Standards and Technology (NIST) statunitense.
- Algoritmi in standard crittografia avanzata (AES) (AES)[2] come AES-256, che utilizza chiavi a 256 bit.
- Algoritmi a chiave asimmetrica, dove il cifrario utilizza un insieme di chiavi pubbliche e private accoppiate per cifrare e decifrare un messaggio, tipicamente come parte di protocolli di sicurezza più estesi per la concordanza di chiavi e le firme digitali. I cifrari asimmetrici sono tipicamente utilizzati per garantire la riservatezza, l'autenticazione o il non ripudio. Gli algoritmi di crittografia a chiave pubblica includono:
- Algoritmi che utilizzano la crittografia a campo finito (FFC), tra cui:
- Algoritmo di firma digitale (DSA) della Federal Information Processing Standard (FIPS)
- Scambio di chiavi Diffie-Hellman (DH)[3] della Internet Engineering Task Force (IETF)
- Algoritmi che utilizzano la crittografia a fattorizzazione integrale (IFC), tra cui:
- Algoritmo RSA (Rivest-Shamir-Adleman)[4]
- Algoritmi che utilizzano la crittografia a curva ellittica (ECC), tra cui:
- Scambio di chiavi a curva ellittica Diffie-Hellman (ECDH)[5]
- Algoritmo di firma digitale a curva ellittica (ECDSA)6
- Algoritmi che utilizzano la crittografia a campo finito (FFC), tra cui:
- Algoritmi di hash, dove l'algoritmo riduce un messaggio originale a un valore di lunghezza fissa molto più piccolo, univoco, chiamato in vari modi: hash, digest o firma. Queste funzioni di conversione unidirezionale svolgono un ruolo cruciale nel verificare che il messaggio non sia stato alterato (integrità) e trovano applicazione in più protocolli che coinvolgono un codice di autenticazione dei messaggi (MAC), un codice di autenticazione dei messaggi con codifica hash (HMAC) o funzioni di derivazione della chiave (KDF), tra le altre. Gli algoritmi di hash crittografico includono:
- MD5 (message digest 5)
- Algoritmi di hash sicuro (SHA)[7] come SHA-256, che genera un valore di hash a 256 bit per un messaggio.
Come ogni altro efficace algoritmo di crittografia, gli algoritmi sopra citati sono stati concepiti con molteplici requisiti cruciali che vanno ben oltre lo scopo di questo breve articolo. In generale, tuttavia, gli algoritmi basati sulla chiave devono generare un testo cifrato che è pressoché impossibile (o almeno economicamente impossibile) da decifrare senza la chiave. Dal canto loro, gli algoritmi di hash devono generare rapidamente l'hash, producendo lo stesso hash per lo stesso messaggio in ingresso, ma generando un hash nettamente diverso anche per un leggero cambiamento del messaggio in ingresso, senza mai produrre lo stesso valore di hash per due messaggi diversi e senza mai produrre il messaggio originale con un particolare valore di hash.
Sebbene i dettagli di questi e di altri algoritmi crittografici differiscano ampiamente, tutti si basano su una serie di manipolazioni di basso livello, trasformazioni e altre operazioni matematiche finalizzate a centrare questi obiettivi generali. Ad esempio, il cifrario AES converte il testo in chiaro in testo cifrato utilizzando una serie di "round" che incorporano "chiavi di round" univoche derivate dalla chiave segreta originale dell'utente (Listato 1).
Copy
Cipher(byte in[4*Nb], byte out[4*Nb], word w[Nb*(Nr+1)])
begin
byte state[4,Nb]
state = in
AddRoundKey(state, w[0, Nb-1])
for round = 1 step 1 to Nr–1
SubBytes(state)
ShiftRows(state)
MixColumns(state)
AddRoundKey(state, w[round*Nb, (round+1)*Nb-1])
end for
SubBytes(state)
ShiftRows(state)
AddRoundKey(state, w[Nr*Nb, (Nr+1)*Nb-1])
out = state
end
Listato 1: Questo pseudocodice descrive le sequenze delle operazioni di cifratura dei messaggi, convertendo il testo in chiaro (in) in testo cifrato (out) mediante un insieme di valori (w) derivati dalla chiave privata del mittente. (Codice per gentile concessione di NIST)
All'interno di un round, la trasformazione SubBytes() sostituisce ogni byte utilizzando una tabella di sostituzione (S-box), che a sua volta è il risultato di una serie di trasformazioni (Figura 1).
Figura 1: Nel cifrario AES, la fase SubBytes() sostituisce ogni byte utilizzando una tabella di sostituzione (S-Box). (Immagine per gentile concessione di NIST)
Nella fase successiva della sequenza, la trasformazione ShiftRows() sposta i byte nelle ultime tre righe, ognuna con un numero di byte diverso (Figura 2).
Figura 2: La fase ShiftRows() nella sequenza di esecuzione del cifrario AES sposta le righe aumentando gli offset. (Immagine per gentile concessione di NIST)
Nei passi finali della sequenza, MixColumns() applica ad ogni colonna una trasformazione che sostituisce ogni byte della colonna con il risultato di un polinomio, mentre AddRoundKey() trasforma il risultato eseguendo un'operazione XOR bitwise su ogni colonna utilizzando una chiave di round appositamente creata.
Il numero totale dei round varia a seconda della dimensione della chiave. AES-128, che utilizza una chiave a 128 bit, richiede 10 round, mentre AES-192 (dimensione chiave 192 bit) e AES-256 (256 bit) richiedono rispettivamente 12 e 14 round. La decodifica segue lo stesso schema, invertendo le fasi del processo e le loro trasformazioni separate.
Cifrari più recenti come ECDH utilizzato per lo scambio di chiavi ed ECDSA utilizzato per le firme digitali si basano su operazioni matematiche più complesse come le strutture algebriche a curva ellittica ampiamente definite dalla formula:
Equazione 1
Con un'attenta selezione dei parametri delle curve a e b e l'uso di vincoli aggiuntivi, le curve mostrano proprietà crittografiche utili (anche in questo caso, esulano dallo scopo di questo articolo). Anche se concettualmente semplice, l'insieme specifico dei parametri è fondamentale: una cattiva selezione dei parametri delle curve può portare a curve che rimangono vulnerabili ad attacchi sofisticati. Per contribuire a eliminare questa possibilità, NIST fornisce un set standard di curve crittograficamente robuste, tra cui P-192, P-224, P-256 e altre di robustezza maggiore. I nomi delle curve corrispondono alla lunghezza in bit del numero primo p di elementi nel campo primo sottostante la curva.
Uno sviluppatore può utilizzare queste proprietà con ECDSA per firmare alcuni messaggi utilizzando una curva concordata e fornire al destinatario la chiave pubblica e la firma – una coppia di numeri etichettati r e s. Il processo di firma vera e propria prevede le seguenti fasi:
- Partendo da un punto della curva, chiamato punto base G(x,y), l'algoritmo crea una chiave pubblica Q(x,y) moltiplicando il punto base per il modulo p della chiave privata dello sviluppatore (d):
Equazione 2
- Un altro punto di coordinate (x1,y1) viene creato utilizzando un numero casuale k nell'intervallo [1 ... n-1]:
Equazione 3
- H(m), l'hash SHA del messaggio m, viene generato
- Utilizzando il modulo inverso del numero casuale k, k-1, le componenti finali r e s della firma digitale vengono generate come segue:
Equazione 4
Equazione 5
Il risultato finale è uno scambio che autentica il messaggio, ne conferma l'integrità e ne garantisce il non ripudio.
Come implementare gli algoritmi crittografici
La lezione da questa trattazione sui generis degli algoritmi è che gli algoritmi crittografici si basano su una sequenza di operazioni matematiche studiate per rendere i tentativi di compromissione dei risultati talmente costosi che diventa impossibile - o impraticabile - completarli abbastanza velocemente per essere utili all'esecutore. Inoltre, anche un'ispezione sommaria di ogni algoritmo suggerisce che un dispositivo IoT con risorse limitate avrà probabilmente poche possibilità di eseguire un'implementazione software dell'algoritmo senza potenzialmente compromettere i requisiti funzionali primari del dispositivo stesso. Infine, i dettagli precisi dell'algoritmo al di là dei passi qui mostrati significano che anche un piccolo errore di codifica o una minima interpretazione errata dello standard può portare a vulnerabilità della sicurezza o addirittura al fallimento del processo crittografico.
Errori nell'implementazione degli algoritmi possono verificarsi anche nelle più grandi aziende di sviluppo e nelle applicazioni che dipendono fortemente da tali algoritmi. Ad esempio, una nota vulnerabilità in una console di gioco è stata rivelata perché l'implementazione di ECDSA, creata dalla società, ha utilizzato un valore costante di k, anziché un valore casuale per il tipo di calcolo mostrato nell'equazione 3. Di conseguenza, gli hacker avrebbero potuto ricavare la chiave segreta d. L'uso di un generatore casuale difettoso per la creazione di k ha portato ad un exploit simile che ha portato a una grave perdita di Bitcoin.
Le capacità crittografiche basate su hardware integrate nei processori e nei CI di sicurezza dedicati consentono agli sviluppatori di ignorare ampiamente i complessi dettagli dell'esecuzione degli algoritmi crittografici e di concentrarsi invece sui vantaggi dati dall'uso di tali capacità per proteggere le loro applicazioni. Questi dispositivi aggiungono un ulteriore livello di sicurezza integrando i flussi di dati e le operazioni nel dispositivo, eliminando una forma comune di attacco che monitora i bus esterni alla ricerca di informazioni privilegiate. Oltre a fornire un'implementazione affidabile di un particolare algoritmo, una soluzione basata su hardware consente agli sviluppatori di integrare la sicurezza nei progetti senza compromettere i requisiti fondamentali come la latenza della risposta e le prestazioni complessive.
Gli acceleratori crittografici integrati in questi dispositivi scaricano il compito dell'esecuzione crittografica dal processore principale, liberandolo per gestire la funzione primaria del progetto. Infatti, il supporto crittografico basato su hardware è una caratteristica sempre più comune nei processori. Allo stesso tempo, non tutte le applicazioni richiedono la piena forza delle misure di sicurezza supportate dagli algoritmi sopra descritti. Gli sviluppatori possono trovare un'ampia gamma di algoritmi crittografici accelerati e combinazioni di algoritmi in processori come i seguenti:
- Microcontroller a 32 bit MAX32631 di Maxim Integrated, che supporta i cifrari AES e DSA
- MCU a 32 bit MAX32520 di Maxim Integrated, che supporta gli algoritmi AES, SHA ed ECDSA
- Famiglia di microcontroller a 16 bit PIC 24F XLP di Microchip Technology, con dispositivi come PIC24FJ256GA406 che supporta i cifrari AES e 3DES
- MCU a 32 bit PIC 32MZ e MPU a 32 bit della famiglia SAM9X60 di Microchip Technology, con dispositivi come PIC32MZ2048EFM144 e SAM9X60T che supportano i cifrari AES e 3DES e le funzioni hash SHA e HMAC
- Famiglia di MCU SimpleLink di Texas Instruments come gli MCU wireless CC1312R e CC2652R, che supportano i cifrari AES, ECDH e ECDSA e le funzioni hash SHA
Altri dispositivi di sicurezza come DS28E38 di Maxim Integrated e ATECC608A di Microchip Technology integrano acceleratori crittografici e le relative funzionalità necessarie per velocizzare i protocolli di autenticazione. Tra le loro ampie capacità di crittografia, questi dispositivi supportano il tipo di operazione ECDSA descritta in precedenza. In un dispositivo IoT o in una periferica intelligente, un processore host può utilizzare CI di autenticazione come questi per creare rapidamente firme digitali ECDSA P-256 da inviare a un altro dispositivo o autenticare le firme ECDSA P-256 da altri dispositivi.
I processori abilitati alla sicurezza e i dispositivi specializzati sono tipicamente costruiti con un'ampia struttura di sicurezza basata su hardware che fornisce funzionalità di sicurezza aggiuntive, come i generatori di numeri casuali di alta qualità. Molti dispositivi che forniscono questo livello di capacità sfruttano le sorgenti di rumore casuale insite nei progetti dei semiconduttori per massimizzare l'entropia necessaria nei generatori di numeri casuali reali (TRNG). Come suggerito nell'esempio Bitcoin sopra citato, questi tipi di TRNG sono essenziali per il corretto funzionamento degli algoritmi crittografici.
Il supporto integrato per lo storage sicuro delle chiavi private e di altri dati segreti fornisce una delle capacità più importanti di progettazione sicura. Altre caratteristiche architettoniche disponibili con questi e altri processori simili forniscono un livello di sicurezza ancora maggiore.
Per tutte le loro capacità, i processori con acceleratori crittografici integrati e le relative caratteristiche contribuiscono a semplificare lo sviluppo di progetti sicuri attraverso l'uso di semplici librerie API (interfaccia di programmazione di applicazioni). Chiamate intuitive delle funzioni API consentono agli sviluppatori di astrarre le implementazioni di sicurezza, affidandosi all'API per accedere alle funzionalità hardware sottostanti. Ad esempio, gli sviluppatori possono utilizzare il kit di valutazione MAX32520-KIT di Maxim Integrated per l'MCU MAX32520 in combinazione con il kit di sviluppo software (SDK) Micros sempre di Maxim Integrated per realizzare velocemente dispositivi IoT sicuri. Insieme ai driver e al middleware associati, l'SDK Micros di Maxim Integrated include funzioni di esempio che dimostrano i pattern di progettazione di base necessari per crittografare i (AES128_ECB_enc()) e decrittografare (AES128_ECB_dec ())) i messaggi utilizzando il cifrario AES (Listato 2).
Copy
int AES128_ECB_enc(int asynchronous)
{
printf( asynchronous ? "Test Cipher Async\n" : "Test Cipher Sync\n");
char *_key = "797f8b3d176dac5b7e34a2d539c4ef36";
char key[MXC_AES_KEY_128_LEN];
ascii_to_byte(_key, key, MXC_AES_KEY_128_LEN);
const char *iv_src = "";
char iv_dst[16];
ascii_to_byte(iv_src, iv_dst, 16);
char *_pt= "00000000000000000000000000000000";
char pt[MXC_AES_DATA_LEN];
ascii_to_byte(_pt, pt, MXC_AES_DATA_LEN);
mxc_ctb_cipher_req_t cipher_req = {
(uint8_t*)pt,
MXC_AES_DATA_LEN,
(uint8_t*)iv_src,
(uint8_t*)result,
&Test_Callback };
// Reset crypto block
MXC_CTB_Init(MXC_CTB_FEATURE_CIPHER | MXC_CTB_FEATURE_DMA);
MXC_CTB_IntEnable(asynchronous);
MXC_CTB_Cipher_SetMode(MXC_CTB_MODE_ECB);
MXC_CTB_Cipher_SetCipher(MXC_CTB_CIPHER_AES128);
MXC_CTB_Cipher_SetKeySource(MXC_CTB_CIPHER_KEY_SOFTWARE);
// Load key into cipher key register
MXC_CTB_Cipher_SetKey((uint8_t *)key, MXC_AES_KEY_128_LEN);
if (asynchronous){
wait = 1;
MXC_CTB_Cipher_EncryptAsync(&cipher_req);
while( wait );
} else {
MXC_CTB_Cipher_Encrypt(&cipher_req);
}
const char *_expected = "322FD6E503395CDB89A77AC53D2B954F";
char expected[MXC_AES_DATA_LEN];
ascii_to_byte(_expected, expected, MXC_AES_DATA_LEN);
return AES_check(result, expected, MXC_AES_DATA_LEN);
}
int AES128_ECB_dec(int asynchronous)
{
printf( asynchronous ? "Test Cipher Async\n" : "Test Cipher Sync\n");
char *_key = "797f8b3d176dac5b7e34a2d539c4ef36";
char key[MXC_AES_KEY_128_LEN];
ascii_to_byte(_key, key, MXC_AES_KEY_128_LEN);
const char *iv_src = "";
char iv_dst[16];
ascii_to_byte(iv_src, iv_dst, 16);
char *_pt= "322FD6E503395CDB89A77AC53D2B954F";
char pt[MXC_AES_DATA_LEN];
ascii_to_byte(_pt, pt, MXC_AES_DATA_LEN);
mxc_ctb_cipher_req_t cipher_req = {
(uint8_t*)pt,
MXC_AES_DATA_LEN,
(uint8_t*)iv_src,
(uint8_t*)result,
&Test_Callback };
// Reset crypto block
MXC_CTB_Init(MXC_CTB_FEATURE_CIPHER | MXC_CTB_FEATURE_DMA);
MXC_CTB_IntEnable(asynchronous);
MXC_CTB_Cipher_SetMode(MXC_CTB_MODE_ECB);
MXC_CTB_Cipher_SetCipher(MXC_CTB_CIPHER_AES128);
MXC_CTB_Cipher_SetKeySource(MXC_CTB_CIPHER_KEY_SOFTWARE);
// Load key into cipher key register
MXC_CTB_Cipher_SetKey((uint8_t *)key, MXC_AES_KEY_128_LEN);
if (asynchronous){
wait = 1;
MXC_CTB_Cipher_DecryptAsync(&cipher_req);
while( wait );
} else {
MXC_CTB_Cipher_Decrypt(&cipher_req);
}
const char *_expected = "00000000000000000000000000000000";
char expected[MXC_AES_DATA_LEN];
ascii_to_byte(_expected, expected, MXC_AES_DATA_LEN);
return AES_check(result, expected, MXC_AES_DATA_LEN);
}
Listato 2: Gli sviluppatori possono ispezionare il codice di esempio nel pacchetto di distribuzione SDK Micros di Maxim Integrated per apprendere i pattern di progettazione di base necessari per la crittografia AES (AES128_ECB_enc()) e la decrittografia (AES128_ECB_dec ()) utilizzando le funzioni di crittografia integrate dell'MCU MAX32520. (Codice per gentile concessione di Maxim Integrated)
Protocolli di autenticazione
Le robuste implementazioni di algoritmi crittografici sono particolarmente critiche per fornire una base sicura ai protocolli di livello superiore utilizzati nelle applicazioni. I protocolli di livello superiore come Transport Layer Security (TLS) solitamente eseguono le operazioni utilizzando un insieme definito di algoritmi crittografici, chiamato suite di cifratura. In TLS, gli algoritmi ricavati da una suite di cifratura concordata aiutano a garantire l'autenticazione e la riservatezza nelle sessioni di comunicazione tra il client di un dispositivo IoT e il server host. TLS 1.2[8] procede attraverso una specifica sequenza di transazioni per negoziare i parametri, eseguire l'autenticazione e scambiare le chiavi di sessione prima di procedere allo scambio dei dati (Figura 3).
Figura 3: Il protocollo di creazione di una sessione TLS 1.2 utilizza svariati algoritmi di una suite di cifratura concordata per l'autenticazione, lo scambio delle chiavi e lo scambio dei dati in corso. (Immagine per gentile concessione di Texas Instruments)
L'autenticazione è garantita dall'accertamento dell'identità del server (e opzionalmente del client) mediante la verifica dei certificati di sicurezza, contenenti la rispettiva chiave pubblica di ogni partecipante. Qui ogni partecipante invia un messaggio criptato con la propria chiave privata. Poiché la chiave pubblica ricevuta può solo decifrare un messaggio criptato con la sua chiave privata associata, ogni partecipante può confermare che il fornitore di un certificato è effettivamente il proprietario di quel certificato.
Nella successiva fase TLS, i partecipanti eseguono una serie di transazioni per creare una chiave di sessione condivisa. Questa chiave di sessione condivisa viene poi utilizzata per crittografare il traffico effettivo dei messaggi, garantendo la riservatezza degli scambi di messaggi per quella sessione.
Varie opzioni di protocollo consentono agli sviluppatori di perfezionare questo processo generico di creazione di sessioni TLS, a volte a discapito della sicurezza generale. Inoltre, durante il processo di scambio dei parametri, gli sviluppatori possono utilizzare una diversa suite di cifratura selezionando una combinazione adeguata di algoritmi supportati da TLS 1.2 per ogni fase del protocollo, tra cui:
- Istituzione di una chiave: RSA, DH, ECDH
- Autenticazione: RSA, DSA, ECDSA
- Cifrari: 3DES, AES
- Autenticazione del messaggio: SHA
La più recente versione di TLS, TLS 1.3[9], aggiunge ulteriore sicurezza eseguendo prima lo scambio di chiavi per proteggere meglio il processo di creazione della sessione. Nello specifico, TLS 1.3 fa meno di una grande parte della suite di cifratura TLS 1.2 a favore di algoritmi più robusti, tra cui l'uso della funzione di estrazione ed espansione della chiave di derivazione basata su HMAC (HKDF) e la cifratura autenticata con gli algoritmi di dati associati (AEAD). Gli algoritmi AEAD rispondono all'esigenza di garantire l'autenticità, l'integrità e la riservatezza dei messaggi. Questi algoritmi lo fanno combinando il messaggio criptato con un MAC che può essere generato in serie (Figura 4, a sinistra), in parallelo (Figura 4, a destra) o in una combinazione dei due modi.
Figura 4: AEAD fornisce l'autenticazione e la riservatezza includendo un MAC con il testo cifrato utilizzando, tra le altre tecniche, metodi chiamati encrypt-then-MAC (sinistra) ed encrypt-and-MAC (destra) che calcolano il MAC rispettivamente in serie o in parallelo. (Immagine per gentile concessione di Wikipedia)
Maggior robustezza della sicurezza
Questa evoluzione degli algoritmi crittografici e dei protocolli associati delinea la corsa tra gli esperti di crittografia determinati a rafforzare la sicurezza e quelli altrettanto determinati a sconfiggerla. Ad esempio, nel tentativo di migliorare la sicurezza, gli esperti hanno creato l'ECDSA come variante ECC della DSA, a sua volta una variante dei cifrari precedenti. Il risultato è che ECDSA può raggiungere la stessa robustezza di sicurezza della DSA, ma con una chiave molto più piccola.
Nella crittografia, la robustezza della sicurezza dell'algoritmo è definita in termini di x bit e l'aspettativa che un attacco richiederebbe circa 2x operazioni per ricavare la chiave privata sottostante l'algoritmo. In questi termini, le diverse classi di algoritmi possono richiedere lunghezze di chiave molto diverse per raggiungere livelli di sicurezza comparabili (Tabella 1).
Tabella 1: Diverse classi di algoritmi crittografici possono richiedere chiavi di dimensioni molto diverse per le chiavi pubbliche (L) o private (N, k, f) per raggiungere livelli di sicurezza comparabili. (Immagine per gentile concessione di NIST)
In questa tabella del NIST, i parametri L e Ndell'algoritmo FFC corrispondono rispettivamente alle dimensioni della chiave pubblica e della chiave privata. Per gli algoritmi IFC ed ECC, k e f corrispondono rispettivamente alla dimensione della chiave. Il NIST osserva che gli algoritmi con robustezza della sicurezza £80 (sfondo arancione nella tabella) non sono più approvati per la protezione di informazioni governative, mentre altri (sfondo giallo) non sono ancora inclusi negli standard NIST a causa di problemi legati all'efficienza.
Questo incremento della robustezza della sicurezza continua a guidare l'evoluzione dei cifrari e delle suite di cifrari consigliati. Ad esempio, la suite Commercial National Security Algorithm (CNSA) della U.S. National Security Agency (NSA) ha sostituito la precedente suite B della NSA con raccomandazioni per l'uso di parametri più robusti necessari per proteggere le informazioni classificate come Top Secret (Tabella 2).
Tabella 2: La suite CNSA raccomandata dall'NSA include algoritmi crittografici con raccomandazioni per i livelli minimi di sicurezza necessari per proteggere le informazioni molto sensibili. (Immagine per gentile concessione di Digi-Key da dati di NSA)
Guardando al futuro, la disponibilità di capacità di calcolo quantistico presenterà un grosso ostacolo alla sicurezza in generale e agli algoritmi crittografici in particolare.
Conclusione
I dispositivi IoT e altri progetti connessi devono affrontare un numero crescente di minacce che richiedono metodi di sicurezza sempre più robusti basati su un'ampia gamma di algoritmi di crittografia. Progettati per rendere impraticabile il cracking della sicurezza, questi algoritmi si basano su una serie di trasformazioni e operazioni matematiche per criptare il testo in chiaro in testo cifrato e decriptare il testo cifrato in testo in chiaro. Come mostrato, è possibile utilizzare implementazioni basate su hardware di questi algoritmi per consentire agli sviluppatori di integrare più facilmente una sicurezza robusta in un progetto senza comprometterne i requisiti primari di funzionalità e prestazioni.
Riferimenti:
Esonero della responsabilità: le opinioni, le convinzioni e i punti di vista espressi dai vari autori e/o dai partecipanti al forum su questo sito Web non riflettono necessariamente le opinioni, le convinzioni e i punti di vista di DigiKey o le sue politiche.
Svizzera