Paramètres
Livraison rapide
Livraison gratuite
Incoterms
Types de paiement
Produit marketplace
Principes de base de la sécurité IoT — 1re partie : utilisation de la cryptographie
Avec la contribution de Rédacteurs nord-américains de DigiKey
2020-06-03
Note de l'éditeur : Cette série en plusieurs parties fournit des conseils pratiques pour aider les développeurs à s'assurer que les meilleures pratiques sont suivies dès le départ. Cette première partie traite des algorithmes de cryptographie sous-jacents aux conceptions sécurisées. La 2e partie traite du rôle des clés privées, de la gestion des clés et du stockage sécurisé dans les systèmes sécurisés. La 3e partie étudie les mécanismes intégrés dans les processeurs sécurisés pour atténuer les menaces de détournement de l'exécution des systèmes et des logiciels d'application sur les dispositifs IoT. La 4e partie identifie des mécanismes de sécurité et montre comment les appliquer dans les processeurs avancés pour contribuer à assurer l'isolement requis pour atténuer les attaques sur l'environnement d'exécution des dispositifs IoT. La 5e partie décrit comment la sécurité IoT continue à s'étendre depuis les dispositifs IoT par le biais de mesures de sécurité de niveau supérieur utilisées pour connecter ces dispositifs aux ressources cloud IoT.
Le recours croissant aux applications IoT dans l'industrie, la médecine, les transports et d'autres applications critiques a radicalement modifié le paysage de la sécurité. Contrairement aux anciennes applications d'entreprise disposant de ressources facilement disponibles pour le traitement des algorithmes de sécurité, les applications IoT de niveau entreprise sont vulnérables à un nombre croissant de menaces qui visent les réseaux en expansion de dispositifs IoT aux ressources limitées. Dans leur empressement à répondre aux opportunités émergentes de l'IoT, les organisations déploient trop souvent des dispositifs IoT fonctionnellement incapables de supporter les mesures de sécurité de base pour protéger les données stockées et protéger l'échange de données et de commandes sur des réseaux vulnérables.
La distance que doivent parcourir les développeurs pour assurer la sécurité d'un projet dépend de multiples facteurs. Chaque application est confrontée à un ensemble de menaces qui lui est propre et nécessite une évaluation appropriée des risques liés à ces menaces. Les dispositifs connectés étant confrontés à un nombre inhabituel de menaces, tout dispositif IoT nécessitera au moins quelques mesures de sécurité minimales.
Pour certains, la mise en œuvre de mesures de sécurité robustes pour un simple dispositif IoT peut sembler exagérée, mais même de simples dispositifs de capteurs de température qui ne sont pas suffisamment protégés peuvent fournir aux pirates un point d'entrée dans les réseaux d'entreprise [1]. En effet, la sécurité IoT est confrontée à des défis constants en raison de la combinaison de la connectivité omniprésente fournie par les applications IoT et des dispositifs à ressources limitées sous-jacents à ces applications. En fait, même dans les conceptions de dispositifs IoT disposant de ressources suffisantes pour exécuter des algorithmes de cryptographie dans les logiciels, les applications peuvent rester vulnérables en raison d'erreurs subtiles dans l'implémentation de ces algorithmes.
Cet article décrit les classes de base des algorithmes de cryptographie et explore leur rôle dans la sécurité. Il montre ensuite comment les développeurs peuvent tirer parti des processeurs et des dispositifs spécialisés de Maxim Integrated, Microchip Technology, et Texas Instruments, conçus pour accélérer ces algorithmes, améliorant différents aspects de la sécurité tout en simplifiant sa mise en œuvre.
Les différents types d'algorithmes cryptographiques et leurs rôles
Les algorithmes de cryptographie se répartissent en trois grandes catégories qui traitent des principes de sécurité fondamentaux que sont la confidentialité, l'authentification (vérifier la source du message), la non-répudiation (prouver que l'expéditeur a créé un message crypté ou signé) et l'intégrité :
- Algorithme à clé symétrique, où l'algorithme ou le chiffrement utilise la même clé secrète pour crypter un message lisible par l'homme (texte en clair) en une version protégée (texte chiffré), et ensuite pour décrypter le texte chiffré en texte en clair. Le chiffrement à clé symétrique est généralement utilisé pour garantir la confidentialité. Les algorithmes de cryptographie symétrique courants incluent :
- Triple DES (Data Encryption Standard), également connu sous le nom de 3DES, ou officiellement par l'Institut national américain des normes et des technologies (NIST) sous le nom de Triple Data Encryption Algorithm (TDEA).
- Algorithmes Advanced Encryption Standard (AES)[2] tels qu'AES-256, qui utilise des clés 256 bits.
- Algorithme à clé asymétrique, où le chiffrement utilise un ensemble associé de clés privées et publiques pour chiffrer et déchiffrer un message, généralement dans le cadre de protocoles de sécurité plus intensifs pour l'agrément de clés et les signatures numériques. Le chiffrement asymétrique est généralement utilisé pour garantir la confidentialité, l'authentification ou la non-répudiation. Les algorithmes de cryptographie à clé publique incluent :
- Algorithmes utilisant la cryptographie en champ fini (FFC), y compris :
- Algorithme de signature numérique (DSA) FIPS (Federal Information Processing Standards)
- Échange de clés Diffie-Hellman (DH)[3] IETF (Internet Engineering Task Force)
- Algorithmes utilisant la cryptographie à factorisation d'entiers (IFC), notamment :
- Algorithme RSA (Rivest–Shamir–Adleman)[4]
- Algorithmes utilisant la cryptographie à courbe elliptique (ECC), y compris :
- Échange de clés ECDH (Elliptic Curve Diffie-Hellman)[5]
- Algorithme de signature numérique à courbe elliptique (ECDSA)[6]
- Algorithmes utilisant la cryptographie en champ fini (FFC), y compris :
- Algorithmes de hachage, où l'algorithme réduit un message original à une valeur de longueur fixe unique et beaucoup plus petite, appelée diversement hachage, condensé ou signature. Ces fonctions de conversion unidirectionnelle jouent un rôle essentiel pour vérifier que le message n'a pas été altéré (intégrité), et sont appliquées dans de multiples protocoles impliquant un code d'authentification de message (MAC), un code d'authentification de message avec hachage de clé (HMAC) ou des fonctions de dérivation de clé (KDF), entre autres. Les algorithmes de hachage cryptographique incluent :
- MD5 (Message Digest 5)
- Algorithmes de hachage sécurisés (SHA)[7] tels que SHA-256, qui génère une valeur de hachage de 256 bits pour un message.
Comme pour tout algorithme de cryptographie efficace, les algorithmes mentionnés ci-dessus sont conçus avec de multiples exigences critiques qui dépassent largement le cadre de ce bref article. D'un point de vue général, cependant, les algorithmes basés sur des clés doivent générer un texte chiffré pratiquement impossible (ou du moins économiquement irréalisable) à décrypter sans la clé. Pour leur part, les algorithmes de hachage doivent générer des hachages rapidement, en produisant le même hachage pour le même message d'entrée mais en générant un hachage nettement différent même pour une légère modification du message d'entrée, sans jamais produire la même valeur de hachage pour deux messages différents, et sans jamais produire le message original étant donné une valeur de hachage particulière.
Bien que les détails de ces algorithmes et d'autres algorithmes cryptographiques diffèrent largement, ils reposent tous sur une série de manipulations de bas niveau, de transformations et d'autres opérations mathématiques conçues pour atteindre ces objectifs généraux. Par exemple, le chiffrement AES convertit le texte en clair en texte chiffré en utilisant une série de « rondes » qui incorporent des « clés rondes » uniques dérivées de la clé secrète originale de l'utilisateur (Liste 1).
Copier
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
Liste 1 : Ce pseudo-code décrit les séquences d'opérations impliquées dans le cryptage de messages, en convertissant le texte en clair (in) en texte chiffré (out) à l'aide d'un ensemble de valeurs (w) dérivées de la clé privée de l'expéditeur. (Source du code : NIST)
Dans une ronde, la transformation SubBytes() remplace chaque octet en utilisant une table de substitution (S-box), qui est elle-même le résultat d'une série de transformations (Figure 1).
Figure 1 : Dans le chiffrement AES, l'étape SubBytes() remplace chaque octet en utilisant une table de substitution (S-Box). (Source de l'image : NIST)
Dans l'étape suivante de la séquence, la transformation ShiftRows() décale les octets dans les trois dernières lignes, chacune d'un nombre différent d'octets (Figure 2).
Figure 2 : L'étape ShiftRows() dans la séquence d'exécution du chiffrement AES déplace les lignes en augmentant les décalages. (Source de l'image : NIST)
Dans les dernières étapes de la séquence, MixColumns() applique à chaque colonne une transformation qui remplace chaque octet dans la colonne par le résultat d'un polynôme, tandis que AddRoundKey() transforme le résultat en effectuant une opération XOR bit par bit sur chaque colonne à l'aide d'une clé ronde créée à cet effet.
Le nombre total de rondes varie en fonction de la taille de la clé. AES-128, qui utilise une clé de 128 bits, nécessite 10 rondes, tandis qu'AES-192 (clé de 192 bits) et AES-256 (256 bits) requièrent respectivement 12 et 14 rondes. Le décryptage suit le même schéma, en inversant les étapes du processus et leurs transformations distinctes.
Des chiffrements plus récents comme ECDH utilisé pour l'échange de clés et ECDSA utilisé pour les signatures numériques reposent sur des mathématiques plus complexes telles que les structures algébriques de courbe elliptique largement définies par la formule :
Équation 1
Grâce à une sélection minutieuse des paramètres de courbe a et b et à l'utilisation de contraintes supplémentaires, les courbes présentent des propriétés cryptographiques utiles (là encore, en dehors du champ d'application de cet article). Bien que conceptuellement simple, l'ensemble spécifique de paramètres est fondamental : une mauvaise sélection des paramètres de courbe peut entraîner des courbes qui restent vulnérables aux attaques sophistiquées. Pour aider à éliminer cette possibilité, le NIST fournit un ensemble standard de courbes cryptographiquement robustes incluant P-192, P-224, P-256 et d'autres plus robustes. Le nom des courbes correspond à la longueur binaire du nombre premier p d'éléments du champ premier sous-jacent de la courbe.
Un développeur peut utiliser ces propriétés avec l'ECDSA pour signer un message en utilisant une courbe convenue, et fournir au destinataire la clé publique et la signature — une paire de chiffres identifiés par r et s. Le processus de signature proprement dit implique les étapes suivantes :
- En partant d'un point de la courbe, appelé point de base G(x,y), l'algorithme crée une clé publique Q(x,y) en multipliant le point de base par la clé privée du développeur (d) modulo p :
Équation 2
- Un autre point de coordonnées (x1,y1) est créé en utilisant un nombre aléatoire k dans la plage [1 ... n-1] :
Équation 3
- H(m), le hachage SHA du message m, est généré
- En utilisant l'inverse modulaire du nombre aléatoire k, k-1, les composantes finales r et s de la signature numérique sont générées comme suit :
Équation 4
Équation 5
Le résultat final est un échange qui authentifie le message, confirme son intégrité et garantit la non-répudiation.
Comment implémenter des algorithmes de cryptographie
La leçon à tirer de cet aperçu, certes superficiel, de ces algorithmes est que les algorithmes cryptographiques reposent sur une séquence d'opérations mathématiques conçues pour rendre les tentatives de compromission des résultats si intensives en termes de calcul qu'il est impossible, ou peu pratique, de les mener à bien suffisamment rapidement pour qu'elles soient utiles à l'instigateur. En outre, même une inspection superficielle de chaque algorithme suggère qu'un dispositif IoT à ressources limitées aura probablement peu de chances d'exécuter une implémentation logicielle de l'algorithme sans potentiellement compromettre les exigences fonctionnelles primaires du dispositif. Enfin, les détails précis de l'algorithme au-delà des étapes présentées ici signifient que même une erreur de codage subtile ou une mauvaise interprétation mineure de la norme peut entraîner des vulnérabilités de sécurité, voire l'échec total du processus cryptographique.
Des erreurs dans la mise en œuvre des algorithmes peuvent se produire même dans les plus grandes organisations de développement, et dans les applications qui dépendent de manière critique de ces algorithmes. Par exemple, une vulnérabilité connue dans une console de jeu a été révélée parce que l'implémentation ECDSA créée par l'entreprise utilisait une valeur constante de k, plutôt qu'une valeur aléatoire pour le type de calcul indiqué dans l'Équation 3. En conséquence, les pirates informatiques pouvaient dériver la clé secrète d. L'utilisation d'un générateur aléatoire défectueux pour la création de k a conduit à un coup d'éclat similaire entraînant une perte importante de Bitcoin.
Les capacités cryptographiques matérielles intégrées dans les processeurs et les circuits intégrés de sécurité dédiés permettent aux développeurs d'ignorer largement les détails complexes de l'exécution des algorithmes cryptographiques et de se concentrer plutôt sur les avantages de l'utilisation de ces capacités pour sécuriser leurs applications. Ces dispositifs ajoutent une couche de sécurité supplémentaire en intégrant les flux de données et les opérations dans le dispositif, supprimant ainsi une forme courante d'attaque qui consiste à surveiller les bus externes à la recherche de signes d'informations privilégiées. En plus de fournir une implémentation fiable d'un algorithme particulier, une solution matérielle permet aux développeurs d'intégrer la sécurité dans les conceptions sans compromettre les exigences fondamentales telles que la latence de réponse et les performances globales.
Les accélérateurs cryptographiques intégrés à ces dispositifs déchargent l'exécution de la cryptographie du processeur principal, le libérant ainsi pour qu'il puisse gérer la fonction principale de la conception. En fait, la prise en charge de la cryptographie basée sur le matériel est devenue une caractéristique de plus en plus courante des processeurs. En même temps, toutes les applications ne nécessitent pas la pleine force des mesures de sécurité prises en charge par les algorithmes décrits ci-dessus. En effet, les développeurs peuvent trouver un large éventail d'algorithmes cryptographiques accélérés et de combinaisons d'algorithmes dans des processeurs tels que les suivants :
- Le microcontrôleur 32 bits MAX32631 de Maxim Integrated, qui prend en charge le chiffrement AES et DSA
- Le microcontrôleur 32 bits MAX32520 de Maxim Integrated, qui prend en charge les algorithmes AES, SHA et ECDSA
- Les membres de la gamme de microcontrôleurs 16 bits PIC 24F XLP de Microchip Technology, où des dispositifs tels que le PIC24FJ256GA406 prennent en charge le chiffrement AES et 3DES
- Les membres de la gamme de microcontrôleurs 32 bits PIC 32MZ et de microprocesseurs 32 bits SAM9X60 de Microchip Technology, où des dispositifs tels que le PIC32MZ2048EFM144 et le SAM9X60T prennent en charge le chiffrement AES et 3DES ainsi que les fonctions de hachage SHA et HMAC
- Les membres de la gamme de microcontrôleurs SimpleLink de Texas Instruments, tels que les microcontrôleurs sans fil CC1312R et CC2652R, qui prennent en charge le chiffrement AES, ECDH et ECDSA ainsi que les fonctions de hachage SHA
D'autres dispositifs de sécurité tels que le DS28E38 de Maxim Integrated et l'ATECC608A de Microchip Technology intègrent des accélérateurs cryptographiques et les fonctionnalités associées requises pour accélérer les protocoles d'authentification. Parmi leurs vastes capacités cryptographiques, ces dispositifs prennent en charge le type d'opération ECDSA décrit précédemment. Dans un dispositif IoT ou un périphérique intelligent, un processeur hôte peut utiliser des circuits intégrés d'authentification tels que ceux-ci pour créer rapidement des signatures numériques ECDSA P-256 à envoyer à un autre dispositif ou authentifier les signatures ECDSA P-256 d'autres dispositifs.
Les processeurs de sécurité et les dispositifs spécialisés sont généralement construits avec une vaste structure de sécurité basée sur le matériel qui fournit des fonctionnalités de sécurité supplémentaires telles que des générateurs de nombres aléatoires de haute qualité. De nombreux dispositifs qui offrent ce niveau de capacité tirent parti des sources de bruit aléatoires inhérentes à la conception des semi-conducteurs pour maximiser l'entropie requise dans les générateurs de nombres véritablement aléatoires (TRNG). Comme le suggère l'exemple de Bitcoin mentionné précédemment, ces générateurs de nombres véritablement aléatoires constituent un facteur essentiel au bon fonctionnement des algorithmes cryptographiques.
Le support intégré pour le stockage sécurisé de clés privées et d'autres données secrètes fournit l'une des plus importantes capacités des conceptions sécurisées. D'autres caractéristiques architecturales disponibles avec ces processeurs et des processeurs similaires offrent un niveau de sécurité encore plus élevé.
En plus de toutes leurs capacités, les processeurs dotés d'accélérateurs cryptographiques intégrés et de fonctions connexes contribuent à simplifier le développement de conceptions sécurisées grâce à l'utilisation de bibliothèques d'interfaces de programmation (API) simples. Les appels de fonction API intuitifs permettent aux développeurs de faire abstraction des implémentations de sécurité, en s'appuyant sur l'API pour accéder à la fonctionnalité matérielle sous-jacente. Par exemple, les développeurs peuvent utiliser le kit d'évaluation MAX32520-KIT de Maxim Integrated pour le microcontrôleur MAX32520 en combinaison avec le kit de développement logiciel Micros (SDK) de Maxim Integrated pour créer rapidement des dispositifs IoT sécurisés. En plus des pilotes et des intergiciels associés, le SDK Micros de Maxim Integrated inclut des exemples de fonctions qui démontrent les schémas de conception de base requis pour chiffrer (AES128_ECB_enc()) et déchiffrer (AES128_ECB_dec()) les messages en utilisant le chiffrement AES (Liste 2).
Copier
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);
}
Liste 2 : Les développeurs peuvent inspecter le code d'exemple dans le pack de distribution du SDK Micros de Maxim Integrated pour apprendre les schémas de conception de base requis pour effectuer le cryptage (AES128_ECB_enc()) et le décryptage (AES128_ECB_dec()) AES en utilisant les fonctions de cryptographie intégrées du microcontrôleur MAX32520. (Source du code : Maxim Integrated)
Protocoles d'authentification
L'implémentation d'algorithmes cryptographiques robustes est particulièrement critique pour fournir une base sûre aux protocoles de plus haut niveau utilisés dans les applications. Les protocoles de plus haut niveau tels que TLS (Transport Layer Security) exécutent typiquement leurs opérations en utilisant un ensemble défini d'algorithmes cryptographiques, appelé suite de chiffrement. Dans TLS, des algorithmes tirés d'une suite de chiffrement convenue permettent de garantir l'authentification et la confidentialité des sessions de communication entre un client de dispositif IoT et un serveur hôte. TLS 1.2[8] procède dans une séquence spécifique de transactions pour négocier les paramètres, effectuer l'authentification et échanger les clés de session avant de procéder à l'échange de données (Figure 3).
Figure 3 : Le protocole de création de session TLS 1.2 utilise une variété d'algorithmes d'une suite de chiffrement convenue pour l'authentification, l'échange des clés et l'échange de données. (Source de l'image : Texas Instruments)
L'authentification est assurée en établissant l'identité du serveur (et optionnellement du client) par la vérification des certificats de sécurité, qui contiennent la clé publique respective de chaque participant. Ici, chaque participant envoie un message crypté avec sa clé privée. Comme la clé publique reçue peut uniquement décrypter un message crypté avec sa clé privée associée, chaque participant peut confirmer que le fournisseur d'un certificat est bien le propriétaire de ce certificat.
Lors de l'étape TLS suivante, les participants exécutent une série de transactions pour créer une clé de session partagée. Cette clé de session partagée est ensuite utilisée pour crypter le trafic réel des messages, garantissant ainsi la confidentialité des échanges de messages pour cette session.
De multiples options de protocole permettent aux développeurs d'affiner ce processus de création de session TLS générique, parfois au détriment de la sécurité globale. En outre, durant le processus d'échange de paramètres, les développeurs peuvent utiliser une suite de chiffrement différente en sélectionnant une combinaison appropriée d'algorithmes TLS 1.2 pris en charge pour chaque phase du protocole, y compris :
- Établissement de clé : RSA, DH, ECDH
- Authentification : RSA, DSA, ECDSA
- Chiffrement : 3DES, AES
- Authentification des messages : SHA
La dernière version de TLS, TLS 1.3[9], ajoute une sécurité supplémentaire en exécutant d'abord l'échange de clés pour mieux protéger le processus de création de session. Plus fondamentalement, TLS 1.3 se débarrasse largement de la suite de chiffrement TLS 1.2 en faveur d'algorithmes plus robustes, y compris l'utilisation des algorithmes HKDF (HMAC-based extract-and-expand Key Derivation Function) et AEAD (Authenticated Encryption with Associated Data). Les algorithmes AEAD répondent au besoin général de garantir l'authenticité, l'intégrité et la confidentialité des messages. Ces algorithmes le font en combinant le message crypté avec un code MAC qui peut être généré en série (Figure 4, à gauche), en parallèle (Figure 4, à droite), ou dans une combinaison des deux.
Figure 4 : AEAD garantit l'authentification et la confidentialité en incluant un code MAC avec le texte chiffré en utilisant, entre autres techniques, des méthodes appelées encrypt-then-MAC (à gauche) et encrypt-and-MAC (à droite) qui calculent les codes MAC en série ou en parallèle, respectivement. (Source de l'image : Wikipédia)
Renforcer la sécurité
Cette évolution des algorithmes de cryptographie et des protocoles associés suit la course continue entre les experts en cryptographie déterminés à renforcer la sécurité et ceux tout aussi déterminés à la vaincre. Par exemple, dans un effort pour renforcer la sécurité, les experts ont créé l'ECDSA comme une variante ECC de l'algorithme DSA, lui-même une variante de chiffrements antérieurs. Il en résulte que l'ECDSA peut atteindre le même niveau de sécurité que DSA, mais avec une clé beaucoup plus petite.
En cryptographie, la force de sécurité de l'algorithme est définie en termes de x bits et l'attente qu'une attaque nécessiterait environ 2x opérations pour dériver la clé privée sous-jacente à l'algorithme. En d'autres termes, différentes classes d'algorithmes peuvent nécessiter des longueurs de clé considérablement différentes pour atteindre des niveaux de sécurité comparables (Tableau 1).
Tableau 1 : Différentes classes d'algorithmes de cryptographie peuvent nécessiter des tailles de clé considérablement différentes pour les clés publiques (L) ou les clés privées (N, k, f) pour atteindre des niveaux de sécurité comparables. (Source de l'image : NIST)
Dans ce tableau du NIST, les paramètres L et N de l'algorithme FFC correspondent à la taille de la clé publique et de la clé privée, respectivement. Pour les algorithmes IFC et ECC, k et f, respectivement, correspondent à la taille de la clé. Le NIST note que les algorithmes avec une force de sécurité ≤ 80 (arrière-plan orange dans le tableau) ne sont plus approuvés pour la protection des informations gouvernementales, tandis que d'autres (arrière-plan jaune) ne sont pas encore inclus dans les normes du NIST pour des raisons d'efficacité.
Ce renforcement de la force de sécurité continue de stimuler l'évolution du chiffrement et des suites de chiffrement recommandées. Par exemple, la suite d'algorithmes CNSA (Commercial National Security Algorithm) de la NSA (National Security Agency) des États-Unis a remplacé la précédente suite B de la NSA par des recommandations pour l'utilisation de paramètres plus robustes nécessaires à la protection des informations classées top secret (Tableau 2).
Tableau 2 : La suite CNSA recommandée par la NSA inclut des algorithmes de cryptographie avec des recommandations sur les niveaux minimum de force de sécurité requis pour protéger les informations hautement sensibles. (Source de l'image : Digi-Key, d'après des données de la NSA)
Pour l'avenir, la disponibilité de capacités d'informatique quantique présentera une discontinuité dramatique dans la sécurité en général, et les algorithmes de cryptographie en particulier.
Conclusion
Les dispositifs IoT et autres conceptions connectées sont confrontés à un nombre croissant de menaces qui exigent des méthodes de sécurité de plus en plus robustes basées sur un large éventail d'algorithmes de cryptographie. Conçus pour rendre le piratage de sécurité difficile, ces algorithmes s'appuient sur une série de transformations et d'opérations mathématiques pour crypter le texte en clair en texte chiffré et décrypter le texte chiffré en texte clair. Comme démontré, il est possible d'utiliser des implémentations matérielles de ces algorithmes pour permettre aux développeurs d'intégrer plus facilement une sécurité forte dans une conception sans compromettre ses exigences principales de fonctionnalités et de performances.
Références :
Avertissement : les opinions, convictions et points de vue exprimés par les divers auteurs et/ou participants au forum sur ce site Web ne reflètent pas nécessairement ceux de DigiKey ni les politiques officielles de la société.
Suisse