Le plan de la partie : méthodes modernes de cryptographie >

Les codes d'authentification de message - MAC

Description

Les codes d'authentification de message, plus connus sous l'acronyme MAC, de l'anglais Message Authentification Code, sont des fonctions cryptographiques destinées à vérifier l'intégrité de données et à en authentifier l'origine. Ces MAC fonctionnent comme les fonctions de hachage : ils calculent à partir d'un message de longueur arbitraire un résumé de longueur fixe (on appelle ce résumé un haché). Mais, contrairement aux fonctions de hachage, ce résumé dépend aussi d'une clé secrète $K$.

Voici une application naturelle des codes d'authentification de message. Imaginons que, pour prévenir les virus, vous gardiez une version hachée de chaque fichier système sur votre ordinateur. Ainsi, si un virus modifie le fichier système, vous pourrez vous en apercevoir car les versions hachées ne coïncideront plus. Mais si le virus est un peu malin, il changera aussi la version hachée, et vous ne pourrez plus vous rendre compte de rien. Ce n'est plus possible si, au lieu de stocker une version hachée, vous stockez un code d'authenfication. En effet, ce code dépend d'une clé secrète que vous êtes le seul à connaitre. Ainsi, si le virus modifie le fichier système, il ne pourra pas calculer le code d'authentification correspondant (car il ne connait pas la clé); et vous pourrez détecter la modification!

Un code d'authentification de message est donc une fonction $h(M,K)$ où $M$ est le message et $K$ est la clé, qui renvoie un texte de longueur fixe. Il doit vérifier les propriétés suivantes :

il est très rapide de calculer $h(M,K)$;
mais si on connait des exemples de code calculés avec la même clé, disons $h(M_1,K),\dots, h(M_n,K)$, si on dispose d'un nouveau message $M$, mais pas de la clé $K$, on ne peut pas calculer $h(M,K)$.

Lors d'une communication entre individus, on utilise les codes d'authentification de message de la façon suivante. Expéditeur et destinataire commencent par se mettre d'accord sur une clé secrète, par un canal sécurisé. L'expéditeur, lorsqu'il veut envoyer un message M, calcule son MAC à l'aide de la clé secrète, et envoie conjointement le message M et son code MAC. A l'arrivée, le destinataire calcule lui aussi le MAC à l'aide de sa propre secrète, et le compare avec la version envoyée. Si les deux coïncident, il est sûr à la fois de qui lui a expédié le message et aussi que ce message n'a pas été modifié. Sinon, c'est que quelque chose ne va pas!

Comment fabriquer un code d'authentification de message?

Un des moyens classiques de fabriquer un code d'authentification de message est d'utiliser un algorithme de chiffrement par blocs, comme AES, en mode CBC (chiffrement par chainage de blocs). Rappelons comment fonctionne ce mode. On dispose d'un algorithme $C_K$ dépendant de la clé $K$ et chiffrant des blocs de $n$ bits. Le message $M$ est partagé en blocs de $k$ bits chacun, $m_1\dots m_r$. On dispose également d'un vecteur d'initialisation $c_0$. On calcule alors successivement, et par récurrence, les chiffrés $c_i=C_K(c_{i-1}\oplus m_i)$.

L'avantage de ce mode de chiffrement est que tous les blocs chiffrés dépendent du précédent. En particulier, le dernier bloc $c_r$ dépend de tout le message (et pas uniquement du dernier bloc). Ainsi, ce bloc peut servir de MAC pour le message $M$. Pour plus de sécurité (ce protocole comporte en effet une faiblesse lorsque l'on traite des concaténations de messages), on chiffre ce dernier bloc $c_r$ pour en faire le réel MAC du message. On parle alors de EMAC, pour Encrypted Mac.

Une autre façon de construire un code d'authentification de message est d'utiliser une fonction de hachage. On parle alors de HMAC. Cela peut sembler étonnant, puisqu'un code d'authentification de message doit dépendre d'une clé, alors que ce n'est pas le cas d'une fonction de hachage. D'ailleurs, il est très facile de faire le contraire, c'est-à-dire de produire une fonction de hachage à partir d'un code d'authentification de message. Il suffit d'appliquer ce dernier avec une clé fixe.

Voici donc comment procéder. On suppose donc qu'on a une fonction de hachage $H$ qui fournit un résumé de taille $l$ bits, et qui procède en interne par blocs de $B$ bits. On veut fabriquer un code d'authentification de message $m$ qui fonctionne avec une clé $K$ de moins de $B$ bits.

On commence par compléter $K$ avec des 0 de sorte qu'il fasse exactement $B$ bits.
On calcule $H\big(K\oplus \textrm{opad}\|H(K\oplus\textrm{ipad}\|m) \big)$ où $\textrm{opad}$ et $\textrm{ipad}$ sont des chaines fixes de $B$ bits et $m_1\|m_2$ désigne la concaténation des deux messages $m_1$ et $m_2$.
On tronque le résultat au $t$ bits les plus à gauche. Le résultat est $HMAC_K(m)$.

Consulter aussi