Chapitre 2:

Intégrité des messages: MACs

et Hachage cryptographique.

Par FARAOUN Kamel Mohamed

 Introduction
• Les algorithmes de chiffrement symétriques (par
flot et par blocs) permettent de garantir la
confidentialité des messages stockées/transmises:
un attaquant qui à le pouvoir d’accéder au texte
chiffré est incapable de le déchiffré !
• Par contre, ces algorithme ne garantissent pas
l’intégrité de ces messages : un attaquant qui à le
pouvoir de modifier le texte chiffré passe inaperçu !
• Face à un tel attaquant, la sécurité du chiffrement
nécessite d’être étendu :la CPA-sécurité n’est plus
suffisante, il faut prévoir des mécanisme
cryptographique permettant la protection de
l’intégrité des messages.
 Intégrité des messages
• La protection des messages contre des modification
intentionnelles illégales est atteinte en utilisant les
MACs (Messages Authentication Codes):
• Définition :
Un MAC est une paire d’algorithmes (S,V) définies sur
(K,M,T), tel que :
– S(k,m) calcule t dans T (Signature)
– V(k,m,t) donne soit « Vrai » soit « Faux » (Vérification)

k message m tag
k
Alice Bob

Generate tag: Verify tag:

?
tag  S(k, m) V(k, m, tag) = “true”
 Intégrité des messages
• Les MACs sont utilisés contre les modifications
Intentionnelles contrairement aux méthodes
classiques de vérification tel que le CRC ! . Les
MACs nécessitant l’utilisation d’une clé secrète.
message m tag
Alice Bob

Generate tag: Verify tag:

?
tag  CRC(m) V(m, tag) = “true”
• Un attaquant peut tout simplement modifier le
message et recalculer le CRC !
• Le CRC est prévue pour les modifications aléatoires
(erreurs de transmissions), pas ceux qui sont
intentionnelles .
 Sécurité Sémantique des MACs
• Afin de définir la sécurité sémantique d’un MAC, on
définie le pouvoir d’un attaquant comme suit:
1. Pour q messages m1,m2,…,mq , l’attaquant obtient
leurs tags tiS(k,mi) sans connaitre la clé k :
Attaque à messages choisies (chosen message
attack).
2. L’objectif est de construire une tag valide pour un
nouveau message (m,t) {(m1,t1),(m2,t2),…,(mq,tq)} :
Falsification existentielle (existential forgery).
• L’attaquant doit être incapable de produire une tag
valide pour un nouveau message m. Même ayant
(m,t) il ne doit pas pouvoir produire (m,t’) avec t≠t’.
 Sécurité Sémantique des MACs
• Pour un MAC I=(S,V), et un adversaire A, on définie
le jeux de la sécurité sémantique par :

m1  M m2 , …, mq
Chal. Adv.
kK t1  S(k,m1) t2 , …, tq

(m,t)
b

b=1 if V(k,m,t) = `yes’ and (m,t)  { (m1,t1) , … , (mq,tq) }

b=0 otherwise

• I=(S,V) est sémantiquement sécurisé ssi: pour tout

adversaire efficace A:
AdvMAC[A,I] =Pr[Chal. outputs 1] est négligeable.
 Sécurité Sémantique des MACs
• Exemples :
Soit I=(S,V) un MAC, on suppose qu’un attaquant
peut trouver m0≠m1 tel que S(k,m0)=S(k,m1) pour
50% des clé dans K (avec une prob. ½).
Est-ce que ce MAC est sécurisé ?

m0
Chal. Adv.
kK t0  S(k,m0) S(k,m0)=
S(k,m1)
(m1,t0)
b
b=1 avec une probabilité ½ (V(k,m1,t0) = “yes”) et (m1,t)  { (m0,t0) }
 Sécurité Sémantique des MACs
• Exemples :
Soit I=(S,V) un MAC, on suppose que la taille de la
sortie de ce MAC est égale toujours à 5 bits (la taille
de S(k,m)).
Est-ce que ce MAC est sécurisé ?

Chal. Adv.
Choisir un
messages m, et
kK (m,t) aléatoirement
choisir une tag t

b=1 avec une probabilité 1/32 (Adv=1/32 n’est pas négligable)

 Utilisation des MACs: Exemple
• Protection des fichiers sur un système
d’exploitation:
1. Les tags sont calculés lors de l’installation;
2. La clé est dérivé depuis le mot de passe user;
3. Les tags sont vérifiées après chaque boot, si un virus
modifie un fichier, la modification sera détectée !

filename filename filename

F1 F2 ⋯ Fn

t1 = S(k,F1) t2 = S(k,F2) tn = S(k,Fn)

• Si le MAC est sécurisé, le système restera saint !

(les fichiers systèmes sont intactes)
 Construction PRF  MACs
• Soit une PRF F:K x X  Y. On définie le MAC
I=(S,V) par :
– t=S(k,m)=F(k,m)
– V(k,m,t) = {« yes » si t=F(k,m); « no » sinon }

message m tag
Alice Bob

tag  F(k,m) accept m if

tag = F(k,m)
• La sortie de la PRF doit être sémantiquement
sécurisé et sa sortie suffisamment grande pour que
le MAC soit sémantiquement sécurisé.
 Construction PRF  MACs
• Théorème :
Si F est une PRF sémantiquement sécurisé, et
1/|Y| est négligeable (Y est suffisamment large),
alors le MAC IF=(S,V) définie par :
– t=S(k,m)=F(k,m)
– V(k,m,t) = {« yes » si t=F(k,m); « no » sinon }
est sémantiquement sécurisé.
En particulier, pour tout adversaire A contre IF il
existe un adversaire B contre F tel que :
AdvMAC[A, IF]  AdvPRF[B, F] + 1/|Y|
• En pratique |Y| doit être au moins 280.
 Construction PRF  MACs
• Preuve :
Si F est une PRF SS, alors elle est équivalente à
une fonction aléatoire f(m)FUNS[X,Y]. L’adversaire
contre IF doit gagner le jeux suivant :
m1  X m2 , …, mq
Chal. Adv.
t1  f(m1) f(m2) , …, f(mq)
f in
Funs[X,Y] (m,t)

« A » gagne si t=f(m) et m{m1,m2,….mq}. Puisque f

est aléatoire , l’adversaire A à une probabilité
1/|Y| de construire t valide.
Puisque F est équivalent à f, ceci tient aussi pour F.
 Construction de MACs
• En pratique, une PRF ou bien une PRP peuvent être
utilisée pour construire un MAC.
• Par exemple :
– en utilisant AES (PRP): un MAC de 16octet (128bit) pour des
messages de 16octet.
– en utilisant une fonction de hachage (SHA-1) :un MAC de
128bit pour des messages de tailles arbitraires.

• Deux constructions fiable utilisées en pratique :

1. CBC-MAC :Systèmes bancaires, ANSI X9.9, X9.19 …
2. HMAC: Protocoles internet: SSL/TLS, SSH, IPSec …..

• Chacun des deux transforme une PRF/PRP ayant

une entrée fixe en une PRF/PRP avec une entrée
arbitraire.
 ECBC-MAC
• Soit F :K x XX une PRF (soit X={0,1}128). On
définit FECBC:K2 x XLX une PRF comme suit:

m[0] m[1] m[L-2] m[L-2]

  
F(k,) F(k,) F(k,) F(k,)
CBC Raw

tag
F(k1,)

• k et k1 doivent être différents est indépendants

sinon FECBC n’est pas sémantiquement sécurisé.
 ECBC-MAC
• Pourquoi la dernière étape est indispensable pour
la sécurité sémantique de ECBC-MAC?
• Si on définie IRAW=(S,V) par S(k,m)=rawCBC(k,m),
alors IRAW peut facilement être cassée avec un seul
message choisie (attaque sur la SS):

m
Chal. Adv.
kK t  S(k,m)
(m1=m tm , t1=t )
b
b=1 avec une probabilité 1

rawCBC(k, m tm) = F(k, F(k,m)(tm) ) = F(k, t(tm) ) = t

Attaque par extension ! (Falsification existentielle)
 NMAC (Nested MAC)
• Soit F :K x X K une PRF. On définie une nouvelle
PRF FNMAC:K2 x XLK comme suit:
m[0] m[1] m[3] m[4]

k > F > F > F > F t

Cascade
t ll fpad

if |k|<|m[i]|
> F
k1
tag

• k et k1 doivent être différents est indépendants

sinon FNMAC n’est pas sémantiquement sécurisé.
 NMAC (Nested MAC)
• Pourquoi la dernière étape est indispensable pour
la sécurité sémantique de NMAC?
• Si on définie ICascase=(S,V) par S(k,m)=Cascade(k,m),
alors ICascade peut facilement être cassée avec un
seul message choisie (attaque sur la SS):

m
Chal. Adv.
kK t  S(k,m)
(m1=m w , t1=F(t,w) )
b
b=1 avec une probabilité 1

cascade(k,m w)=F(cascade(k,m),w)=F(t,w)
Attaque par extension ! (Falsification existentielle)
 Analyse de ECBC-MAC et NMAC
• Théorème :
Soit L>0, pour tout adversaire efficace A attaquant
FECBC ou FNMAP avec q messages choisies, il existe
un adversaire efficace B contre la PRP/PRF F tel
que :
AdvPRP[A, FECBC]  AdvPRP[B, F] + 2 q2 /|X|
AdvPRF[A, FNMAC]  q⋅L⋅AdvPRF[B, F] + q2 /2|K|

• CBC-MAC est sécurisé tans que q<<|X|½

• NMAC est sécurisé tans que q<<|K|½
 Analyse de ECBC-MAC et NMAC

• Exemple :
AdvPRP[A, EECBC]  AdvPRP[B, E] + 2 q2 /|X|

On suppose que le seuil choisie de négligence est de

1/232: AdvPRP[A, EECBC] 1/232  q2 /|X|  1/ 232

• AES: |X| = 2128 ⇒ q  248 :Il faut changé de clé

après la signature de 248 messages !
• 3DES : |X| = 264 ⇒ q  216 :Il faut changé de clé
après la signature de 216 messages !
 ECBC-MAC vs. NMAC

• ECBC-MAC est généralement utilisé avec AES-128:

1. Le mode de chiffrement CCM (pour le wifi 802.11i).
2. Un standard du NIST basé sur ECBC-MAC: CMAC.

• NMAC n’est en générale jamais utilisé avec une

PRP (ni AES ni 3DES) pour des raisons de
performances : la clé change à chaque bloc du
messages est nécessite donc des calcules
supplémentaires !. Il est la base du MAC le plus
utilisé sur internet :HMAC utilisant une PRF.
 Une amélioration de ECBC-MAC
: Randomized ECBC-MAC
2 blocks
m
k1
k > rawCBC t

>
rawCBC

tag
r
rand. r in X

Soit F: K × X ⟶ X une PRF. Résultat : un MAC

avec des tags dans X2. Sécurité :
AdvMAC[A, FRCBC]  AdvPRF[B, F] ⋅ (1 + 2 q2 / |X| )

⇒ pour 3DES: on peut signé jusqu’à q=232 message

avec la même clé.
 Padding dans les MACs
• Si la taille du message n’est pas multiple de la taille
n du bloc de la PRF/PRP, il faut complété le dernier
bloc. Comment ?
m[0] m[1] m[3] m[4] ???

• Une mauvaise idée : ajouter des 0..

m[0] m[1] m[3] m[4] 0000

MAC(m)=MAC(m 0s)
• Solution :il faut que m0≠m1pad(m0) ≠pad(m1)
• Solution ISO: ajouter 1000.. , et même si la taille de
m est multiple de n, ajouter un nouveau bloc 10n-1.
m[0] m[1] m[0] m[1] 100

m’[0] m’[1] m’[0] m’[1] 1000…000

 Variante de CBC-MAC :CMAC
• La clé est un triplet (k,k1,k2), k1 et k2 sont dérivés
de k:
1. Pas besoin de faire le chiffrement à la fin.
2. Pas de bloc supplémentaires si la taille du message
est multiple de n.
3. Standardisé par NIST.

m[0] m[1] ⋯ m[w] 100 m[0] m[1] ⋯ m[w]

  k1   k2

F(k,) F(k,) F(k,) F(k,) F(k,) F(k,)

tag tag
 Variante de CBC-MAC :PMAC
• CBC-MAC et NMAC sont séquentiels ! Donc lent durant
leurs exécutions.
• Une variante parallèle existe :PMAC .
m[0] m[1] m[2] m[3]
P(k,0)  P(k,1)  P(k,2)
 P(k,3) 
F(k1,) F(k1,) F(k1,)


F(k1,) tag

• P(k,i) est une fonction simple qui garantie i≠j  p(k,i) ≠

p(k,j).Le padding utilisé est celui ce CMAC.
• PMAC est incrémentale !
 Hachage cryptographique
• On nomme fonction de hachage une fonction
particulière qui, à partir d'une donnée fournie en
entrée, calcule une empreinte servant à identifier
rapidement, bien qu'incomplètement, la donnée initiale.
 Hachage cryptographique
• Une fonction de hachage cryptographique est une
fonction
H:{0,1}*{0,1}n
à sens unique résistante à la 2nd pré-image et à la
collision :
1. Résistance à la 2e pré-image : soit un message x
et son haché y correspondant, l’attaquant ne doit
pas être en mesure de trouver un message x’ ≠ x
tel que h(x’) = y, en moins de (2n) opérations.
2. Résistance aux collisions : l’attaquant ne doit pas
être en mesure de trouver deux messages
différents (x, x’) tels que h(x) = h(x’), en moins de
(2n/2) opérations (paradoxe des anniversaires).
 Hachage cryptographique
• Résistance aux collisions :
Soit H une fonction de hachage H:{0,1}* X
H est résistante à la collision si pour tout adversaire
efficace A, l’avantage définie par :
AdvCR[A,H]=Pr[A trouve une collision sur H]
est négligeable.

Exemples:
SHA-1, SHA-256, Whirlpool, ….
• Une fonction de hachage donne une sortie de taille fixe
pour une entrée de taille variable: ex. SHA256 donne un
hache de 256bit (32 octet).
 Hachage cryptographique
Exemple d’utilisation:
read-only
public space
package name package name package name
H(F2)
F1 F2 ⋯ Fn H(F1)
H(Fn)

• Après le téléchargement d’un fichier, l’utilisateur peut

vérifier sa validité en utilisant un hash publiquement
disponible.
• Si H est résistante à la collision, un attaquant ne
pourra pas modifier un fichier sans altérer le résultat
du hash,
• L’espace publique des hash doit être protéger,
sinon??..
 Hachage cryptographique
Exemple d’utilisation:
Serveur:
password ….
Bob Bob : password
:claire ……
Attaquant
Bob
 :H-1 ?? Serveur:
….
Bonjour H f3cedf44e
Bob : f3cedf44e
……

Au lieu de stocker tous les mots de passe dans le serveur 29

pour l’authentification d’utilisateurs, il vaut mieux stocker

le haché des mots de passe…. Mais!!....
MACs à base de fonct. de Hachage
• Soit I=(S,V) définie sur (K,M,T), un MAC pour des
messages de tailles fixe (M={0,1}n) (par exemple à base
de AES).
• Soit H une fonction de hachage : H:{0,1}*{0,1}n.
• On définie I*=(S*,V*) sur (K,{0,1}*,T) par :
S*(k,m)=S(k,H(m)) ; V*(k,m,t)=V(k,H(m),t)
Théorème :
Si I est un MAC sémantiquement sécurisé, et H une
fonction résistante à la collision, alors I* est un MAC
sémantiquement sécurisé.
Exemple:
S(k,m) = AES (k, SHA-256(m)) est un MAC sécurisé.
MACs à base de fonct. de Hachage
• La résistance à la collision est une condition nécessaire
pour la sécurité du MAC construit :
Si un adversaire parvient à trouver deux messages
m0m1 avec H(m0)=H(m1) alors il peut facilement brisé
la sécurité sémantique de I*:

m0
Chal. Adv.
kK t0  S*(k,m0)
(m1m0, t1=t0 )
b
b=1 avec une probabilité 1 (car H(m0)=H(m1)).
Attaque sur les fonctions de hachage:
Paradoxe de l’anniversaire
• Soit H :{0,1}*{0,1}n une fonction de Hachage.
• Il existe une attaque générique sur H de complexité
O(2n/2):
1. Choisir 2n/2 messages différents m1,m2,….,m2n/2 ;
2. Pour i=1…2n/2: calculer ti=H(mi);
3. Chercher une collision ti=tj avec ij, sinon revenir à 1.

• C’est une attaque qui marche avec une probabilité 1

pour n’importe quelle fonction de hachage !
• Pourquoi cette attaque marche-elle ?:
Théorème du Paradoxe de l’Anniversaire
Paradoxe de l’anniversaire
 Paradoxe de l’anniversaire

B=106

# samples n
 Exemples et Performances

Function digest Speed generic

size (bits) (MB/sec) attack time
MD5 128 255 264
SHA-1 160 153 280
SHA-256 256 111 2128
SHA-512 512 99 2256
Whirlpool 512 57 2256
RIPEMD-256 256 158 2128
 Construction des fonc. de hachage
• La majorité des fonctions de hachage sont construites
à base de deux éléments:
1. Une fonction de compression h: une fonction dont
la taille d’entrée et de sortie est fixe.
2. Un algorithme d’extension de domaine: un
processus (généralement itératif) utilisant la
fonction de compression h pour que la fonction de
hachage H puisse hacher des messages de taille
arbitraire.
 Construction de Merkle-Damgrad

m[0] m[1] m[2] m[3] ll PB

IV H(m)
(fixed) H0 h H1 h H2 h H3 h H4

PB: un padding selon le schéma : 1000…0 ll msg len

64 bits
Théorème :
Soit h:T x XT une fonction de compression, et H:XLT
une function de hachage à base de h et Merkle-Damgrad:
Si h est sécurisé (résistante à la collision) alors H est
sécurisé (résistante à la collision).
 Construction de la fonction de
compression « h »
• Il existe trois catégories de fonctions de
compression:
1. Ad-hoc (majorité): Très rapides mais on ne peut
avoir confiance en leur sécurité qu’après une longue
analyse….
2. Fondées sur une PRP: un peu plus lentes que les
fonctions Ad-hoc, mais avec une sécurité
conditionnellement prouvé…
3. Fondées sur un problème difficile: Très lentes, leur
sécurité repose totalement sur la difficulté de
résoudre un problème difficile (factorisation,
résolution de systèmes algébriques, etc.).
Fonctions de compression par PRP
• Soit E:K x {0,1}n{0,1}n une PRP.
• La fonction de compression de Davies-Meyer est
définie par :
h:{0,1}n x K{0,1}n
h(Hi,m)=E(m,Hi)Hi
mi
>
E ⨁
Hi

• Si E est sémantiquement sécurisé alors h est

résistante à la collision.
 Fonctions de compression par PRP
• Il existe d’autres constructions possibles :
Miyaguchi-Preneel (Whirlpool) Matyas-Meyer-Oseas
h(H, m) = E(m, H)⨁H⨁m h(H, m) = E(H, m)⨁m

• D’autres construction ne sont pas forcément sécurisées:

h(H, m) = E(m, H) : si H’=D(m’,E(m,H)) alors h(H’,m’)=h(H,m) : Collision !
h(H, m) = E(m, H)⨁m : exercice !
 Exemple: SHA-256
• Calcule des haches sur 256 bit (32 octets);
• Utilise le modèle Merkle-Damgard avec une function de
compression de Davies-Meyer.
• La PRP utilisée (chiffrement par bloc) est l’algorithme
SHACAL-2 :clé sur 512 bit et bloc sur 256bit.

512-bit block

>
SHACAL-2
256-bit block
256-bit block
 Fonctions de compression
mathématiques (problèmes difficiles)

• Choisir un nombre premier « p » sur au moins 2000 bit ,

ainsi que deux nombres aléatoires 1< u,v< p.
h:{0,…,p-1} x {0,…,p-1} {0,…,p-1}
h(H,m)= uH.vm (mod p)
• Trouvez une collision sur h revient à résoudre le
problème du logarithme discret (difficile !).
• Inconvénient : très lente (exponentiation modulaire).
 MAC par les fonctions de hachage
• A partir d’une fonction de hachage sécurisé, on veux
construire un MAC sécurisé :
Hachage: H: X≤L ⟶ T
 MAC :I=(S,V). S:K x X≤L ⟶ T et V:K x X≤L xT ⟶ {v,f}
• Une solution classique est spontané :
S(k, m) = H( k ll m)
• Cette solution n’est pas sécurisé :
avec le hache H(k ll m) il est toujours possible de
calculer H( k ll m ll PB ll w ) pour tout w : falsification
existentielle.
• Meilleurs solution: HMAC utilisent SHA-256.

S( k, m ) = H(kopad ll H( kipad ll m))

 HMAC en détails
k⨁ipad m[0] m[1] m[2] ll PB

IV >
h > h > h > h
(fixed)

k⨁opad
> tag
h > h
IV
(fixed)

• Similaire à NMAC mais avec deux clés dépendantes !.

• ipad = 0x363636...3636 et opad = 0x5c5c5c...5c5c des
constantes.
• Le modèle le plus utilisé sur internet :TLS/SSL.
 Attaques sur HMAC: Timing Attack
• Soit l’implémentation suivante d’un HMAC (en
python):

def Verify(key, msg, sig_bytes):

return HMAC(key, msg) == sig_bytes
• C’est une implémentation qui n’est pas sécurisé !:
L’opérateur d’égalité « == » entre deux tableaux d’octet
renvoi « False » dés qu’il trouve deux octets différents 
le temps d’exécution de l’instruction permet de
déterminer à quel octet commence la différence et ceci
permet une attaque sur le MAC permettant de généré
une Tag valide pour un message choisie par l’attaquant:
falsification existentielle.
 Attaques sur HMAC: Timing Attack
m , tag
target k
msg m
accept or reject

Timing attack: pour calculer une Tag valide pour un message

m faire :
Etape 1: envoyer le message avec une Tag aléatoire
commençant par 0
Etape 2: bouclé sur tout les valeurs possibles du premier
octet en interrogeant le serveur pour chaque valeur . Arrêter
quand le temps de vérification devient un peut plus long que
l’étape 1.
Etape 3: répéter la procédure pour les octets restant jusqu’a
déterminer tout les octets de la Tag
 Attaques sur HMAC: Timing Attack
• Le remède à cette attaque est que la comparaison
doit prendre le même temps quelque soit la valeur
des deux tableaux (achever la boucle de
comparaison dans tout les cas).
• La solution en python pour l’exemple :
return false if sig_bytes has wrong length
result = 0
for x, y in zip( HMAC(key,msg) , sig_bytes):
result |= ord(x) ^ ord(y)
return result == 0
• Une autre solution plus sûre :
def Verify(key, msg, sig_bytes):
mac = HMAC(key, msg)
return HMAC(key, mac) == HMAC(key, sig_bytes)
 Conclusion
• Les MACs permettent de protégé l’intégrité des
messages transmises contre un attaquant qui peut
modifier.
• Plusieurs constructions sont possibles :ECBC-
MAC, NMAC, PMAC…, d’une autre part, en
utilisant une fonction de hachage cryptographique
résistante à la collision, la construction devient
plus facile: HMAC.
• Dans un systèmes de communication sécurisé, les
deux aspects confidentialité et intégrité sont
important. Pour satisfaire les deux, il faut
combiner les algorithmes de chiffrement avec les
MACs : chiffrement authentifier.
Merci