Kryptographie in der Softwareentwicklung

Bedeutung von Kryptographischen Aufgaben

Die Geschichte der Kryptographie reicht weit zurück und hat sich im Laufe der Zeit zu einem essentiellen Bestandteil der modernen IT-Entwicklung entwickelt. Bereits im antiken Griechenland wurde Kryptographie verwendet, um vertrauliche Botschaften zu schützen. Heutzutage hat sich die Kryptographie in der digitalen Welt als unverzichtbare Methode etabliert, um Informationen vor unbefugtem Zugriff und Manipulation zu schützen.

Die Anwendungsfälle sicherer Kryptographie im Programmier-Alltag sind vielfältig und von entscheidender Bedeutung für die Sicherheit von Software und Systemen. Ein zentrales Anwendungsgebiet ist das Passwort-Hashing, bei dem Benutzerpasswörter in unleserliche Zeichenfolgen umgewandelt werden, um sie vor neugierigen Blicken zu schützen. Aber auch darüber hinaus spielt Kryptographie eine Schlüsselrolle, wie beispielsweise bei der OAuth-Sicherheit mit JSON Web Tokens (JWT) zur sicheren Authentifizierung und Autorisierung von Benutzern. Zudem kommen Zertifikate zum Einsatz, um die Identität von Entitäten zu überprüfen und verschlüsselte Kommunikation zu gewährleisten.

In diesem Artikel werden wir uns eingehend mit dem Thema der sicheren Kryptographie in der Entwicklung auseinandersetzen. Wir werden uns mit verschiedenen Aspekten befassen, angefangen bei den Grundlagen des Hashings bis hin zu praktischen Programmierbeispielen. Durch ein besseres Verständnis dieser Konzepte können Entwicklerinnen und Entwickler dazu beitragen, robuste und widerstandsfähige Anwendungen zu gestalten, die den heutigen Sicherheitsherausforderungen gerecht werden.

Hashing

Was ist Hashing?

Hashing ist ein fundamentaler Prozess in der Kryptografie, bei dem eine Eingabe (oder Nachricht) in eine feste Länge von Zeichen umgewandelt wird, die als Hash-Wert bezeichnet wird. Dieser Hash-Wert dient als digitale Fingerabdruck der Eingabe und ermöglicht die Identifikation und Überprüfung der Integrität der Daten.

Unterschiedliche Hashing-Algorithmen

Es gibt eine Vielzahl von Hashing-Algorithmen, von denen jeder bestimmte Eigenschaften und Anwendungsfälle aufweist. Einige der wichtigsten Hashing-Algorithmen sind MD5, SHA-1, SHA-256 und SHA-3. Während MD5 und SHA-1 aufgrund von Schwachstellen heutzutage vermieden werden sollten, bieten SHA-256 und SHA-3 eine robustere Sicherheit.

Einsatz von unterschiedlichen Algorithmen je nach Aufgabe

Ein interessanter Hashing-Algorithmus im Kontext der Kryptowährungen ist RIPEMD-160. Dieser Algorithmus wurde entwickelt, um eine kürzere Hash-Länge im Vergleich zu den SHA-2 Algorithmen zu erreichen. Insbesondere wird RIPEMD-160 in der Blockchain-Technologie von Bitcoin verwendet, um die Adressen von Bitcoin-Wallets zu erstellen.

Die Bitcoin-Adresse eines Wallets wird aus dem öffentlichen Schlüssel erzeugt, indem der öffentliche Schlüssel zunächst durch SHA-256 und dann durch RIPEMD-160 gehasht wird. Der resultierende Hash-Wert wird als Basis für die Bitcoin-Adresse verwendet. Die Verwendung von RIPEMD-160 trägt dazu bei, dass die erzeugten Adressen kürzer sind und somit leichter von Benutzern verarbeitet werden können.

Durch die Verwendung von RIPEMD-160 für die Erzeugung von Bitcoin-Adressen wird auch eine gewisse Sicherheit gewährleistet, da die Adresse von einem öffentlichen Schlüssel abgeleitet wird, ohne Rückschlüsse auf den privaten Schlüssel zuzulassen. Dies trägt zur Sicherheit und Anonymität der Benutzer im Bitcoin-Netzwerk bei.

Salting

Ein SALT ist eine zufällige Zeichenfolge, die vor oder nach der Eingabe hinzugefügt wird, bevor der Hash-Wert erstellt wird. Dies erhöht die Sicherheit, da es verhindert, dass Angreifer vorberechnete Hash-Tabellen (Rainbow-Tables) verwenden, um Hash-Werte zu brechen. Ein SALT trägt zur Einmaligkeit des Hash-Werts bei, selbst wenn die gleiche Eingabe von verschiedenen Benutzern verwendet wird.

Programmierbeispiel in Python

import hashlib

def hash_with_salt(input_str, salt):
    # Kombiniere das Eingabe-Passwort mit dem Salt
    salted_input = input_str + salt
    
    # Erstelle einen SHA-256 Hash
    hash_object = hashlib.sha256(salted_input.encode())
    hash_value = hash_object.hexdigest()
    
    return hash_value

# Beispielanwendung
password = "geheimes_passwort"
salt = "zufaelliges_salt"
hashed_password = hash_with_salt(password, salt)
print("Passwort:", password)
print("Salt:", salt)
print("Hash-Wert:", hashed_password)

In diesem Beispiel wird ein Passwort unter Verwendung eines SALTs gehasht, um die Sicherheit zu erhöhen. Das Ergebnis ist ein Hash-Wert, der schwer rückgängig zu machen ist und die Vertraulichkeit des Passworts bewahrt. Durch den Einsatz von angemessenen Hashing-Algorithmen und bewährten Praktiken wie der Verwendung von SALTs können Entwickler eine robuste Sicherheit für ihre Anwendungen gewährleisten.

Symmetrische Verschlüsselung

Was ist Symmetrische Verschlüsselung?

Symmetrische Verschlüsselung ist ein Verfahren in der Kryptographie, bei dem sowohl die Verschlüsselung als auch die Entschlüsselung mit demselben geheimen Schlüssel erfolgen. Diese Art der Verschlüsselung zeichnet sich durch ihre Einfachheit und Geschwindigkeit aus, da nur ein Schlüssel für beide Vorgänge benötigt wird. Allerdings besteht bei symmetrischer Verschlüsselung die Herausforderung, den geheimen Schlüssel sicher zwischen den Kommunikationspartnern auszutauschen.

Unterschiedliche Arten der Symmetrischen Verschlüsselung

Es gibt verschiedene Modi und Algorithmen, die in der symmetrischen Verschlüsselung verwendet werden können. Einige der gängigen Modi sind der elektronische Codebuch-Modus (ECB), der Cipher Block Chaining-Modus (CBC) und der Counter-Modus (CTR). Jeder Modus hat spezifische Vor- und Nachteile in Bezug auf Sicherheit und Effizienz.

Unter den wichtigen symmetrischen Verschlüsselungsalgorithmen finden sich DES (Data Encryption Standard), 3DES, AES (Advanced Encryption Standard), IDEA (International Data Encryption Algorithm) und RC4. Diese Algorithmen zeichnen sich durch unterschiedliche Schlüssellängen, Blockgrößen und Sicherheitsstufen aus.

Programmierbeispiel in Python

from cryptography.fernet import Fernet

# Generiere einen zufälligen Schlüssel
key = Fernet.generate_key()

# Erstelle ein Fernet-Verschlüsselungsobjekt
cipher_suite = Fernet(key)

# Klartext-Nachricht
message = b"Geheime Nachricht, die verschlüsselt werden soll."

# Verschlüsselung
encrypted_message = cipher_suite.encrypt(message)

# Entschlüsselung
decrypted_message = cipher_suite.decrypt(encrypted_message)

print("Klartext:", message)
print("Verschlüsselte Nachricht:", encrypted_message)
print("Entschlüsselte Nachricht:", decrypted_message)

In diesem Beispiel verwenden wir die Python-Bibliothek "cryptography" für symmetrische Verschlüsselung mit dem Fernet-Algorithmus. Ein zufälliger Schlüssel wird generiert, um die Nachricht zu verschlüsseln und anschließend wieder zu entschlüsseln. Dieses Verfahren demonstriert die grundlegende Funktionsweise der symmetrischen Verschlüsselung.

Die symmetrische Verschlüsselung bleibt eine wichtige Technik, um vertrauliche Daten zu schützen, insbesondere wenn eine effiziente und schnelle Verschlüsselung erforderlich ist. Dennoch ist der sichere Schlüsselaustausch eine kritische Herausforderung, die angegangen werden muss, um die Vertraulichkeit der Daten zu gewährleisten.

Asymmetrische Verschlüsselung

Was ist Asymmetrische Verschlüsselung?

Asymmetrische Verschlüsselung, auch Public-Key-Verschlüsselung genannt, ist eine Verschlüsselungstechnik, bei der ein Schlüsselpaar verwendet wird: ein öffentlicher Schlüssel zum Verschlüsseln und ein privater Schlüssel zum Entschlüsseln. Die Sicherheit dieses Verfahrens basiert auf der Schwierigkeit, den privaten Schlüssel aus dem öffentlichen Schlüssel abzuleiten. Es gibt verschiedene Algorithmen für asymmetrische Verschlüsselung, wobei RSA (Rivest-Shamir-Adleman) und ECC (Elliptic Curve Cryptography) die bekanntesten sind. ECC verwendet elliptische Kurven, um die gleiche Sicherheit mit kürzeren Schlüsseln im Vergleich zu RSA zu bieten. Zu den wichtigen asymmetrischen Verschlüsselungsalgorithmen gehören:

• RSA: Basierend auf der Schwierigkeit des Faktorisierens großer Zahlen.
• ECC: Verwendet elliptische Kurven und bietet starke Sicherheit mit kürzeren Schlüsseln.
• DSA (Digital Signature Algorithm): Zur Erstellung digitaler Signaturen.
• DH (Diffie-Hellman): Zum sicheren Schlüsselaustausch.

Programmierbeispiel in Python

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization

# Generiere Schlüsselpaar
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
public_key = private_key.public_key()

# Nachricht verschlüsseln
message = b"Geheime Nachricht, die verschlüsselt werden soll."
cipher_text = public_key.encrypt(
    message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# Nachricht entschlüsseln
plain_text = private_key.decrypt(
    cipher_text,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

print("Klartext:", message)
print("Verschlüsselte Nachricht:", cipher_text)
print("Entschlüsselte Nachricht:", plain_text)

Dieses Beispiel zeigt die Erzeugung eines Schlüsselpaars, die Verschlüsselung und Entschlüsselung einer Nachricht mit asymmetrischer Verschlüsselung unter Verwendung des RSA-Algorithmus.

Elliptische Kurven

Bei elliptischer Kurvenkryptographie werden bestimmte Kurven verwendet, um den Schlüsseltausch zu ermöglichen. Die Brainpool- und NIST-Kurven sind bekannte Standardkurven, die in der Kryptographie verwendet werden. Sie bieten eine angemessene Balance zwischen Sicherheit und Effizienz. Ein Beispiel für eine Brainpool-Kurve ist "brainpoolP256r1", die eine Schlüssellänge von 256 Bit hat. Die NIST-Kurven, auch bekannt als P-256, P-384 und P-521, sind von der National Institute of Standards and Technology (NIST) standardisierte elliptische Kurven. Diese Kurven bieten ebenfalls eine ausgewogene Kombination aus Sicherheit und Effizienz. Beispielsweise hat die P-256-Kurve eine Schlüssellänge von 256 Bit.

Programmierbeispiel in Python für Brainpool Kurven

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.backends import default_backend

# Erzeuge privaten und öffentlichen Schlüssel mit Brainpool-Kurve P-256
private_key = ec.generate_private_key(
    ec.BrainpoolP256R1(),
    backend=default_backend()
)
public_key = private_key.public_key()

# Beispiel für Verschlüsselung und Entschlüsselung
data = b"Geheime Nachricht"
encrypted_data = public_key.encrypt(data, ec.ECIES())
decrypted_data = private_key.decrypt(encrypted_data, ec.ECIES())

print("Klartext:", data)
print("Verschlüsselte Nachricht:", encrypted_data)
print("Entschlüsselte Nachricht:", decrypted_data)

Programmierbeispiel in Python für NIST Kurven

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.backends import default_backend

# Erzeuge privaten und öffentlichen Schlüssel mit NIST-Kurve P-256
private_key = ec.generate_private_key(
    ec.SECP256R1(),
    backend=default_backend()
)
public_key = private_key.public_key()

# Beispiel für Signaturerstellung und -prüfung
message = b"Nachricht, die signiert wird"
signature = private_key.sign(
    message,
    ec.ECDSA(hashes.SHA256())
)
public_key.verify(
    signature,
    message,
    ec.ECDSA(hashes.SHA256())
)

Diese Beispiele zeigen die Erzeugung von Schlüsselpaaren und die Verwendung von Brainpool- bzw. NIST-Kurven in Python.

Asymmetrische Verschlüsselung bietet eine sichere Möglichkeit, vertrauliche Daten zu schützen, ohne dass ein sicherer Schlüsselaustausch erforderlich ist. Sie wird häufig in Kombination mit symmetrischer Verschlüsselung und zur Erstellung digitaler Signaturen eingesetzt.

Hybride Verschlüsselung

Was ist Hybride Verschlüsselung?

Hybride Verschlüsselung ist eine Kombination aus symmetrischer und asymmetrischer Verschlüsselung, die die Vorteile beider Ansätze vereint. Sie wurde entwickelt, um die Schwächen der symmetrischen Schlüsselaustauschprozesse zu überwinden und gleichzeitig die Effizienz der symmetrischen Verschlüsselung zu nutzen.

Wie funktioniert Hybride Verschlüsselung?

Bei der hybriden Verschlüsselung wird ein zufälliger symmetrischer Sitzungsschlüssel (Session Key) erzeugt. Dieser wird verwendet, um die eigentlichen Daten symmetrisch zu verschlüsseln, was effizient ist. Anschließend wird der Sitzungsschlüssel asymmetrisch mit dem öffentlichen Schlüssel des Empfängers verschlüsselt und zusammen mit den verschlüsselten Daten gesendet. Der Empfänger kann den symmetrischen Sitzungsschlüssel dann mit seinem privaten Schlüssel entschlüsseln und die eigentlichen Daten entschlüsseln.

Programmierbeispiel für Hybride Verschlüsselung in Python

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.backends import default_backend
from cryptography.fernet import Fernet

# Erzeuge privaten und öffentlichen Schlüssel für asymmetrische Verschlüsselung
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
    backend=default_backend()
)
public_key = private_key.public_key()

# Nachricht, die verschlüsselt werden soll
message = b"Geheime Nachricht, die verschlüsselt werden soll."

# Erzeuge zufälligen Sitzungsschlüssel für symmetrische Verschlüsselung
symmetric_key = Fernet.generate_key()
cipher_suite = Fernet(symmetric_key)

# Verschlüssele die Nachricht symmetrisch
encrypted_message = cipher_suite.encrypt(message)

# Verschlüssele den Sitzungsschlüssel asymmetrisch
encrypted_session_key = public_key.encrypt(
    symmetric_key,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# Sende verschlüsselte Nachricht und Sitzungsschlüssel

# Empfängerseite:

# Entschlüssele den Sitzungsschlüssel asymmetrisch
session_key = private_key.decrypt(
    encrypted_session_key,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# Entschlüssele die Nachricht symmetrisch
decrypted_message = cipher_suite.decrypt(encrypted_message)

print("Klartext:", message)
print("Verschlüsselte Nachricht:", encrypted_message)
print("Entschlüsselte Nachricht:", decrypted_message)

In diesem Beispiel wird ein hybrides Verschlüsselungsschema demonstriert. Ein asymmetrischer RSA-Schlüsselpaar wird erzeugt, um den Sitzungsschlüssel für die symmetrische Verschlüsselung zu verschlüsseln. Dieser Sitzungsschlüssel wird verwendet, um die eigentlichen Daten zu verschlüsseln. Auf Empfängerseite wird der Sitzungsschlüssel mit dem privaten RSA-Schlüssel entschlüsselt, um die Daten wiederherzustellen.

Hybride Verschlüsselung ist eine leistungsstarke Technik, die die Sicherheit asymmetrischer Verschlüsselung mit der Effizienz der symmetrischen Verschlüsselung kombiniert. Dieses Verfahren wird häufig bei der sicheren Übertragung von vertraulichen Daten verwendet.

Einsatz von sicheren Kryptographie Libraries

Bedeutung von sicheren Software Libraries für Kryptographische Aufgaben

Sichere Kryptographie-Bibliotheken spielen eine zentrale Rolle bei der Implementierung von kryptografischen Verfahren. Sie bieten Entwicklern gut getestete und bewährte Implementierungen von Algorithmen, die für eine robuste und vertrauenswürdige Sicherheit von entscheidender Bedeutung sind. Diese Bibliotheken minimieren Fehler, die bei der Implementierung von Kryptographie auftreten können, und stellen sicher, dass bewährte Sicherheitspraktiken eingehalten werden.

Vergleich von Kryptographischen Libraries

Es gibt eine Vielzahl von kryptographischen Bibliotheken, die in verschiedenen Programmiersprachen verfügbar sind. Einige der bekanntesten Bibliotheken sind OpenSSL, libsodium, Bouncy Castle, Cryptography (Python), und Crypto++ (C++). Jede Bibliothek hat ihre eigenen Vor- und Nachteile, je nach Anforderungen und Präferenzen.

Was ist FIPS 140?

FIPS 140 steht für den Federal Information Processing Standard Publication 140, der von der US-amerikanischen National Institute of Standards and Technology (NIST) herausgegeben wird. Dieser Standard definiert die Anforderungen für kryptografische Module, einschließlich Hardware- und Softwaremodule, die in sensiblen Informationssystemen verwendet werden. FIPS 140 Zertifizierung zeigt an, dass eine kryptografische Implementierung bestimmte Sicherheitsstandards erfüllt.
Einige kryptografische Bibliotheken, die FIPS 140 Zertifizierung haben oder mit FIPS 140 kompatibel sind:

• OpenSSL (C)
• WolfSSL (C)
• Bouncy Castle (Java und C#)
• Microsoft CNG (Windows Cryptographic Next Generation)
• Amazon CloudHSM (Hardware Security Module)
• Google BoringSSL (Abspaltung von OpenSSL)

Programmierbeispiel FIPS 140

(Hinweis: Da die Implementierung von FIPS 140 stark von der Bibliothek und Umgebung abhängt, ist hier ein allgemeines Beispiel für die Verwendung einer FIPS 140 Bibliothek in Python gegeben.)

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes

# Erzeuge FIPS 140-kompatiblen Hash
digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
digest.update(b"Nachricht zum Hashen")
hash_value = digest.finalize()

print("SHA-256 Hash:", hash_value)

In diesem Beispiel verwenden wir die Python-Bibliothek "cryptography" zur Erzeugung eines FIPS 140-kompatiblen Hash-Werts. Beachten Sie, dass die FIPS 140 Konformität nicht nur von der Bibliothek selbst abhängt, sondern auch von der Konfiguration und Umgebung, in der die Bibliothek ausgeführt wird.

Die Verwendung von FIPS 140-konformen Bibliotheken stellt sicher, dass kryptografische Funktionen den höchsten Sicherheitsstandards entsprechen und in sicherheitskritischen Anwendungen eingesetzt werden können.

Weiterführende Aspekte

Zusätzliche Sicherheit durch echte Zufallszahlen

Hardware Security Modules (HSMs) sind spezielle Hardwaregeräte, die zur sicheren Verwahrung von kryptografischen Schlüsseln und zur Durchführung kryptografischer Operationen verwendet werden. Sie bieten eine höhere Sicherheitsstufe, insbesondere in Bezug auf den Schutz von Schlüsseln vor unbefugtem Zugriff und die Erzeugung von echten Zufallszahlen. Echte Zufallszahlen sind für kryptografische Verfahren von entscheidender Bedeutung, da sie die Vorhersehbarkeit von Schlüsseln und Daten minimieren.

Kryptographische Libraries mit HSM Support

Einige kryptografische Bibliotheken bieten speziellen Support für die Integration von HSMs. Diese Bibliotheken ermöglichen es Entwicklern, kryptografische Schlüssel und Operationen sicher in einem HSM zu verwalten und durchzuführen. Beispiele für Bibliotheken mit HSM-Unterstützung sind:

• OpenSSL mit HSM-Unterstützung
• PKCS#11 (Cryptoki)
• Microsoft CNG (Windows Cryptographic Next Generation) mit HSM-Integration
• Botan (C++)

Bekannte HSM-Hersteller

Es gibt mehrere Hersteller von Hardware Security Modules, die in verschiedenen Branchen eingesetzt werden. Einige bekannte HSM-Hersteller sind:

• Thales (ehemals Gemalto)
• Utimaco
• Yubico
• IBM
• Amazon Web Services (AWS) CloudHSM

Die Verwendung von HSMs bietet eine zusätzliche Schutzschicht für kryptografische Schlüssel und Operationen. HSMs sind in sicherheitskritischen Anwendungen weit verbreitet, insbesondere in Bereichen wie Finanzwesen, Gesundheitswesen und Regierungsbehörden.

Summary

Die Verwendung sicherer Kryptographie in der Entwicklung ist von entscheidender Bedeutung, um Daten vor unbefugtem Zugriff und Manipulation zu schützen. Mit Hilfe von symmetrischer und asymmetrischer Verschlüsselung, hybrider Verschlüsselung und dem Einsatz von zuverlässigen kryptografischen Bibliotheken können Entwickler robuste Sicherheitsmechanismen in ihren Anwendungen implementieren. Die Integration von Hardware Security Modules (HSMs) und die Verwendung von zufälligen Schlüsseln tragen weiter zur Stärkung der Sicherheitsinfrastruktur bei. Die sorgfältige Auswahl und Implementierung dieser Techniken gewährleistet die Vertraulichkeit, Integrität und Verfügbarkeit von sensiblen Informationen und schützt sowohl Benutzer als auch Daten vor Bedrohungen.

Quellen:

• dpunkt.verlag, Kryptografie, Verfahren * Protokolle * Infrastrukturen
• Oreilley, Mastering Bitcoin
• Wikipedia