Chapitre 1:

Chiffrement Symétrique:
par flot et par blocs.

Par FARAOUN Kamel Mohamed

 Introduction
• Les systèmes de chiffrement à clé privé (crypto-
systèmes symétrique), sont utilisés depuis déjà
plusieurs siècles. C'est l'approche la plus
authentique du chiffrement de données et
mathématiquement la moins problématique.
• Dans ce type de système, la clé servant à chiffrer
les données peut être facilement déterminée si l'on
connaît la clé servant à déchiffrer et vis-versa. Dans
la plupart des systèmes symétriques, la clé de
chiffrement est la même que la clé de
déchiffrement.
 Chiffrement symétrique
• L’échange de la clé doit se faire sur un canal
sécurisé. La sécurité repose totalement sur la
confidentialité de la clé.
KC=KD
Clé Clé
01010000111 01010000111

Texte clair Texte clair

Chiffrement Internet Déchiffrement
Voici le Voici le
numéro numéro
de ma de ma
carte de ☺☼♀☻ carte de
crédit
crédit
111111, ♠♣▼╫◊ 111111,
♫◙◘€£
¥₪Ω‫٭‬

Texte crypté
Emetteur Récepteur

3
 Chiffrement symétrique
Deux catégories existent dans le cadre du
chiffrement symétrique :

1. Chiffrement par flot (Stream ciphering):

Les données en claires sont considérées comme
un flot de bits (octets) et chiffrées ensembles….

2. Chiffrement par blocs (Block ciphering):

Les données en claire sont considérées block par
block (de taille fixe). Les blocks sont ensuite
chiffrés selon un mode opératoire spécifique
(généralement plus sécurisé que le chiffrement
par flot!)
 Chiffrement symétrique
• Pour un algorithme de chiffrement
symétrique, la clé est de taille fixe (ex. 256
bit). Les messages en claire et les messages
chiffrées sont de longueurs arbitraires.
• Ainsi on définie :

– L’ensemble K de tout les clés possibles

K={0,1}L (ex. L=256)
– L’ensemble M de tout les messages en claire
M={0,1}*
– L’ensemble C de tout les messages chiffrées
C={0,1}*
 Chiffrement symétrique
• Un algorithme de chiffrement symétrique est
définie par deux fonctions E et D (un couple
(E,D)), tel que :
E : KxMC
(k,m)C=E(k,m)=Ek(m)

D: KxC M
(k,c) M=D(k,c)=Dk(c)

mM, kK : D(k,E(k,m))=m

E : peut être aléatoire , mais D doit être

déterministe
 One Time Pad
• L’algorithme de chiffrement symétrique le plus
simple est le : OTP(One-Time-Pad). On l’appel
aussi chiffrement de Vernam (1971).
• Le message en claire est une chaine de bits
(mM={0,1}*), le message chiffré est aussi une
chaine de bits (cC=M={0,1}*).
• La clé de chiffrement n’est d’autre qu’un
message binaire arbitraire de même longueur
que le message en claire (kK=C=M={0,1}*),
avec l(k)=l(m).
 One Time Pad
• Le chiffrement : E(k,m)=km;
le déchiffrement : D(k,c)=k c.
• On peut facilement vérifier que:
D(k,c)=D(k,E(k,m))= k E(k,m)= kkm=m !
 One Time Pad
• Est-ce que le OTP est sécurisé? (Un adversaire
qui observe seulement!):
« Sécurité contre une attaque à texte chiffré
seulement :l’attaquant ne dispose que du texte
chiffré et veut déduire le texte en claire ou la
clé »
• Selon Shannon: le texte chiffré ne doit
véhiculer aucune information sur le texte en
claire. (Sécurité parfaite par rapport à la
théorie de l’information).
 Sécurité parfaite du OTP
Définition: Un crypto-système (E,D) sur (K,M,C) à
une sécurité parfaite ssi:
∀m0, m1 ∈M ( |m0| = |m1| ) et ∀c∈C
Pr[ E(k,m0)=c ] = Pr[ E(k,m1)=c ]
avec k ⟵K (choisie uniformément)

• Pour deux message m0 et m1, un attaquant qui

à le texte chiffré ne peut déterminé si c’est le
chiffrement de m0 ou bien de m1.
• Le One Time Pad possède une sécurité parfaite
(dans le sens de la THI).
 Sécurité parfaite du OTP
Preuve : (M=C=K= {0,1}L)
m,c {0,1}L, k {0,1}L : c=Ek(m)= km
 k=cm
 k est unique
Donc : |{k {0,1}L tel que c= km}|=1
(nombre de clé possibles pour un couple (c ,m))
Ainsi :
∀m∈M, ∀c∈C: Pr(Ek(m)=c)=
=|{k {0,1}l tel que c= km}|/|K|
=1/|K| (const.)
Donc : ∀m0, m1 ∈M (|m0|=|m1|):
Pr(E(k,m0)=c)= Pr(E(k,m1)=c)=1/|K|
Donc le OTP est donc parfaitement sécurisé.
 One Time Pad
• Inconvénients : Taille de clé même que celle du
message (|K||M|): c’est pas pratique. En
plus, la même clé ne doit être utilisée qu’une
seul fois (One Time !)
• La sécurité de Vernam repose sur le théorème
suivant:

Théorème: Un flux de distribution uniforme

combiné par un Xor avec un flux de
distribution quelconque produit toujours un
flux de distribution uniforme.
 One Time Pad
Preuve (pour n=1):
• P(X=0)=P(X=1)=1/2 ;
• P(Y=0)=p1 et P(y=1)=p2.
Selon la table du Xor :
Z=0 ssi: (X=0 et Y=0)
ou(X=1 et Y=1),
donc :
P(Z=0) = (P(X=0)*P(Y=0) )+(P(X=1)*P(Y=1))
=p1/2+p2/2
=(p1+p2)/2 = ½
Ainsi :
P(Z=0)=P(Z=1)= ½ , (Z est donc uniforme)
 One Time Pad
• Le OTP n’est pas du tout pratique : taille de la
clé et nombre de clés ne peuvent être pris en
charge par une application pratique surtout
dans un environnement multiutilisateur et
temps réel tel Internet.
• La solution à ce problème est d’utiliser un
Keystreams Pseudo-aléatoire : a partir d’une
information de taille fixe (une clé), une suite
pseudo aléatoire est génère et servira comme
keystream (un flot aléatoire).
 One Time Pad
Ensemble de
Keystream possibles

Ensemble de clés
possibles

Ensemble de clés
sur une taille fixe Ensemble de tout les
l ex. 128 bit 2128 Keystream possible
possibilités sur n bit : n>>l de
cardinalité 2n
 Chiffrement par flot
• Le chiffrement par flot: est une adaptation
pratique du OTP: Taille de la clé raisonnable
et utilisable !
• Malheureusement le chiffrement par flot n’est
pas parfaitement sécurisé (nombre de clés
inférieur au nombre de messages possibles).
• Pour généré des keystreams , on utilise des
PRNG (Pseudo Random Number Generators).
• A partir d’une information de taille fixe (la clé
/seed), on génère un flot de taille arbitraire
(selon la taille du message en claire).
 Chiffrement par flot
• L’algorithme de génération doit être
déterministe: la même clé génère toujours la
même séquence.
• Deux catégories de PRNG existes :
– PRNG classique: non utilisé en
cryptographie (non sécurisé);
– PRNG cryptographique :hautement sécurisé.
• Puisqu’un chiffrement par flot n’est pas
parfaitement sécurisé comme le OTP, une
autre définition de la sécurité s’impose : « La
Prédictibilité ».
 Sécurité d’un PRNG
• Un PRNG est sécurisé s’il est imprédictible !
• Définition : soit le générateur G:K{0,1}n un
générateur de séquence PRNG.
G est prédictible ssi:
 un algorithme efficace A, et  0  i  n-1, tel
que :
Adv(A,G)=P{A(G(k)[0],…G(k)[i])=G(k)[i+1]} > ½ +
avec  non négligeable (>1/230).

Théorème (Yao’82): si ∀ i ∈ {0, … , n-1}, un

PRNG G est imprédictible à la position i, alors G
est sécurisé .
 Sécurité d’un PRNG
• Généralement il n’existe pas de moyennes
formelles de test d’imprédictibilité d’un PRNG.
• En pratique, on utilise des testes statistiques
qui permettes de tester le degré de l’aléatoire
d’une séquence (keystream):
– Distribution uniforme
– Nombre de séquence répétitives
– …….
• Un teste statistique A donne en sortie 1 si la
séquence est aléatoire (selon le test) sinon 0.
 Sécurité d’un PRNG
• Les testes statistiques ne sont pas suffisants
pour prouver qu’une séquence est pseudo-
aléatoire :non différentiable (indistinguishable)
d’une séquence vraiment aléatoire.
• Pour qu’une séquence soit pseudo-aléatoire il
faut que le résultat de tout les testes
statistiques soit 0.
Pour tout teste efficace A,
Adv(A,G)=|P(A(G(k))=1)-P(A(r)=1)| < (avec 
négligeable ).
Est-ce qu’on connait tout les testes statistiques
possibles …..????
 Sécurité d’un PRNG
• Par contre, il suffit qu’un seul teste répond
par 1 pour que la séquence ne soit pas
considérée pseudo-aléatoire.
• En pratique, il existe des PRNG qui passent
avec sucées les testes statistiques connues.
Ceux-ci sont considéré comme des PRNG
cryptographiques sûres.
• D’autres PRNG sont faibles (échoues pour
certains testes ), donc ne doivent jamais être
utilisées pour des opérations de chiffrement !,
par exemples : les générateurs inclus dans les
compilateurs des différents langages de
programmation….
 Exemples de PRNG :
Congruences linéaires
• Utilisés dans la majorité
des langages de
programmation.
• Très faibles et prédictibles;
à ne pas utilisés
• Exemple : glibc random()
(faille grave dans Kerberos
V4).
• Réservé à tout autre
utilisation non
cryptographique.
 Exemples de PRNG:
Chiffrement par flot RC4 (1987)
2048bits
40bits
1 byte
seed per round
 Chiffrement par flot RC4: Exemple
réel

• Longueur du IV : 24bit ;
• Le IV est répété après chaque 224 bloc =16Mo ;
• Dans certains cartes 802.11: remise à 0 du IV
après reset !
 Exemples de PRNG:
Chiffrement par flot RC4 (1987)
• Il est largement utilisé : WEP, WPA, SSL/TLS,
Oracle SQL, ...
• Faiblesses :
1. Biais dans le premier octet en sortie : Pr[ 2nd byte = 0 ]
= 2/256
2. Probabilité d’avoir (0,0) est 1/2562 + 1/2563
3. Related key attacks……
• Actuellement n’est plus conseiller : possibilité
de reconstruire la clé complète à partir
seulement de 40000 IV différent.
• Retiré du standard TLS depuis 2015.
 Exemples de PRNG:
Chiffrement LFSR
• Exemple : registre sur 16 bits

• Cet algorithme n’est plus fiable. Une attaque

développé par Berlekamp et Massey permet de
trouver la clé à partir d’une suite finie de bits
que l’on génère.
• Améliorations: on utilise plusieurs registres
avec filtrage (Algorithme A5 utilisé par les
réseaux GSM européens).
 Exemples de PRNG:
: LFSR -CSS
• LSFR à été utilisé dans plusieurs système
(hardaware):
 Chiffrement des DVD (CSS): 2 LFSRs
 Chiffrement GSM (A5 /1,2): 3 LFSRs
 Bluetooth (E0):4 LFSRs
• Tous ces systèmes ont été cassés !
• Exemple : CSS utilise une clé de 40 bit =
5bytes
 Exemples de PRNG:
: LFSR -CSS
• On peut cassé CSS en 217 opération seulement !

20 octet

20 octet

• Pour tout les 217 valeurs possible faire:

1. Initialiser la configuration du 1ièr registre;
2. Généré 20 octet avec cette configuration;
3. Soustraire ce résultat su préfix CSS obtenu,
le résultat définie les 25 bit du deuxième
registre s’il s’agit d’une configuration
produite par un LFSR !!!.
 Exemples de PRNG:
: LFSR -Trivium

• Clé sur 80bit et IV sur 80bit. Peut générer

jusqu’à 264 bit de flot.
• Aucune attaque jusqu’à aujourd’hui!
 Exemples de PRNG: Salsa 20
nonce
Salsa20: {0,1} 128 or 256 × {0,1}64 ⟶ {0,1}n (max n = 273 bits)

Salsa20( k ; r) := H( k, (r, 0))║H( k , (r, 1))║…

τ0
k
k τ1
64 byte
r r
i h ⊕ output
i τ2 (10 rounds)
32 bytes k
τ3 64 bytes 64 bytes

h: fonction inversible. Rapide sur les CPU x86 (SSE2)

http://www.ecrypt.eu.org/stream/salsa20.html
 Attaques sur le chiffrement par
flot / OTP
• La clé ne doit jamais être utilisé deux fois :
C1  m1  PRG(k)
C2  m2  PRG(k)
On peut facilement calculer :C1C2=m1m2 .
Avec un calcul simple (a cause de la
redondance de la langue):m1m2  m1 , m2
Ex. MS-PPTP (windows NT):

k k
Attaques sur le chiffrement par
flot / OTP
• Les modifications sur le texte chiffré sont
facilement détectable :
Attaques sur le chiffrement par
flot / OTP
Le mode de chiffrement par flot est malléable !:
enc ( ⊕k )
m m⊕k
p
⊕
dec ( ⊕k )
m⊕p (m⊕k)⊕p

Les modifications sur le texte chiffré sont

indétectable et leurs résultat est facilement
prévisible !
Attaques sur le chiffrement par
flot / OTP
enc ( ⊕k ) From: Bob
From: Bob

⋯
⊕
dec ( ⊕k )
From: Eve From: Eve

Ne jamais utiliser un chiffrement par flot s’il

n’ya pas en plus un mécanisme de contrôle
d’intégrité !
 Sécurité Sémantique
• Le OTP est parfaitement sécurisé;
• Le chiffrement par flot ne l’est pas (Taille des clés);
• Nous avons besoin d’une nouvelle définition de la
sécurité plus pratique et réaliste :Sécurité
Sémantique.
• Cette notion est utilisée pour prouver la sécurité
des algorithmes/protocoles de chiffrement dans
certains conditions :
1. Le cas d’un attaquant qui observe seulement:
CPA-Security
2. Le cas d’un attaquant sui peut modifier :CCA-
Security
 Sécurité Sémantique
Soit (E,D) un crypto-système sur (K,M,C)
(E,D) est parfaitement sécurisé ssi:
∀ m0, m1 ∈ M ( |m0| = |m1| )
{ E(k,m0) } = { E(k,m1) } avec k⟵K

On peut allégé la contrainte par :

{ E(k,m0) } ≈p { E(k,m1) } (pas vraiment pratique)
Pour être plus pratique, on impose une contrainte
sur m0 et m1: ils doivent être explicitement choisies
par un adversaire:
(E,D) est sémantiquement sécurisé ssi:
Pour tout m0, m1 choisies par un adversaire
(|m0|= |m1|): { E(k,m0) }≈p { E(k,m1) } avec k⟵K
 Sécurité Sémantique (One time
key)
• L’adversaire soumis deux messages en claire m0 et
m1 au challenger.
• Le challenger choisie une clé aléatoire K et réalise
l’une des deux expériences EXP(0) ou EXP(1):
dans EXP(0) il chiffre m0 avec K et renvoi le
résultat à l’adversaire, dans EXP(1) il chiffre m1
avec K et renvoi le résultat à l’adversaire.
• L’adversaire donne en sortie une valeur (prédite)
de b qui b’{0,1} pour dire s’il à reçu le
chiffrement de m0 ou de m1: il doit être incapable
de faire la différence !
 Sécurité Sémantique (One time
key)
Pour b=0,1 on définir deux expériences EXP(0) et
EXP(1) tel que :
b
Chal. m0 , m1  M : |m0| = |m1| Adv. A
kK
c  E(k, mb)

b’  {0,1}
pour b=0,1: Wb := [ événement EXP(b)=1]

AdvSS[A,E] := | Pr[ W0 ] − Pr[ W1 ] | ∈ [0,1]

 Sécurité Sémantique (One time
key)
Définition (sécurité sémantique pour un chiffrement qui ce
fait toujours avec la même clé ):

Un crypto système E est sémantiquement sécurisé si

pour tout adversaire efficace A:

AdvSS[A,E] est négligeable (<).

Cette définition implique que pour tout m0 , m1  M

explicites :
{ E(k,m0) } ≈p { E(k,m1) }
 Exemple
• On suppose un crypto système E, pour lequel il existe
un adversaire A qui peut toujours trouver le bit de
poids faible (LSB) du texte en claire à partir seulement
du texte chiffré. On montre que E n’est pas
sémantiquement sécurisé:
b{0,1}
m0, LSB(m0)=0
Chal. Adv. B (us)
m1, LSB(m1)=1
kK
C E(k, mb) C Adv. A
(given)
LSB(mb)=b

Alors :
AdvSS[B, E] =|Pr[ EXP(0)=1 ] −Pr[ EXP(1)=1 ] |=|0 – 1|=1
 Exemple: OTP
• On montre que le OTP est sémantiquement sécurisé :

EXP(0): Chal. m0 , m1  M : |m0| = |m1| Adv. A

kK
c  k ⊕m 0 b’  {0,1}

Même distribution

Chal. m0 , m1  M : |m0| = |m1| Adv. A

EXP(1):
kK
c  k ⊕m 1 b’  {0,1}

Pour tout A:
AdvSS[A,OTP] = | Pr[ A(k⊕m0)=1 ] − Pr[ A(k⊕m1)=1 ] |= 0
 Sécurité sémantique du
chiffrement par flot
• Le chiffrement par flot est sémantiquement sécurisé si
le générateur utilisé est sécurisé (imprédictible !).

Théorème : G:K ⟶{0,1}n est un PRG sécurisé 

Le chiffrement par flot E utilisent G est sémantiquement
sécurisé.
La démonstration se fait par contraposé: il suffit de
montré que :
∀ A un adversaire sémantiquement sécurisé, ∃ un
adversaire B pour le PRG tel que :

AdvSS[A,E] ≤ 2 ∙ AdvPRG[B,G]
 Preuve par intuition
m0 , m1 m0 , m1
chal. adv. A chal. adv. A
kK c  m0 ⊕ G(k) ≈p r{0,1}n c  m0 ⊕ r

b’≟1
b’≟1
≈p
m0 , m1 m0 , m1
chal. adv. A chal. adv. A

kK c  m1 ⊕ G(k) ≈p r{0,1}n c  m1 ⊕ r

b’≟1 b’≟1
 Chiffrement par blocs
• Un message est décomposer en blocs avant
d’être chiffré. Les blocs obtenus sont
rassemblés pour construire le message chiffré.

n bits n bits
PT Block E, D CT Block

Key k bits

Examples:
3DES: n= 64 bits, k = 168 bits
AES: n=128 bits, k = 128, 192, 256 bits
 Réseaux de Feistel
• Un réseau de Feistel est une construction utilisée dans
les algorithmes de chiffrement par bloc, nommée d'après
le cryptologue d'IBM, Horst Feistel. Elle a été utilisée
pour la première fois dans Lucifer et DES.
• Avantages:
1. Le chiffrement et le déchiffrement ont une architecture
similaire voire identique dans certains cas.
2. L'implémentation matérielle est aussi plus facile avec un
tel système.

Avec des fonctions qui ne sont inversible :

f1, …, fd: {0,1}n ⟶ {0,1}n,

Construire une fonction inversible :

F: {0,1}2n ⟶ {0,1}2n
n-bits
Réseaux de Feistel
R0 R1 R2 Rd-1 Rd
f1 f2
⋯ fd
n-bits

L0 ⊕ L1 ⊕ L2 Ld-1 ⊕ Ld
input output

Li-1 Ri-1
Li=Ri-1
fi
⊕

Ri= Li-1f(Ri-1,Ki)
Li Ri

Le chiffrement se fait selon la séquence:

L0R0L1R1……………….. LnRn
 Réseaux de Feistel
Pour tout ensemble de fonctions
f1, …, fd: {0,1}n ⟶ {0,1}n
Le réseaux de Feistel définie par
F: {0,1}2n ⟶ {0,1}2n est inversible

Preuve: construction de l’inverse:

Ri ⊕ Ri-1
Ri-1 Ri inverse
fi
fi
Li-1 ⊕ Li Li Li-1

Dans le cadre d’un algorithme de chiffrement, la clé est

un paramètre de chaque fonction fi. (une sous-clé).
 Réseaux de Feistel
• La taille de chaque Bloc Li et Ri est généralement de
32 bits dans le standard (32+32=64 bits)
• La taille de chaque clé Ki et de 48 bits; les clés Ki
sont extraites de la clé initiale K de taille 64 bits.
• Les schémas de Feistel ont été largement analysés et
examinés par les experts. Plusieurs attaques sont
possibles mais les deux principales sont : la
cryptanalyse linéaire et la cryptanalyse différentielle.
• Ces méthodes ont fait leur preuve sur DES et sur
d'autres algorithmes. Mais cela ne signifie pas que
l'utilisation d'un réseau de Feistel va obligatoirement
entraîner des vulnérabilités significatives.
 PRF et PRP
• Les structures de Feistel sont théoriquement basées
sur deux notions importantes :
1. Les fonctions pseudo-aléatoires: PRF (Pseudo-
random functions).
2. Les permutations pseudo-aléatoires: PRP (Pseudo-
random permutations).

• Une PRF est définie sur (K,X,Y):

F: K  X  Y
tel qu’il existe un algorithme efficace pour le calcule
de F(k,x), son inversion n’est pas nécessairement
possible.
 PRF et PRP
• Une PRP est définie sur (K,X):
E: K  X  X
tel que :
1. Il exist un algorithme déterministe pour l’évaluation de
E(k,x)
2. La fonction E( k,  ) est un-à-un (bijective)
3. Il existe un algorithme efficace d’inversion D(k,y)
Contrairement à une PRF, une PRP doit
obligatoirement être inversible (Une PRP est une
PRF mais pas l’inverse)
 Sécurité des PRF
• Une PRF est sécurisé, si ça sortie ne peut être
distinguer de celle d’une fonction aléatoire:
b

Chal. b=0: kK, f F(k,) Adv. A

b=1: fFuns[X,Y] x1  X , x2 , …, xq
f
f(x1) , f(x2), …, f(xq)

b’  {0,1}
EXP(b)
• Déf: F est une PRF sécurisé si pour tout algorithme
“efficace ” A:
AdvPRF[A,F] = |Pr[EXP(0)=1] – Pr[EXP(1)=1] |est
négligeable
 Sécurité des PRP
• Une PRP est sécurisé, si ça sortie ne peut être
discriminer de celle d’une permutation aléatoire:
b

Chal. b=0: kK, f E(k,) Adv. A

b=1: fPerms[X] x1  X , x2, …, xq
f
f(x1) , f(x2), …, f(xq)

b’  {0,1}
• Déf: F est une PRP sécurisé si pour tout algorithme
“efficace ” A:
AdvPRP[A,F] = |Pr[EXP(0)=1] – Pr[EXP(1)=1] |est
négligeable
 PRF et PRP
• Un algorithme de chiffrement par bloc n’est rein
d’autre qu’une PRP:
– AES : une PRP sur ({0,1}128,{0,1}128) vers {0,1}128
– DES :une PRP sur ({0,1}56,{0,1}64) vers {0,1}64
– 3DES: une PRP sur ({0,1}112,{0,1}64) vers {0,1}64
• Une PRF n’est pas inversible, elle ne peut être
utilisée directement pour le chiffrement, mais elle
peut l’être en utilisant deux constructions :
– Les réseaux de Feistel
– Le mode opératoire CTR (a voir plus loin)
 PRF dans les réseaux de Feistel
Théorème: (Luby-Rackoff ‘85):
Soit f: K × {0,1}n ⟶ {0,1}n une PRF sécurisé,
alors avec 3 round Feistel on obtient:
F: K3 × {0,1}2n ⟶ {0,1}2n une PRP sécurisé

R0 R1 R2 R3
f f f
L0 ⊕ L1 ⊕ L2 ⊕ L3

input output
 Exemple d’une PRP:DES
• DES est l’un des premiers algorithmes de
chiffrement par bloc.
• L’information à chiffrer est à découper en blocs de
tailles identiques (64bit dans le standard).
• Les blocs sont chiffrés les uns après les autres en
utilisant la même clé.
• La clé de DES est sur 64 bits dont 8 servent à
vérifier l’intégrité de la clé: 56bit utilisés
réellement.
• Le principe de fonctionnement de DES est basé
sur le mécanisme des Réseaux de Feistel.
• La version standard du DES utilise un réseau de
Feistel de 16 rounds pour le cryptage et le
décryptage.
 Exemple d’une PRP:DES
• L’algorithme DES agit en trois étapes :
1. Les 64 bits m en entrée sont transformés selon
une permutation fixe pour obtenir m0=IP(m), m0
est ensuite divisé en deux parties L et R de taille
32 bits chacune tel que m0=L0R0
2. Pour i=1..16 faire : Li=Ri-1 et Ri= Li-1f(Ri-1,Ki)
3. Inverser le résultat final m16=L16R16 pour obtenir
R16L16, ensuite la permutation initiale est
appliquée dans le sens inverse pour obtenir C=IP-
1(R L )
16 16
Exemple d’une PRP:DES
Plaintext

IP

L0 R0
K1
f

L1 R1




L16 R16

IP-1

Ciphertext
 Exemple d’une PRP:DES

Transformed
Key Ki

Permutations
Ri-1 and substitution XOR Ri
f

Li-1 Li

Les étapes d’un tour de chiffrement

 Exemple d’une PRP:DES
Ri-1

Expander

E(Ri-1)
Ki
Blocs de 6
bits
B1 B2 B3 B4 B5 B6 B7 B8

S1 S2 S3 S4 S5 S6 S7 S8 S-Boxes

C1 C2 C3 C4 C5 C6 C7 C8
Blocs de 4
Permutation bits

f(Ri-1, Ki)
 Exemple d’une PRP:3DES
• DES présente quelques faiblesses : Taille des clefs :
56 bits  Vulnérabilité devant la recherche
exhaustive.
• Une des solution est d’utilisé 3DES:
• Enchaînant 3 applications successives de l'algorithme
DES sur le même bloc de données de 64 bits, avec 2
ou 3 clés DES différentes. Plusieurs approches
permettent de combiner DES 3 fois.
• La version adoptée (de Tuchman) utilise un
chiffrement, suivi d'un déchiffrement pour se conclure
à nouveau par un chiffrement (mode EDE :Encryption-
Decryption-Encryption).
 Exemple d’une PRP:3DES

• Le 3DES est: Plus sécurisé mais trois fois plus lent.

La taille des blocs est limitée à 64 bits Nécessité
de trouver un remplaçant .
 Une autre solution pour DES:
DESX
• Une construction plus optimale permet de rendre
DES plus sécurisé avec les même performances
(même temps de calcule), il s’agit de DESX.
• Proposé par Ron Rivest en 1984.
DESXK(M)=K1EK2(M K3) avec K=K1||K2||K3.
• Taille de la clé =64+56+64=184 bit !
• Meilleur attaque connue de l’ordre de 264+256=2120.
• Sachez que K1 EK2(M) et EK2(M K1) ont un
niveau de sécurité exactement égale à EK2(M) !!!!
• Cette approche peut être utilisé avec tout PRP:
construction d’Evan-Mansour.
 Exemple d’une PRP:AES
k1 k2 kn
S1 S1 S1
S2 S2 S2
S3 S3 S3

output
input

⨁
⋯
⨁
⨁

⋯
⋯
⋯

S8 S8 S8
subs. perm.
layer layer inversion

• Tailles de clés: 128, 192, 256 bits. Taille de blocks : 128 bits
• Standard depuis l’an 2000, d’origines Belges (Rijndael)
 Exemple d’une PRP:AES
10 rounds

4
(1) ByteSub (1) ByteSub (1) ByteSub
⋯ (2) ShiftRow

⨁
⨁
(2) ShiftRow
⨁

4 input (2) ShiftRow

(3) MixColumn (3) MixColumn

invertible
k0 k1 k2 k9

⨁
k10
key key expansion:
4 output
16 bytes 16 bytes ⟶176 bytes 4

ByteSub: une S-Box pour un octet (Table de 256 octet). Il

s’agit simplement de l’inverse modulaire dans le corps de Galois,
 Exemple d’une PRP:AES
• ShiftRows:

• MixColumns:

Meilleur attaque connue sur AES256(Bogdanov et

Khovratovich): de l’ordre de 2254 !!!
 Modes opératoires
• Les standard connues tel AES,3DES,CAST… sont
suffisamment sécurisé comme PRP, il n’est pas
nécessaire (à ce stade) de se préoccuper de leurs
fonctionnement interne!
• L’essentiel par contre est de savoir les utilisés d’une
manière correcte et sécurisé !
• L’objectif : construire des crypto-système sécurisé
pour des données de tailles arbitraires en utilisant
des PRP sécurisés.
• Dans la suite on considère (pour l’instant!) que
l’attaquant n’a accès qu’au texte chiffré, et que la clé
n’est utilisée qu’une seul fois !
• L’attaquant cherche à cassé la sécurité sémantique
du crypto-système.
 Modes opératoires: ECB (OTK)
• La plus mauvaise manière d’utiliser une PRP:
Electronic Code Book (ECB) mode.

m1 m2 m3

c1 c2 c3

si mi=mj alors ci=cj

 Modes opératoires: ECB (OTK)
• Image « Cervin » chiffrée (AES-256 mode ECB)!

Originale avec ECB Autre mode

 Modes opératoires: ECB (OTK)
• Le mode ECB n’est pas sémantiquement sécurisé !

AdvSS[A, ECB] =
|Pr[ EXP(0)=1 ] −Pr[ EXP(1)=1 ] |=1
 Modes opératoires: CTR (OTK)
• Un meilleur mode :le mode CTR déterministe. Utilise
une PRF (ou PRP) pour simuler un chiffrement par
flot!: F : K x {0,1}n{0,1}n

• Le mode CTR déterministe est sémantiquement

sécurisé (Emulation d’un chiffrement par flot en
utilisant une PRP),
 Modes opératoires: CTR (OTK)
• Théorème (ROGAWAY’89):
Pour tout valeur entière L>0, si F est une PRF
sécurisé sur (K,X,X), alors Edetctr est
sémantiquement sécurisé sur (K,XL,XL).
En particulier, pour tout adversaire A contre Edetctr,
il existe un adversaire efficace B contre la PRF F tel
que:
AdvSS[A,Edeter]=2*AdvPRF[B,F]

Négligeable  Négligeable
Preuve par intuition
Utiliser la clé plusieurs fois (MTK)

• Si la même clé est utiliser plusieurs fois, un

attaquant peut accéder à plusieurs texte chiffré avec
la même clé !: la définition de la sécurité sémantique
doit changée.
• Dans ce cas on considère que :
1. L’attaquant peut soumettre plusieurs texte en
claire et obtenir leurs version chiffré (Choosen-
Plaintext-Attack CPA)
2. L’attaquant veut casser la sécurité sémantique
du crypto-système.
Utiliser la clé plusieurs fois (MTK)
Utiliser la clé plusieurs fois (MTK)
Pour b=0,1 on définit deux expériences EXP(0) et EXP(1)
tel que :

Si l’adversaire veut le chiffrement de m, il peut soumettre

m=mi,0=mi,1.
Un crypto-système (E,D) est sémantiquement CPA-Secure
si pour tout adversaire A:
AdvCPA[A,E] := | Pr[ EXP(0)=1 ] − Pr[ EXP(1)=1 ] |
est négligeable.
Utiliser la clé plusieurs fois (MTK)
• Si la même clé est toujours utilisée, un attaquant
peut toujours casser la sécurité sémantique !:

• L’attaquant peut savoir si deux fichiers, deux

paquets ou deux enregistrements chiffrées sont
identiques.
• En pratique, ceci peut conduire à des attaques
significatives !, surtout quand la taille du message
M est relativement petite.
 Solution 1: Chiffrement Probabiliste
Randomized Encryption
• L’algorithme de chiffrement E(k,m) doit être une
fonction aléatoire (initialement proposé par Chafi
Goldwasser):

• Le même message chiffré deux fois donnera un message

chiffrer différent :la taille du message chiffré est
obligatoirement supérieur à celle du message en claire.
|Ci|=|mi|+#random_bits
 Exemple :Randomized Encryption

• Soit F :K x RM une PRF sémantiquement

sécurisé.
• Pour un message mM, on définie E(k,m) par:
E(k,m)={rR; C=(r , F(k,r)m)}
Est-ce que E est CPA-Sémantiquement sécurisé ?
• Oui mais seulement si R est suffisamment grande
pour que r ne ce répète jamais ! Sinon un
attaquant parviendra toujours à brisé la sécurité
sémantique.
Exemple :Randomized Encryption
m0 , m0  M
Chal. Adv. A
c0  r0,F(k,r0) ⊕ m0
b kK
m0 , m0  M
ri{0,1}n
c1  r1,F(k,r1) ⊕ m0
ri F(k,ri)
r0 F(k,r1)
r1 F(k,r2)
m0 , m0  M r2 F(k,r3)
… …
cn  rn,F(k,rn) ⊕ m0 rn F(k,rn)

m0 , m1  M
• Chercher F(k,ri)
cb  ri,F(k,ri) ⊕ mb • Déchiffré Cb en mb
• Output 0 si mb=m0
 Solution 2: nonce-based
Encryption

• Nonce : number used once. Une valeur qui change

d’un message à un autre. Généralement il s’agit
d’un compteur.
• Si les deux parties sont synchroniser, pas besoin
de transmettre la valeur de n.
• La valeur de n ne doit jamais être réutilisée.
Sécurité sémantique: nonce-based
Encryption

Un crypto-système (E,D) utilisant les nonces est

sémantiquement CPA-Secure si pour tout adversaire A:
AdvCPA[A,E] := | Pr[ EXP(0)=1 ] − Pr[ EXP(1)=1 ] |
est négligeable.
 Exemple :nonce-based Encryption
• Soit F :K x RM une PRF sécurisé. Soit r un
compteur initialisé à 0. Alors le schéma de
chiffrement définie par :
mM , E(k,m)={r++, C=(r,E(k,r)m)}
Est CPA-sémantiquement sécurisé, à condition que r
ne soit jamais réutilisé!
• Le chiffrement basé sur les nonce est utilisée quand
les deux parties sont « synchrones » (ex. le protocole
https, l’ordre des messages est le même des deux
cotées).
• Par contre le chiffrement aléatoires est utilisée quand
les deux sont «asynchrones» (ex. le protocole IPsec,
l’ordre des paquets n’est pas le même)
 Modes opératoires: CBC (MTK)
• Soit (E,D) une PRP sémantiquement sécurisé. On
définie le mode opératoire CBC par ECBC(k,m), le
vecteur IV est choisie aléatoirement!
E: K x {0,1}n{0,1}n, IV{0,1}n
 Modes opératoires: CBC (MTK)
• Si c[0]=E(k,IVm[0]) alors : m[0]=IVD(k,c[0])

• Le vecteur IV est transmis en claire avec le message

chiffré  la taille du message chiffré augment.
• Un IV n’est jamais réutilisé, et ne doit même pas être
prédictible !
 Sécurité sémantique du CBC
Théorème (Bellar,Rogaway’11):
Pour tout valeur L>0, si E est une PRP sémantiquement
sécurisé sur (K,X,X), alors ECBC est CPA-sémantiquement
sécurisé sur (K,XL,XL+1).
En particulier, pour un adversaire A contre ECBC qui
soumis q requêtes il existe un adversaire B contre la
PRP E tel que:
AdvCPA[A,ECBC]2*AdvPRP[B,E]+(2*q2L2)/|X|
CBC est sémantiquement sécurisé tans que q2L2<<|X|
 Sécurité sémantique du CBC
AdvCPA[a,ECBC]2*AdvPRP[B,E]+(2*q2L2)/|X|
q : le nombre de messages chiffrés avec la même clé k
L : la longueur maximale d’un message (nombre de blocs)
On suppose que le seuil de sécurité désiré soit de 1/232:
AdvCPA[A,ECBC] ≤1/232  q2L2/|X| ≤1/232

• Pour AES: |X|=2128  q L ≤ 248 , donc la clé doit

changé après le chiffrement de 248 bloc (16384 To).
• Pour 3DES: |X|=264  q L ≤ 216 une condition plus
stricte (216 bloc= 512Ko seulement !!!)
 Sécurité sémantique du CBC
• Si le IV est prédictible, CBC ne grarantie aucune
sécurité sémantique !!!
• Prédictible :on peut prédire le prochain IV.
• Preuve:
On suppose qu’ayant c=ECBC(k,m), un attaquant peut
prédire le prochain IV:

• Exemple: un bug dans SSL/TLS v1.0: le IV du

prochain N° i enregistrement est le dernier bloc chiffré
de l’enregistrement N° i-1. (BEAST Attack)
 CBC avec « nonce »
• Quand le mode CBC est utiliser avec une « nonce » (le
cas d’une communication synchrone), certains
mesures de sécurité supplémentaires doivent être
prises :

• k1 doit être différente de k, sinon le mode n’est plus

sémantiquement sécurisé.
 m1,0

m0,0=m0,1
EXP(0)

m1,1

EXP(1)
Problème technique: CBC et padding

• Un bourrage (padding) est ajouter quand la taille du

dernier bloc n’est pas conforme (taille de la PRP).
• Un padding de n octets est un bloc (ajouté
même si la taille est conforme !).
• Une grande source de vulnérabilités : « Padding Oracle
Attack » contre SSL/TLS v 1.0 (attaque active).
 Modes opératoires: CTR (MTK)
• Soit F une PRF sémantiquement sécurisé. On définie le
mode opératoire CTR par ECTR(k,m), le vecteur IV est
choisie aléatoirement!
F: K x {0,1}n{0,1}n, IV{0,1}n

• Une émulation du chiffrement par flot !

• Avantages: parallélisable; déchiffrement sélective; pas
besoin de faire un padding !
 Sécurité sémantique du CTR
Théorème (Bellar,Rogaway’11):
Pour tout valeur L>0, si F est une PRF sémantiquement
sécurisé sur (K,X,X), alors ECTR est CPA-sémantiquement
sécurisé sur (K,XL,XL+1).
En particulier, pour un adversaire A contre ECTR qui
soumis q requêtes il existe un adversaire B contre la
PRF F tel que:
AdvCPA[A,ECTR]2*AdvPRP[B,F]+(2*q2L)/|X|
CTR est sémantiquement sécurisé tans que q2L<<|X|
il est meilleur que CBC!
 Sécurité sémantique du CTR
AdvCPA[A,ECTR]2*AdvPRP[B,F]+(2*q2L)/|X|
q : le nombre de messages chiffrés avec la même clé k
L : la longueur maximale d’un message (nombre de blocs)
On suppose que le seuil de sécurité désiré soit de 1/232:
AdvCPA[A,ECTR] ≤1/232  q2L/|X| ≤1/232

• Pour AES: |X|=2128  q L1/2 ≤ 248 , donc la clé doit

changé après le chiffrement de 264 bloc (16777216 To).
• Pour 3DES: |X|=264  q L1/2 ≤ 216 une condition plus
stricte (220 bloc= 8Mo seulement !!!)
Modes opératoires: CFB et OFB
• Des variantes de CTR
• Sémantiquement sécurisés (Sung & Lee 2001)
• Ne permettent pas l’accès aléatoire !!
• OFB est protéger par un brevet (US 20050160279 A1).

CFB

OFB
 Conclusion
• Les PRF et les PRP sont de meilleurs abstractions pour
modéliser le chiffrement par bloc.
• La sécurité sémantique diffère entre le cas de l’usage de
la clé une seul fois, et le cas d’usage multiple. Dans ce
dernier, deux solutions sont envisageable : chiffrement
aléatoire (en utilisant un IV), et chiffrement par nonce.
• Dans les deux cas, le mode doit être choisie
attentivement pour assuré la sécurité sémantique.
• Le mode CTR est le plus sécurisé et le plus pratique !
• Malheureusement, tout ces modes n’assurant pas la
sécurité contre un attaquant qui peut modifier (Temper)
« aucune assurance sur l’intégrité des données ».
• Il est donc nécessaire de prévoir d’autres outils
cryptographique et d’autres modes de chiffrement avec
une nouvelle définition de la sécurité sémantique…..
Merci