Advanced Encryption Standard

Pour les articles homonymes, voir AES.

Cet article sur l'informatique doit être recyclé (juin 2011).

Une réorganisation et une clarification du contenu paraissent nécessaires. Améliorez-le, discutez des points à améliorer ou précisez les sections à recycler en utilisant {{section à recycler}}.

AES

Résumé

Concepteur(s)	Joan Daemen, Vincent Rijmen
Première publication	2000
Dérivé de	Rijndael, Square
Chiffrement(s) dérivé(s)	Aucun

Caractéristiques

Taille(s) du bloc	128 bits
Longueur(s) de la clé	128, 192, 256 bits
Structure	Réseau de substitution-permutation
Nombre de tours	10,12 ou 14 selon la taille de la clé

Meilleure cryptanalyse

Une attaque par clé apparentée casse 9 tours de AES-256.

Une attaque par texte clair choisi casse 8 tours de AES-192 et 256, ou 7 tours de AES-128 (Ferguson et al, 2000).

modifier - modifier le code - voir Wikidata (aide)

Advanced Encryption Standard ou AES (litt. « norme de chiffrement avancé »), aussi connu sous le nom de Rijndael, est un algorithme de chiffrement symétrique. Il remporta en octobre 2000 le concours AES, lancé en 1997 par le NIST et devint le nouveau standard de chiffrement pour les organisations du gouvernement des États-Unis. Il a été approuvé par la NSA (National Security Agency) dans sa suite B des algorithmes cryptographiques (en)^[1].

Le système cryptographique AES est très fréquemment associé à la sécurisation de l'affichage des pages web ou des échanges de mails à travers l'usage de TLS. Son utilisation est extrêmement répandue^[2].

Origine

Il est issu d'un appel international à candidatures lancé en janvier 1997 et ayant reçu 15 propositions. Parmi ces 15 algorithmes, 5 furent choisis pour une évaluation plus poussée en avril 1999 : MARS, RC6, Rijndael, Serpent, et Twofish. A l'issue du processus de sélection, ce fut le candidat Rijndael - du nom de ses deux concepteurs Joan Daemen et Vincent Rijmen (tous les deux de nationalité belge) - qui a été choisi^[3]. Ces deux experts en cryptographie étaient déjà les auteurs d'un autre algorithme : Square. AES est un sous-ensemble de Rijndael : il ne travaille qu'avec des blocs de 128 bits alors que Rijndael offre des tailles de blocs et de clefs qui sont des multiples de 32 (compris entre 128 et 256 bits).

Ce faisant, l'AES remplace le DES (choisi comme standard dans les années 1970) devenu obsolète car il utilise une clef de 56 bits ; ce qui n'est plus assez robuste. L'AES a été adopté par le NIST (National Institute of Standards and Technology) en 2001^[4]. Conformément aux prérequis du concours, son utilisation ne nécessite que peu de mémoire sa complexité est réduite, il existe des implémentations efficaces tant logicielle que matérielle. Contrairement à son prédécesseur, le DES, et à certains de ses coucurrents pour le concours du NIST, l'AES est un réseau de substitution-permutation simple, qui n'utilise pas de schéma de Feistel.

Fonctionnement

L'algorithme prend en entrée un bloc de 128 bits (16 octets), la clé fait 128, 192 ou 256 bits. Les 16 octets en entrée sont permutés selon une table définie au préalable. Ces octets sont ensuite placés dans une matrice de 4x4 éléments et ses lignes subissent une rotation vers la droite. L'incrément pour la rotation varie selon le numéro de la ligne. Une transformation linéaire est ensuite appliquée sur la matrice, elle consiste en la multiplication binaire de chaque élément de la matrice avec des polynômes issus d'une matrice auxiliaire, cette multiplication est soumise à des règles spéciales selon GF(2⁸) (groupe de Galois ou corps fini). La transformation linéaire garantit une meilleure diffusion (propagation des bits dans la structure) sur plusieurs tours.

Finalement, un OU exclusif (XOR) entre la matrice et une autre matrice permet d'obtenir une matrice intermédiaire. Ces différentes opérations sont répétées plusieurs fois et définissent un « tour ». Pour une clé de 128, 192 ou 256, AES nécessite respectivement 10, 12 ou 14 tours.

procedure Rijndael(State,Cipherkey)
    KeyExpansion(CipherKey,ExpandedKey)
    AddRoundKey(State,ExpandedKey[0])
    for i = 1 to Nr − 1 do
        Round(State,ExpandedKey[i])
    end for
    FinalRound(State,ExpandedKey[Nr])
end procedure

procedure Round(State,ExpandedKey[i])
    SubBytes(State);
    ShiftRows(State);
    MixColumns(State);
    AddRoundKey(State,ExpandedKey[i]);
end procedure
procedure FinalRound(State,ExpandedKey[Nr])
    SubBytes(State);
    ShiftRows(State);
    AddRoundKey(State,ExpandedKey[Nr]);
end procedure

Chiffrement

L'AES est un algorithme de chiffrement symétrique, et c'est un chiffrement par blocs. Il chiffre un message de 128 bits pour produire un chiffré de 128 bits également. La clé utilisée peut varier en taille : elle peut être de 128 bits, 192 bits ou 256 bits. La représentation du message bloqué se fait sous la forme d'un tableau 4x4, soit 16 cases, chacune représentant un octet, pour un total de 128 bits. Le chiffrement AES est constitué de plusieurs tours. Ce nombre de tours varie selon la taille de la clé initiale : pour une clé de 128 bits, le nombre de tours est de 10 ; pour une clé de 192 bits, il est de 12 tours ; et pour une clé de 256 bits, il est de 14 tours.

Pour chaque tour, une clé sera générée à partir de la clé initiale en utilisant un algorithme d'expansion de clé. Ces clés sont appelées round keys, et chacune est de taille 128 bits, quelle que soit la taille de la clé initiale.

Chaque tour est divisé en 4 étapes : substitution des octets, shift rows, mix columns et add round key, sauf pour le dernier tour, qui n'inclut pas l'étape mix columns.

Substitution des octets

Chaque octet dans le message représenté par un bloc 4x4 sera remplacé par un autre octet en utilisant une table de substitution 16x16 (boite S)

---

Shift rows

Pour la première ligne, il n'y a pas de changements. Pour la deuxième ligne, les éléments sont décalés chacun d'un pas vers la gauche, pour la troisième ligne, de 2 pas vers la gauche, et pour la quatrième ligne, de 3 pas vers la gauche.

---

Mix columns

Chaque colonne sera multipliée par la matrice 4x4 fixe suivante :

---

---

Add round key

Le message en bloc sera XORé avec la round key.

La round key est formée de 4 mots, et chaque mot sera XORé avec une colonne du message.

---

Algorithme d'expansion des clés

Division de la clé initiale

La clé initiale (128, 192 ou 256 bits) est divisée en mots, chacun contenant 4 octets :

AES-128 : 16 octets (4 mots).

AES-192 : 24 octets (6 mots).

AES-256 : 32 octets (8 mots).

Exemple avec une clé AES-128 (128 bits) : 2b7e151628aed2a6abf7158809cf4f3c

W0 =2b7e1516

W1 =28aed2a6

W2 =abf71588

W3 =09cf4f3c

Nombre de mots pour la clé étendue

Le nombre de mots nécessaires pour la clé étendue est donné par :

Nb de mots = 4 × (Nb de tours + 1) Le facteur 4 correspond au nombre de mots de 4 octets d'un bloc (128 bits).

AES ne traite que des blocs de 128 bits, donc il y a 4 mots par bloc.

Ainsi :

Pour AES-128, on a besoin de 44 mots.

Pour AES-192, on a besoin de 52 mots.

Pour AES-256, on a besoin de 60 mots.

Calcul des mots pour les clés de ronde

La clé de ronde suivante est composée des mots

W4 ,W5 ,W6 ,W7 .

W4=W0⊕core(W3)

W5=W4⊕W1

W6=W5⊕W2

W7=W6⊕W3

Note : La fonction core applique des transformations spécifiques (substitution et rotation) à un mot.

On répète ce processus jusqu'à obtenir tous les mots nécessaires pour générer les clés de toutes les rondes.

---

Déchiffrement

Dans le déchiffrement, on applique le même mécanisme que lors du chiffrement, mais dans l'ordre inverse. Cela signifie : AddRoundKey en premier.

Pour chaque tour :

• Inverse ShiftRows (décalage inverse des lignes).
• Inverse SubBytes (substitution inverse des octets).
• AddRoundKey.
• Inverse MixColumns (sauf lors du dernier tour).

Lors du dernier tour, l'étape Inverse MixColumns est omise, et le déchiffrement se termine avec AddRoundKey.

Attaques sur le système cryptographique AES

L'AES n'a pour l'instant pas été cassé, même théoriquement, au sens où il n'existe pas d'attaque significativement plus efficace que la recherche exhaustive quand le chiffrement est correctement utilisé. Le système AES est largement considéré comme l'un des algorithmes de chiffrement les plus sécurisés disponibles. Cependant, comme tout système cryptographique, il est constamment soumis à des analyses et des attaques pour tester sa robustesse.

Il est important de noter que, malgré ces attaques, l'AES reste un algorithme très robuste. Il est largement utilisé dans de nombreuses applications sécurisées. Les attaques mentionnées sont souvent théoriques ou nécessitent des conditions très spécifiques pour être réalisées avec succès.

Rijndael a été conçu de façon à résister aux méthodes classiques en particulier la cryptanalyse linéaire et la cryptanalyse différentielle. Le nombre de tours de l'AES est calculé en fonction de la taille de la clef pour que chacune de ces deux attaques (linéaire et différentielle) ne soit pas plus efficace qu'une attaque par force brute.

Performances

Lors de la sélection d'un nouveau standard de chiffrement, le NIST a évalué les performances de nombreux algorithmes^[19],[20].

Une étude comparative détaillée a été conduite concernant les performances des candidats à l'AES sur diverses plateformes, notamment les CPU 32 bits, 64 bits, les cartes à puce 8 bits et le matériel dédié. Les algorithmes ont été évalués en termes de vitesse de chiffrement, de temps de configuration des clés, de consommation de RAM et de ROM, ainsi que de leur capacité à être parallélisés et utilisés comme fonctions de hachage. Choisir un seul algorithme pour toutes les applications a été difficile pour répondre au besoin de standardisation. L'AES tel que connu aujourd'hui, dérivé de Rijndael, a été retenu parmi les candidats au regard de ses performances et de son coût d'implémentation^[19].

Les instructions AES d'Intel offrent des performances significativement améliorées pour le chiffrement et le déchiffrement des données par rapport aux implémentations logicielles traditionnelles basées sur des tables de recherche. Ces instructions permettent une exécution en temps indépendant des données et sans utilisation de tables, ce qui aide à éliminer les principales attaques par chronométrage et basées sur le cache qui menacent les implémentations logicielles d'AES. De plus, elles simplifient la mise en œuvre d'AES avec une taille de code réduite, diminuant ainsi le risque d'introduction accidentelle de failles de sécurité, comme les fuites par canaux latéraux difficiles à détecter. Les instructions AES sont conçues pour fonctionner efficacement sur diverses plateformes et pour différentes applications, y compris le chiffrement en temps réel de flux vidéo et audio, les cartes à puce, les systèmes embarqués, et les applications nécessitant une agilité de clé élevée comme IPsec^[21].

Mieux connaître l'AES

import sys
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import base64

# Fixed key and IV
FIXED_KEY = b'fixedkey1234567890123456'  # 256-bit key (32 bytes)
FIXED_IV = b'fixediv012345678'  # 128-bit IV (16 bytes)

def encrypt(plaintext):
    cipher = AES.new(FIXED_KEY, AES.MODE_CBC, FIXED_IV)
    ciphertext = cipher.encrypt(pad(plaintext, AES.block_size))
    return base64.b64encode(ciphertext)

def decrypt(ciphertext):
    ciphertext = base64.b64decode(ciphertext)
    cipher = AES.new(FIXED_KEY, AES.MODE_CBC, FIXED_IV)
    plaintext = unpad(cipher.decrypt(ciphertext), AES.block_size)
    return plaintext

def main():
    if len(sys.argv) < 4:
        print("Usage: python aes_cbc_file.py <encrypt|decrypt> <input_file> <output_file>")
        sys.exit(1)

    action = sys.argv[1]
    input_file = sys.argv[2]
    output_file = sys.argv[3]

    try:
        with open(input_file, 'rb') as f:
            data = f.read()
    except FileNotFoundError:
        print(f"File {input_file} not found.")
        sys.exit(1)

    if action == "encrypt":
        encrypted_data = encrypt(data)
        with open(output_file, 'wb') as f:
            f.write(encrypted_data)
        print(f"Encrypted data written to {output_file}")
    elif action == "decrypt":
        decrypted_data = decrypt(data)
        with open(output_file, 'wb') as f:
            f.write(decrypted_data)
        print(f"Decrypted data written to {output_file}")
    else:
        print("Invalid action. Use 'encrypt' or 'decrypt'.")
        sys.exit(1)

if __name__ == "__main__":
    main()

Notes et références

Annexes