AES (Advanced Encryption Standard) ist ein symmetrischer Verschlüsselungsalgorithmus, der Daten in Blöcken verschlüsselt und dabei den gleichen Schlüssel für Verschlüsselung und Entschlüsselung verwendet.

AES wurde von der US-Regierung als Standard für sichere Datenübertragung festgelegt und nutzt Blockgrößen von 128 Bit mit Schlüssellängen von 128, 192 oder 256 Bit.
Durch seine hohe Sicherheit und Effizienz ist AES weit verbreitet und wird sowohl für private als auch für staatliche Verschlüsselungsanwendungen verwendet.
AES arbeitet in mehreren Runden (abhängig von der Schlüssellänge) und nutzt Substitution, Permutation und Schlüsseladdition.

Geschichte und Entstehung

Der Weg zu AES

In den 1990er Jahren war der bisherige Standard DES (Data Encryption Standard) veraltet und unsicher geworden.

Zeitlinie:

1997: NIST startet AES-Wettbewerb
      ↓
      15 Kandidaten aus aller Welt
      ↓
1999: 5 Finalisten bleiben übrig
      - MARS (IBM)
      - RC6 (RSA)
      - Rijndael (Belgien) ✓
      - Serpent (UK/Israel/Norwegen)
      - Twofish (USA)
      ↓
2000: Rijndael gewinnt
      ↓
2001: AES wird offizieller Standard (FIPS 197)

Grundprinzip: Symmetrische Verschlüsselung

AES ist ein symmetrischer Algorithmus: Derselbe Schlüssel wird zum Ver- und Entschlüsseln verwendet.

Prinzip:

┌───────────────┐                      ┌───────────────┐
│    Alice      │                      │      Bob      │
│               │                      │               │
│ Klartext:     │                      │ Verschlüsselt:│
│ "GEHEIM"      │                      │ "8x9#mP..."   │
│               │                      │               │
│      │        │                      │      │        │
│      ↓        │                      │      ↓        │
│  [Schlüssel]  │  Sicherer Kanal     │  [Schlüssel]  │
│      │        │  ────────────────►  │      │        │
│      ↓        │                      │      ↓        │
│  AES Encrypt  │                      │  AES Decrypt  │
│      │        │                      │      │        │
│      ↓        │  Verschlüsselter    │      ↓        │
│ "8x9#mP..."   │  ─────────────────► │ "GEHEIM"      │
│               │      Text           │               │
└───────────────┘                      └───────────────┘

AES-Varianten und Schlüsselgrößen

Die Blockgröße ist bei allen Varianten gleich (128 Bit), nur die Schlüssellänge und Rundenanzahl unterscheiden sich.

Wie funktioniert AES?

AES-Struktur (Substitution-Permutation Network)

Plaintext (128 Bit)
       │
       ↓
┌─────────────────────────────────────┐
│   Initial Round: AddRoundKey        │  ← XOR mit Round Key 0
└─────────────────────────────────────┘
       │
       ↓
┌─────────────────────────────────────┐
│   Main Rounds (9/11/13 Mal)         │
│   ┌───────────────────────────┐     │
│   │ 1. SubBytes               │     │  ← S-Box Substitution
│   │ 2. ShiftRows              │     │  ← Zeilen verschieben
│   │ 3. MixColumns             │     │  ← Spalten mixen
│   │ 4. AddRoundKey            │     │  ← XOR mit Round Key
│   └───────────────────────────┘     │
└─────────────────────────────────────┘
       │
       ↓
┌─────────────────────────────────────┐
│   Final Round                        │
│   1. SubBytes                        │
│   2. ShiftRows                       │
│   3. AddRoundKey                     │
│   (Kein MixColumns!)                 │
└─────────────────────────────────────┘
       │
       ↓
Ciphertext (128 Bit)

AES-Operationen im Detail

1. SubBytes (Byte-Substitution)

Jedes Byte wird durch ein anderes Byte ersetzt, basierend auf einer S-Box (Substitution Box).

Input Byte:    0x53
       │
       ↓
┌──────────────┐
│   S-Box      │  ← Nachschlagetabelle (16x16)
└──────────────┘
       │
       ↓
Output Byte:   0xED

S-Box-Prinzip:

     0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
   ┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┐
 0 │63│7C│77│7B│F2│6B│6F│C5│30│01│67│2B│FE│D7│AB│76│
 1 │CA│82│C9│7D│FA│59│47│F0│AD│D4│A2│AF│9C│A4│72│C0│
 2 │B7│FD│93│26│36│3F│F7│CC│34│A5│E5│F1│71│D8│31│15│
 3 │04│C7│23│C3│18│96│05│9A│07│12│80│E2│EB│27│B2│75│
 ...

2. ShiftRows (Zeilen verschieben)

Die Bytes der State-Matrix werden zeilenweise zyklisch verschoben.

Vorher:                      Nachher:
┌──┬──┬──┬──┐               ┌──┬──┬──┬──┐
│a0│a1│a2│a3│  Zeile 0 →    │a0│a1│a2│a3│ (keine Verschiebung)
├──┼──┼──┼──┤               ├──┼──┼──┼──┤
│b0│b1│b2│b3│  Zeile 1 →    │b1│b2│b3│b0│ (1 nach links)
├──┼──┼──┼──┤               ├──┼──┼──┼──┤
│c0│c1│c2│c3│  Zeile 2 →    │c2│c3│c0│c1│ (2 nach links)
├──┼──┼──┼──┤               ├──┼──┼──┼──┤
│d0│d1│d2│d3│  Zeile 3 →    │d3│d0│d1│d2│ (3 nach links)
└──┴──┴──┴──┘               └──┴──┴──┴──┘

3. MixColumns (Spalten mischen)

Jede Spalte der State-Matrix wird mit einer festen Matrix multipliziert (im Galois-Feld GF(2⁸)).

┌──┐     ┌──────┐     ┌──┐
│a0│     │02 03 │     │a0'│
│a1│  ×  │01 01 │  =  │a1'│
│a2│     │01 01 │     │a2'│
│a3│     │03 02 │     │a3'│
└──┘     └──────┘     └──┘

Mathematisches Beispiel (vereinfacht):

a0' = (2 × a0) ⊕ (3 × a1) ⊕ (1 × a2) ⊕ (1 × a3)
a1' = (1 × a0) ⊕ (2 × a1) ⊕ (3 × a2) ⊕ (1 × a3)
...

4. AddRoundKey (Rundenschlüssel addieren)

Der aktuelle Rundenschlüssel wird per XOR mit dem State kombiniert.

State:           Round Key:        Ergebnis:
┌──┬──┬──┬──┐   ┌──┬──┬──┬──┐    ┌──┬──┬──┬──┐
│a0│a1│a2│a3│ ⊕ │k0│k1│k2│k3│ =  │c0│c1│c2│c3│
│b0│b1│b2│b3│   │k4│k5│k6│k7│    │d0│d1│d2│d3│
│c0│c1│c2│c3│   │k8│k9│kA│kB│    │e0│e1│e2│e3│
│d0│d1│d2│d3│   │kC│kD│kE│kF│    │f0│f1│f2│f3│
└──┴──┴──┴──┘   └──┴──┴──┴──┘    └──┴──┴──┴──┘

XOR-Operation:
a0 ⊕ k0 = c0

Key Expansion (Schlüsselerweiterung)

Aus dem ursprünglichen Schlüssel werden mehrere Rundenschlüssel abgeleitet.

Beispiel für AES-128 (10 Runden):

Original Key (128 Bit)
       │
       ↓
┌─────────────────┐
│ Key Expansion   │  ← Algorithmus generiert aus
│   Algorithmus   │     1 Schlüssel → 11 Rundenschlüssel
└─────────────────┘
       │
       ↓
Round Key 0  (Initial)
Round Key 1  (Runde 1)
Round Key 2  (Runde 2)
   ...
Round Key 10 (Runde 10)

Visualisierung:

Original:  [2B 7E 15 16 28 AE D2 A6 AB F7 15 88 09 CF 4F 3C]
              │
              ↓  RotWord, SubWord, Rcon
              │
Round 1:   [A0 FA FE 17 88 54 2C B1 23 A3 39 39 2A 6C 76 05]
              │
              ↓
Round 2:   [F2 C2 95 F2 7A 96 B9 43 59 35 80 7A 73 59 F6 7F]
   ...

AES-Betriebsmodi (Block Cipher Modes)

AES verschlüsselt nur 128-Bit-Blöcke. Für längere Daten werden Betriebsmodi verwendet.

ECB (Electronic Codebook) - NICHT EMPFOHLEN!

Block 1  →  [AES]  →  Cipher 1
Block 2  →  [AES]  →  Cipher 2
Block 3  →  [AES]  →  Cipher 3

CBC (Cipher Block Chaining) - Empfohlen

IV ─────┐
        ↓
Block 1 ⊕ → [AES] → Cipher 1
              │
              ↓
Block 2 ⊕ → [AES] → Cipher 2
              │
              ↓
Block 3 ⊕ → [AES] → Cipher 3

CTR (Counter Mode)

Counter 1 → [AES] → Keystream 1 ⊕ Block 1 → Cipher 1
Counter 2 → [AES] → Keystream 2 ⊕ Block 2 → Cipher 2
Counter 3 → [AES] → Keystream 3 ⊕ Block 3 → Cipher 3

GCM (Galois/Counter Mode) - Moderne Wahl

Kombiniert CTR-Modus mit Authentifizierung (GMAC).

Counter → [AES] → Keystream ⊕ Plaintext → Ciphertext
                                              │
                                              ↓
                                          [GMAC] → Authentication Tag

Praktische Code-Beispiele

Python mit PyCryptodome

Installation

pip install pycryptodome

AES-128 Verschlüsselung (CBC-Modus)

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

# Schlüssel generieren (16 Bytes = 128 Bit)
key = get_random_bytes(16)
print(f"Schlüssel: {key.hex()}")

# Initialisierungsvektor (IV)
iv = get_random_bytes(16)
print(f"IV: {iv.hex()}")

# Plaintext
plaintext = b"Geheime Nachricht!"

# Verschlüsselung
cipher = AES.new(key, AES.MODE_CBC, iv)
ciphertext = cipher.encrypt(pad(plaintext, AES.block_size))

print(f"Verschlüsselt: {base64.b64encode(ciphertext).decode()}")

# Entschlüsselung
decipher = AES.new(key, AES.MODE_CBC, iv)
decrypted = unpad(decipher.decrypt(ciphertext), AES.block_size)

print(f"Entschlüsselt: {decrypted.decode()}")

AES-256 mit GCM (empfohlen!)

from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes

# Schlüssel generieren (32 Bytes = 256 Bit)
key = get_random_bytes(32)
plaintext = b"Top Secret Data"

# Verschlüsselung mit GCM
cipher = AES.new(key, AES.MODE_GCM)
ciphertext, tag = cipher.encrypt_and_digest(plaintext)

print(f"Nonce: {cipher.nonce.hex()}")
print(f"Ciphertext: {ciphertext.hex()}")
print(f"Auth Tag: {tag.hex()}")

# Entschlüsselung mit Authentifizierung
decipher = AES.new(key, AES.MODE_GCM, nonce=cipher.nonce)
try:
    decrypted = decipher.decrypt_and_verify(ciphertext, tag)
    print(f"Entschlüsselt: {decrypted.decode()}")
except ValueError:
    print("Authentifizierung fehlgeschlagen! Daten wurden manipuliert.")

OpenSSL (Kommandozeile)

Datei verschlüsseln

# AES-256-CBC
openssl enc -aes-256-cbc -salt -in plaintext.txt -out encrypted.bin

# Mit Base64-Kodierung
openssl enc -aes-256-cbc -salt -in plaintext.txt -out encrypted.txt -base64

Datei entschlüsseln

openssl enc -aes-256-cbc -d -in encrypted.bin -out decrypted.txt

AES in der Praxis

1. HTTPS/TLS

AES wird in TLS 1.2 und TLS 1.3 für die Verschlüsselung der Webkommunikation verwendet.

Typische Cipher Suite:

TLS_AES_256_GCM_SHA384
    │    │   │    │
    │    │   │    └─ SHA-384 für Hashing
    │    │   └────── GCM-Modus
    │    └────────── AES-256
    └─────────────── TLS-Protokoll

2. WLAN-Verschlüsselung (WPA2/WPA3)

┌──────────────┐                      ┌──────────────┐
│   Client     │                      │   Router     │
│              │  4-Way Handshake     │              │
│              │  ◄────────────────►  │              │
│              │                      │              │
│  AES-CCMP    │  Verschlüsselte      │  AES-CCMP    │
│  Encryption  │  ──────────────────► │  Decryption  │
└──────────────┘      WLAN-Pakete     └──────────────┘

3. Festplattenverschlüsselung

• Windows: BitLocker (AES-128/256)
• macOS: FileVault (AES-128)
• Linux: LUKS (AES-256)

# Linux: Partition mit AES verschlüsseln
cryptsetup luksFormat /dev/sdb1 --cipher aes-xts-plain64 --key-size 512

4. Datenbanken

-- MySQL: AES-Verschlüsselung
INSERT INTO users (name, secret)
VALUES ('Alice', AES_ENCRYPT('Passwort123', 'encryption_key'));

-- Entschlüsseln
SELECT name, AES_DECRYPT(secret, 'encryption_key') AS password
FROM users;

Sicherheit und Angriffe

Ist AES sicher?

Theoretische Angriffe:

AES-128: 2^126.1 Operationen (Biclique-Angriff)
         → Praktisch unmöglich

AES-256: 2^254.4 Operationen
         → Noch sicherer

Mögliche Schwachstellen

1. Schwache Schlüssel

Falsch:

# Unsicher!
key = "passwort".encode().ljust(16, b'\0')

Richtig:

from Crypto.Protocol.KDF import PBKDF2

password = b"mein_sicheres_passwort"
salt = get_random_bytes(16)
key = PBKDF2(password, salt, dkLen=32, count=100000)

2. Schlüsselwiederverwendung mit CTR/GCM

3. Side-Channel-Angriffe

• Timing-Angriffe: Messung der Verschlüsselungszeit
• Cache-Timing: Analyse von CPU-Cache-Zugriffen
• Power-Analyse: Strommessung während Verschlüsselung

Schutz: Konstante-Zeit-Implementierungen (z.B. AES-NI)

4. Quantencomputer

Empfehlung: Für Post-Quantum-Sicherheit AES-256 verwenden.

AES-NI (Hardware-Beschleunigung)

Moderne CPUs haben spezielle AES-Instruktionen für schnellere Verschlüsselung.

Ohne AES-NI:  ~200 MB/s
Mit AES-NI:   ~2000 MB/s (10x schneller!)

Prüfen, ob CPU AES-NI unterstützt:

# Linux
grep aes /proc/cpuinfo

# Windows (PowerShell)
Get-WmiObject Win32_Processor | Select-Object Name, *aes*

Stärken und Schwächen

Stärken

Schwächen

AES vs. Andere Verfahren

Zusammenfassung

Verwandte Konzepte

• Kryptographie - Übergeordnetes Konzept
• Symmetrische Verschlüsselung - AES ist symmetrisch
• RSA - Asymmetrische Alternative
• TLS - Verwendet AES für sichere Verbindungen
• Diffie-Hellman - Schlüsselaustausch für AES
• Passwort-Hashing - Schlüsselableitung für AES

Weiterführende Ressourcen

Bücher:

• "The Design of Rijndael" von Joan Daemen und Vincent Rijmen
• "Cryptography Engineering" von Ferguson, Schneier, Kohno

Online:

• NIST FIPS 197 (AES-Spezifikation)
• Computerphile: AES Explained (YouTube)
• CrypTool (Visualisierung von AES)

Tools:

• OpenSSL (Kommandozeile)
• PyCryptodome (Python)
• CyberChef (Online-Tool)