Grundlagen der IoT-Sicherheit - Teil 1: Verwendung der Kryptographie

Hinweis für Redakteure: Diese mehrteilige Serie bietet praktische Anleitungen, die Entwicklern helfen sollen, sicherzustellen, dass von Anfang an bewährte Verfahren befolgt werden. Hier werden in Teil 1 die Kryptographie-Algorithmen erörtert, die sicheren Entwürfen zugrunde liegen. Teil 2 erörtert die Rolle von privaten Schlüsseln, Schlüsselverwaltung und sicherer Speicherung in sicheren Systemen. Teil 3 untersucht die Mechanismen, die in sichere Prozessoren eingebaut sind, um Bedrohungen abzuschwächen, die darauf abzielen, die Ausführung von System- und Anwendungssoftware auf IoT-Geräten zu untergraben. Teil 4 identifiziert und zeigt, wie Sicherheitsmechanismen in fortschrittlichen Prozessoren angewendet werden können, um die Isolierung zu gewährleisten, die erforderlich ist, um Angriffe auf die Laufzeitumgebung von IoT-Geräten abzuschwächen. Teil 5 beschreibt, wie die IoT-Sicherheit von IoT-Geräten durch Sicherheitsmaßnahmen auf höherer Ebene weitergeführt wird, um diese Geräte mit IoT-Cloud-Ressourcen zu verbinden.

Die rasch wachsende Abhängigkeit von IoT-Anwendungen in Industrie, Medizin, Transport und anderen kritischen Anwendungen hat die Sicherheitslandschaft dramatisch verändert. Im Gegensatz zu früheren Unternehmensanwendungen mit leicht verfügbaren Ressourcen für die Verarbeitung von Sicherheitsalgorithmen sind IoT-Anwendungen auf Unternehmensebene anfällig für eine wachsende Anzahl von Bedrohungen, die auf expandierende Netzwerke von IoT-Geräten mit eingeschränkten Ressourcen abzielen. In ihrer Eile, auf die sich rasch abzeichnenden IoT-Gelegenheiten zu reagieren, setzen Organisationen allzu oft IoT-Geräte ein, die funktional nicht in der Lage sind, grundlegende Sicherheitsmaßnahmen zum Schutz gespeicherter Daten und zum Schutz des Daten- und Befehlsaustauschs über anfällige Netzwerke zu unterstützen.

Wie weit Entwickler gehen müssen, um ein Design zu sichern, hängt natürlich von mehreren Faktoren ab. Jede Anwendung ist mit einer eigenen Reihe von Bedrohungen konfrontiert und erfordert eine angemessene Bewertung der Risiken, die von diesen Bedrohungen ausgehen. Da angeschlossene Geräte einer ungewöhnlichen Anzahl von Bedrohungen ausgesetzt sind, erfordert jedes IoT-Gerät zumindest einige minimale Sicherheitsmaßnahmen.

Einigen mag die Implementierung robuster Sicherheitsmaßnahmen für ein einfaches IoT-Gerät wie ein Fall von Overengineering erscheinen, aber selbst einfache Temperatursensorgeräte, die keinen ausreichenden Schutz bieten, können Hackern einen Einstiegspunkt in Firmennetzwerke ^[1] bieten. In der Tat steht die IoT-Sicherheit aufgrund der Kombination aus der allgegenwärtigen Konnektivität, die von IoT-Anwendungen bereitgestellt wird, und den ressourcenbeschränkten Geräten, die diesen Anwendungen zugrunde liegen, vor ständigen Herausforderungen. Tatsächlich können selbst bei IoT-Gerätedesigns mit ausreichenden Ressourcen zur Ausführung von Kryptographie-Algorithmen in Software Anwendungen aufgrund subtiler Fehler bei der Implementierung dieser Algorithmen anfällig bleiben.

Dieser Artikel beschreibt die grundlegenden Klassen von Kryptographie-Algorithmen und untersucht ihre Rolle in der Sicherheit. Anschließend wird gezeigt, wie Entwickler die Vorteile von Prozessoren und Spezialgeräten - von Maxim Integrated, Microchip Technology, und Texas Instruments - nutzen können, die darauf ausgelegt sind, diese Algorithmen zu beschleunigen, verschiedene Sicherheitsaspekte zu verbessern und gleichzeitig ihre Implementierung zu vereinfachen.

Die verschiedenen Arten von kryptographischen Algorithmen und ihre Rolle

Kryptographie-Algorithmen lassen sich in drei große Kategorien einteilen, die sich mit den grundlegenden Sicherheitsprinzipien Vertraulichkeit, Authentifizierung (Überprüfung der Quelle der Nachricht), Unleugbarkeit (Nachweis, dass der Absender eine verschlüsselte oder signierte Nachricht erstellt hat) und Integrität befassen:

• Symmetrische Schlüsselalgorithmen, wobei der Algorithmus oder die Chiffre denselben geheimen Schlüssel verwendet, um eine von Menschen lesbare Nachricht (Klartext) zu einer geschützten Version (Chiffretext) zu verschlüsseln und später den Chiffretext wieder zu Klartext zu entschlüsseln. Symmetrische Schlüssel-Chiffren werden üblicherweise verwendet, um die Vertraulichkeit zu gewährleisten. Gängige symmetrische Kryptographie-Algorithmen umfassen:
  • Triple DES (Data Encryption Standard), auch bekannt als 3DES, oder offiziell vom U.S. National Institute of Standards and Technology (NIST) als Triple Data Encryption Algorithm (TDEA) bezeichnet.
  • Advanced Encryption Standard (AES)^[2] Algorithmen wie z.B. AES-256, der 256-Bit-Schlüssel verwendet.
• Asymmetrische Schlüsselalgorithmen, bei denen die Chiffre einen gepaarten Satz von privaten und öffentlichen Schlüsseln verwendet, um eine Nachricht zu ver- und entschlüsseln, typischerweise als Teil umfassenderer Sicherheitsprotokolle für Schlüsselvereinbarung und digitale Signaturen. Asymmetrische Chiffren werden in der Regel verwendet, um Vertraulichkeit, Authentifizierung oder Unleugbarkeit zu gewährleisten. Zu den Kryptographie-Algorithmen für öffentliche Schlüssel gehören
  • Algorithmen, die Finite-Field-Kryptographie (FFC) verwenden, einschließlich
    • Digitaler Signatur-Algorithmus (DSA) nach dem Federal Information Processing Standard (FIPS)
    • Internet Engineering Task Force (IETF) Diffie-Hellman (DH)^[3] Schlüsselaustausch
  • Algorithmen, die ganzzahlige Faktorisierungs-Kryptographie (IFC) verwenden, einschließlich
    • RSA (Rivest-Shamir-Adleman)^[4] Algorithmus
  • Algorithmen, die Kryptographie mit elliptischen Kurven (ECC) verwenden, einschließlich
    • Elliptische Kurve Diffie-Hellman (ECDH)^[5] Schlüsselaustausch
    • Algorithmus für digitale Signaturen mit elliptischer Kurve (ECDSA)^[6]
• Hash-Algorithmen, wobei der Algorithmus eine Originalnachricht auf einen viel kleineren, eindeutigen Wert fester Länge reduziert, der unterschiedlich als Hash, Digest oder Signatur bezeichnet wird. Diese Einweg-Konvertierungsfunktionen spielen eine entscheidende Rolle bei der Überprüfung, dass die Nachricht nicht verändert wurde (Integrität), und finden Anwendung in mehreren Protokollen, die u.a. einen Nachrichten-Authentifizierungscode (MAC), einen Keyed-Hash Message Authentication Code (HMAC) oder Schlüssel-Ableitungsfunktionen (KDF) beinhalten. Zu den kryptographischen Hash-Algorithmen gehören
  • MD5 (Nachrichtendigest 5)
  • Sichere Hash-Algorithmen (SHA)^[7] wie z.B. SHA-256, der einen 256-Bit-Hashwert für eine Nachricht erzeugt.

Wie jeder effektive Kryptoalgorithmus sind auch die oben genannten Algorithmen mit mehreren kritischen Anforderungen ausgestattet, die weit über den Rahmen dieses kurzen Artikels hinausgehen. Aus einer breiten Perspektive betrachtet, müssen schlüsselbasierte Algorithmen jedoch einen Chiffriertext erzeugen, der ohne den Schlüssel praktisch unmöglich (oder zumindest wirtschaftlich nicht machbar) zu entschlüsseln ist. Hash-Algorithmen ihrerseits müssen Hash-Werte schnell erzeugen, indem sie denselben Hash-Wert für die gleiche Eingangsnachricht erzeugen, aber einen deutlich anderen Hash-Wert schon bei einer geringfügigen Änderung in der Eingangsnachricht erzeugen, während sie niemals den gleichen Hash-Wert für zwei verschiedene Nachrichten erzeugen und niemals die ursprüngliche Nachricht mit einem bestimmten Hash-Wert erzeugen.

Obwohl die Details dieser und anderer Kryptoalgorithmen sehr unterschiedlich sind, beruhen sie alle auf einer Reihe von Manipulationen, Transformationen und anderen mathematischen Operationen auf niedriger Ebene, die dazu dienen, diese allgemeinen Ziele zu erreichen. Zum Beispiel wandelt die AES-Chiffre Klartext in Chiffretext um, indem sie eine Reihe von "Runden" verwendet, die eindeutige "runde Schlüssel" enthalten, die vom ursprünglichen geheimen Schlüssel des Benutzers abgeleitet sind (Listing 1).

Kopieren
Cipher(byte in[4*Nb], byte out[4*Nb], word w[Nb*(Nr+1)]) 
begin 
   byte  state[4,Nb]
 
  state = in
 
   AddRoundKey(state, w[0, Nb-1])
 
    for round = 1 step 1 to Nr–1
        SubBytes(state)
        ShiftRows(state)
        MixColumns(state)
        AddRoundKey(state, w[round*Nb, (round+1)*Nb-1]) 
    end for 
 
    SubBytes(state)
    ShiftRows(state)
    AddRoundKey(state, w[Nr*Nb, (Nr+1)*Nb-1]) 
 
    out = state
end

Listing 1: Dieser Pseudocode beschreibt die Sequenzen von Operationen bei der Nachrichtenverschlüsselung, bei denen Klartext (in) in Chiffretext (out) unter Verwendung einer Menge von Werten (w), die aus dem privaten Schlüssel des Absenders abgeleitet werden, umgewandelt wird. (Code-Quelle: NIST)

Innerhalb einer Runde ersetzt die SubBytes()-Transformation jedes Byte unter Verwendung einer Substitutionstabelle (S-Box), die ihrerseits das Ergebnis einer Reihe von Transformationen ist (Abbildung 1).

Abbildung 1: In der AES-Chiffre ersetzt die SubBytes()-Stufe jedes Byte mit Hilfe einer Substitutionstabelle (S-Box). (Bildquelle: NIST)

Im nächsten Schritt in der Sequenz verschiebt die ShiftRows()-Transformation Bytes in den letzten drei Zeilen, jeweils um eine unterschiedliche Anzahl von Bytes (Abbildung 2).

Abbildung 2: Die ShiftRows()-Stufe in der AES-Chiffrierausführungssequenz verschiebt Zeilen durch zunehmende Offsets. (Bildquelle: NIST)

In den letzten Schritten der Sequenz wendet MixColumns() auf jede Spalte eine Transformation an, bei der jedes Byte in der Spalte durch das Ergebnis eines Polynoms ersetzt wird, während AddRoundKey() das Ergebnis durch eine bitweise XOR-Operation für jede Spalte unter Verwendung eines zu diesem Zweck erstellten runden Schlüssels transformiert.

Die Gesamtzahl der Runden variiert je nach Schlüsselgröße. AES-128, das einen 128-Bit-Schlüssel verwendet, erfordert 10 Runden, während AES-192 (Schlüsselgröße 192 Bit) und AES-256 (256 Bit) 12 bzw. 14 Runden erfordern. Die Entschlüsselung folgt dem gleichen Muster, indem die Prozessschritte und ihre getrennten Transformationen umgekehrt werden.

Neuere Chiffren wie ECDH, die für den Schlüsselaustausch verwendet werden, und ECDSA, die für digitale Signaturen verwendet werden, beruhen auf komplexeren mathematischen Strukturen wie den algebraischen Strukturen mit elliptischer Kurve, die durch die Formel breit definiert sind:

Gleichung 1

Mit einer sorgfältigen Auswahl der Kurvenparameter a und b und der Verwendung zusätzlicher Einschränkungen weisen die Kurven nützliche kryptographische Eigenschaften auf (wiederum über den Rahmen dieses Artikels hinaus). Obwohl vom Konzept her einfach, ist der spezifische Satz von Parametern entscheidend: Eine schlechte Auswahl von Kurvenparametern kann zu Kurven führen, die anfällig für raffinierte Angriffe bleiben. Um diese Möglichkeit auszuschließen, bietet das NIST einen Standardsatz von kryptografisch robusten Kurven, darunter P-192, P-224, P-256 und andere mit zunehmender Stärke. Die Kurvennamen entsprechen der Bitlänge der Primzahl p der Elemente im zugrundeliegenden Primzahlenfeld der Kurve.

Ein Entwickler kann diese Eigenschaften mit ECDSA nutzen, um eine Nachricht mit einer vereinbarten Kurve zu signieren und dem Empfänger den öffentlichen Schlüssel und die Signatur - ein Zahlenpaar mit der Bezeichnung r und s zur Verfügung zu stellen. Der eigentliche Unterzeichnungsprozess umfasst die folgenden Schritte:

• Ausgehend von einem Punkt auf der Kurve, dem sogenannten Basispunkt G(x,y), erzeugt der Algorithmus einen öffentlichen Schlüssel Q(x,y) durch Multiplikation des Basispunktes mit dem privaten Schlüssel des Entwicklers (d) modulo p:

Gleichung 2

• Ein weiterer Koordinatenpunkt (x₁,y₁) wird mit einer Zufallszahl k im Bereich [1 ... n-1] erzeugt:

Gleichung 3

• H(m), wird der SHA-Hash der Nachricht m, erzeugt
• Unter Verwendung der Modulo-Inverse der Zufallszahl k, k^-1 werden die endgültigen r und s Komponenten der digitalen Signatur wie folgt generiert:

Gleichung 4

Gleichung 5

Das Endergebnis ist ein Austausch, der die Nachricht authentifiziert, ihre Integrität bestätigt und ihre Unleugbarkeit gewährleistet.

Wie man Kryptographie-Algorithmen implementiert

Die Lehre, die sich aus dieser zugegebenermaßen oberflächlichen Betrachtung dieser Algorithmen ergibt, ist, dass kryptographische Algorithmen auf einer Folge von mathematischen Operationen beruhen, mit denen versucht wird, die Ergebnisse so rechenintensiv zu kompromittieren, dass es unmöglich - oder unpraktisch - ist, sie schnell genug zu vervollständigen, um für den Täter nützlich zu sein. Darüber hinaus deutet selbst eine oberflächliche Prüfung jedes Algorithmus darauf hin, dass ein IoT-Gerät mit beschränkten Ressourcen wahrscheinlich kaum eine Chance hat, eine Software-Implementierung des Algorithmus auszuführen, ohne die primären Funktionsanforderungen des Geräts zu beeinträchtigen. Schließlich bedeuten die präzisen Details des Algorithmus über die hier gezeigten Schritte hinaus, dass selbst ein subtiler Kodierungsfehler oder eine geringfügige Fehlinterpretation des Standards zu Sicherheitslücken oder sogar zum völligen Versagen des kryptographischen Prozesses führen kann.

Fehler bei der Implementierung von Algorithmen können sogar in den größten Entwicklungsorganisationen und in Anwendungen auftreten, die kritisch von diesen Algorithmen abhängen. Zum Beispiel entstand eine bekannte Schwachstelle in einer Spielkonsole, weil die firmeneigene Implementierung von ECDSA einen konstanten Wert von k verwendete, anstatt einen Zufallswert für die in Gleichung 3 gezeigte Berechnungsart. Infolgedessen konnten Hacker den geheimen Schlüssel d ableiten. Die Verwendung eines fehlerhaften Zufallsgenerators zur Erzeugung von k führte zu einem ähnlichen Exploit, der zu einem großen Bitcoin-Verlust führte.

Hardware-basierte Kryptografie-Fähigkeiten, die in Prozessoren und dedizierte Sicherheits-ICs eingebaut sind, ermöglichen es Entwicklern, die komplexen Details der Ausführung von Kryptografie-Algorithmen weitgehend zu ignorieren und sich stattdessen auf die Vorteile der Nutzung dieser Fähigkeiten zur Sicherung ihrer Anwendungen zu konzentrieren. Diese Geräte fügen eine zusätzliche Sicherheitsebene hinzu, indem sie die Datenflüsse und Operationen innerhalb des Geräts integrieren und so eine übliche Form des Angriffs beseitigen, bei der externe Busse auf Anzeichen von privilegierten Informationen überwacht werden. Neben der Bereitstellung einer vertrauenswürdigen Implementierung eines bestimmten Algorithmus ermöglicht es eine hardwarebasierte Lösung Entwicklern, Sicherheit in Designs einzubauen, ohne grundlegende Anforderungen wie Antwortlatenz und Gesamtleistung zu beeinträchtigen.

In diese Geräte eingebaute Kryptobeschleuniger entlasten den Hauptprozessor von der Ausführung der Kryptographie, so dass dieser die primäre Funktion des Designs übernehmen kann. Tatsächlich ist die hardwarebasierte Krypto-Unterstützung zu einem immer häufigeren Merkmal von Prozessoren geworden. Gleichzeitig erfordert nicht jede Anwendung die volle Kraft der Sicherheitsmaßnahmen, die durch die oben beschriebenen Algorithmen unterstützt werden. In der Tat können Entwickler eine breite Palette von beschleunigten Kryptoalgorithmen und Kombinationen von Algorithmen in Prozessoren wie den folgenden finden:

• Der MAX32631 32-Bit-Mikrocontroller von Maxim Integrated, der AES- und DSA-Chiffren unterstützt
• Maxim Integrated's MAX32520 32-Bit-MCU, die AES-, SHA- und ECDSA-Algorithmen unterstützt
• Microchip Technology's PIC 24F XLP Mitglieder der 16-Bit-Mikrocontroller-Familie, wobei Geräte wie das PIC24FJ256GA406 AES- und 3DES-Chiffren unterstützen
• Microchip Technology's 32-Bit PIC 32MZ MCU und 32-Bit SAM9X60 Mitglieder der MPU-Familie, wobei Geräte wie die PIC32MZ2048EFM144 und SAM9X60T AES- und 3DES-Chiffren sowie SHA- und HMAC-Hash-Funktionen unterstützen
• Texas Instruments' SimpleLink MCU-Familienmitglieder wie die CC1312R und CC2652R drahtlosen MCUs, die AES-, ECDH- und ECDSA-Chiffren sowie SHA-Hash-Funktionen unterstützen

Andere Sicherheitsvorrichtungen wie die Maxim Integrated DS28E38 und Microchip Technology ATECC608A integrieren Kryptobeschleuniger und verwandte Funktionen, die zur Beschleunigung von Authentifizierungsprotokollen erforderlich sind. Unter ihren breiten Kryptofähigkeiten unterstützen diese Geräte die Art von ECDSA-Operationen, wie sie oben beschrieben wurden. In einem IoT-Gerät oder intelligenten Peripheriegerät kann ein Host-Prozessor Authentifizierungs-ICs wie diese verwenden, um schnell digitale ECDSA P-256-Signaturen zu erstellen, die an ein anderes Gerät gesendet werden, oder um die ECDSA P-256-Signaturen von anderen Geräten zu authentifizieren.

Sicherheitsfähige Prozessoren und Spezialgeräte werden in der Regel mit einem breiten hardwarebasierten Sicherheitsrahmen gebaut, der zusätzliche Sicherheitsfunktionen wie z.B. Zufallszahlengeneratoren hoher Qualität bietet. Viele Geräte, die dieses Leistungsniveau bieten, nutzen die Vorteile von Zufallsrauschquellen, die den Halbleiterdesigns eigen sind, um die Entropie zu maximieren, die in echten Zufallszahlengeneratoren (TRNGs) benötigt wird. Wie in dem bereits erwähnten Bitcoin-Beispiel angedeutet, sind solche TRNGs ein wesentlicher Faktor für den ordnungsgemäßen Betrieb von kryptographischen Algorithmen.

Die integrierte Unterstützung für die sichere Speicherung von privaten Schlüsseln und anderen geheimen Daten stellt eine der wichtigsten Fähigkeiten von sicheren Designs dar. Andere architektonische Merkmale, die mit diesen und ähnlichen Prozessoren verfügbar sind, bieten ein noch höheres Maß an Sicherheitsunterstützung.

Prozessoren mit integrierten Krypto-Beschleunigern und verwandten Funktionen vereinfachen die Entwicklung sicherer Designs durch die Verwendung einfacher API-Bibliotheken (Application Programming Interface). Intuitive API-Funktionsaufrufe ermöglichen es Entwicklern, Sicherheitsimplementierungen zu abstrahieren und sich beim Zugriff auf die zugrunde liegende Hardwarefunktionalität auf die API zu verlassen. Beispielsweise können Entwickler das Maxim Integrated MAX32520-KIT Evaluierungskit für die MAX32520 MCU in Kombination mit dem Maxim Integrated Micros Software Development Kit (SDK) verwenden, um schnell sichere IoT-Bausteine zu erstellen. Zusammen mit den zugehörigen Treibern und Middleware enthält das Maxim Integrated Micros SDK Beispielfunktionen, die die grundlegenden Entwurfsmuster demonstrieren, die zum Verschlüsseln (AES128_ECB_enc()) und Entschlüsseln (AES128_ECB_dec ()) von Nachrichten mit der AES-Chiffre (Listing 2) erforderlich sind.

Kopieren
int AES128_ECB_enc(int asynchronous)
{
    printf( asynchronous ? "Test Cipher Async\n" : "Test Cipher Sync\n");
 
    char *_key = "797f8b3d176dac5b7e34a2d539c4ef36";
    char key[MXC_AES_KEY_128_LEN];
    ascii_to_byte(_key, key, MXC_AES_KEY_128_LEN);
 
    const char *iv_src = "";
    char iv_dst[16];
    ascii_to_byte(iv_src, iv_dst, 16);
 
    char *_pt= "00000000000000000000000000000000";
    char pt[MXC_AES_DATA_LEN];
    ascii_to_byte(_pt, pt, MXC_AES_DATA_LEN);
 
    mxc_ctb_cipher_req_t cipher_req = {
        (uint8_t*)pt,
        MXC_AES_DATA_LEN,
        (uint8_t*)iv_src,
        (uint8_t*)result,
        &Test_Callback };
 
    // Reset crypto block
    MXC_CTB_Init(MXC_CTB_FEATURE_CIPHER | MXC_CTB_FEATURE_DMA);
    MXC_CTB_IntEnable(asynchronous);
 
 
    MXC_CTB_Cipher_SetMode(MXC_CTB_MODE_ECB);
    MXC_CTB_Cipher_SetCipher(MXC_CTB_CIPHER_AES128);
    MXC_CTB_Cipher_SetKeySource(MXC_CTB_CIPHER_KEY_SOFTWARE);
 
    // Load key into cipher key register
    MXC_CTB_Cipher_SetKey((uint8_t *)key, MXC_AES_KEY_128_LEN);
 
    if (asynchronous){
        wait = 1;
        MXC_CTB_Cipher_EncryptAsync(&cipher_req);
        while( wait );
    } else {
        MXC_CTB_Cipher_Encrypt(&cipher_req);
    }
    const char *_expected = "322FD6E503395CDB89A77AC53D2B954F";
    char expected[MXC_AES_DATA_LEN];
    ascii_to_byte(_expected, expected, MXC_AES_DATA_LEN);
 
    return AES_check(result, expected, MXC_AES_DATA_LEN);
 
}
 
int AES128_ECB_dec(int asynchronous)
{
    printf( asynchronous ? "Test Cipher Async\n" : "Test Cipher Sync\n");
 
    char *_key = "797f8b3d176dac5b7e34a2d539c4ef36";
    char key[MXC_AES_KEY_128_LEN];
    ascii_to_byte(_key, key, MXC_AES_KEY_128_LEN);
 
    const char *iv_src = "";
    char iv_dst[16];
    ascii_to_byte(iv_src, iv_dst, 16);
 
    char *_pt= "322FD6E503395CDB89A77AC53D2B954F";
    char pt[MXC_AES_DATA_LEN];
    ascii_to_byte(_pt, pt, MXC_AES_DATA_LEN);
 
    mxc_ctb_cipher_req_t cipher_req = {
        (uint8_t*)pt,
        MXC_AES_DATA_LEN,
        (uint8_t*)iv_src,
        (uint8_t*)result,
        &Test_Callback };
 
    // Reset crypto block
    MXC_CTB_Init(MXC_CTB_FEATURE_CIPHER | MXC_CTB_FEATURE_DMA);
    MXC_CTB_IntEnable(asynchronous);
 
 
    MXC_CTB_Cipher_SetMode(MXC_CTB_MODE_ECB);
    MXC_CTB_Cipher_SetCipher(MXC_CTB_CIPHER_AES128);
    MXC_CTB_Cipher_SetKeySource(MXC_CTB_CIPHER_KEY_SOFTWARE);
 
    // Load key into cipher key register
    MXC_CTB_Cipher_SetKey((uint8_t *)key, MXC_AES_KEY_128_LEN);
 
    if (asynchronous){
        wait = 1;
        MXC_CTB_Cipher_DecryptAsync(&cipher_req);
        while( wait );
    } else {
        MXC_CTB_Cipher_Decrypt(&cipher_req);
    }
    const char *_expected = "00000000000000000000000000000000";
    char expected[MXC_AES_DATA_LEN];
    ascii_to_byte(_expected, expected, MXC_AES_DATA_LEN);
 
    return AES_check(result, expected, MXC_AES_DATA_LEN);
}

Listing 2: Entwickler können Beispielcode im Maxim Integrated Micros SDK-Distributionspaket untersuchen, um grundlegende Entwurfsmuster zu erlernen, die für die Durchführung der AES-Verschlüsselung (AES128_ECB_enc()) und Entschlüsselung (AES128_ECB_dec ()) unter Verwendung der integrierten Kryptographiefunktionen der MAX32520 MCU erforderlich sind. (Codequelle: Maxim Integrated)

Authentifizierungsprotokolle

Robuste Implementierungen von Kryptographie-Algorithmen sind besonders wichtig, um eine sichere Grundlage für die in Anwendungen verwendeten Protokolle höherer Ebenen zu schaffen. Protokolle auf höherer Ebene wie Transport Layer Security (TLS) führen ihre Operationen in der Regel unter Verwendung eines definierten Satzes kryptographischer Algorithmen, einer so genannten Cipher Suite, durch. Bei TLS helfen Algorithmen, die aus einer vereinbarten Chiffriersuite stammen, die Authentifizierung und Vertraulichkeit in Kommunikationssitzungen zwischen einem IoT-Geräte-Client und einem Host-Server zu gewährleisten. TLS 1.2[8] durchläuft eine bestimmte Sequenz von Transaktionen, um Parameter auszuhandeln, Authentifizierung durchzuführen und Sitzungsschlüssel auszutauschen, bevor es zum Datenaustausch übergeht (Abbildung 3).

Abbildung 3: Das TLS 1.2 Protokoll zur Sitzungserstellung verwendet eine Vielzahl von Algorithmen aus einer vereinbarten Verschlüsselungssuite für die Authentifizierung, den Schlüsselaustausch und den laufenden Datenaustausch. (Bildquelle: Texas Instruments)

Die Authentisierung wird durch die Feststellung der Identität des Servers (und optional des Clients) durch Verifizierung von Sicherheitszertifikaten gewährleistet, die für jeden Teilnehmer den jeweiligen öffentlichen Schlüssel enthalten. Hier sendet jeder Teilnehmer eine mit seinem privaten Schlüssel verschlüsselte Nachricht. Da der empfangene öffentliche Schlüssel nur eine Nachricht entschlüsseln kann, die mit seinem zugehörigen privaten Schlüssel verschlüsselt wurde, kann jeder Teilnehmer bestätigen, dass der Anbieter eines Zertifikats tatsächlich dieses Zertifikat besitzt.

In der nächsten TLS-Stufe führen die Teilnehmer eine Reihe von Transaktionen aus, um einen gemeinsamen Sitzungsschlüssel zu erstellen. Dieser gemeinsame Sitzungsschlüssel wird dann zur Verschlüsselung des eigentlichen Nachrichtenverkehrs verwendet, wodurch die Vertraulichkeit des Nachrichtenaustauschs für diese Sitzung gewährleistet wird.

Mehrere Protokolloptionen ermöglichen es Entwicklern, diesen generischen TLS-Sitzungserstellungsprozess zu verfeinern, manchmal zum Nachteil der Gesamtsicherheit. Darüber hinaus können die Entwickler während des Parameteraustauschprozesses eine andere Verschlüsselungssuite verwenden, indem sie für jede Phase des Protokolls eine geeignete Kombination der von TLS 1.2 unterstützten Algorithmen auswählen, einschließlich

• Schlüssel-Erstellung: RSA, DH, ECDH
• Authentifizierung: RSA, DSA, ECDSA
• Chiffren: 3DES, AES
• Authentifizierung der Nachricht: SHA

Die neueste Version von TLS, TLS 1.3[9], bietet zusätzliche Sicherheit, indem der Schlüsselaustausch zuerst durchgeführt wird, um den Prozess der Sitzungserstellung besser zu schützen. Grundsätzlich verfügt TLS 1.3 weitgehend über die TLS 1.2-Chiffrier-Suite zugunsten robusterer Algorithmen, einschließlich der Verwendung der HMAC-basierten Extract-and-Expand Key Derivation Function (HKDF) und der Algorithmen zur authentifizierten Verschlüsselung mit zugehörigen Daten (AEAD). Die AEAD-Algorithmen tragen dem breiten Bedürfnis Rechnung, die Authentizität, Integrität und Vertraulichkeit von Nachrichten zu gewährleisten. Diese Algorithmen tun dies, indem sie die verschlüsselte Nachricht mit einem MAC kombinieren, der seriell (Abbildung 4, links), parallel (Abbildung 4, rechts) oder in einer Kombination aus beiden generiert werden kann.

Abbildung 4: AEAD bietet Authentifizierung und Vertraulichkeit, indem es einen MAC mit dem Chiffriertext verbindet und dabei unter anderem Verfahren namens "encrypt-then-MAC" (links) und "encrypt-and-MAC" (rechts) verwendet, die den MAC in Serie bzw. parallel berechnen. (Bildquelle: Wikipedia)

Wachsende Sicherheitsstärke

Diese Entwicklung von Kryptographie-Algorithmen und zugehörigen Protokollen verfolgt den anhaltenden Wettlauf zwischen Kryptographie-Experten, die entschlossen sind, die Sicherheit zu stärken, und denen, die ebenso entschlossen sind, sie zu besiegen. In dem Bestreben, die Sicherheit zu erhöhen, schufen Experten beispielsweise die ECDSA als eine ECC-Variante der DSA, die ihrerseits eine Variante früherer Chiffren ist. Das Ergebnis ist, dass die ECDSA die gleiche Sicherheitsstärke wie die DSA erreichen kann, aber mit einer viel kleineren Schlüsselgröße.

In der Kryptographie wird die Sicherheitsstärke eines Algorithmus in Form von x Bits und der Erwartung definiert, dass ein Angriff etwa 2^x Operationen zur Ableitung des dem Algorithmus zugrunde liegenden privaten Schlüssels erfordern würde. So definiert, können die verschiedenen Klassen von Algorithmen deutlich unterschiedliche Schlüssellängen erfordern, um vergleichbare Sicherheitsniveaus zu erreichen (Tabelle 1).

Tabelle 1: Verschiedene Klassen von Kryptographie-Algorithmen können deutlich unterschiedliche Schlüsselgrößen für die öffentlichen Schlüssel (L) oder privaten Schlüssel (N, k, f) erfordern, um vergleichbare Sicherheitsstärken zu erreichen. (Bildquelle: NIST)

In dieser Tabelle aus dem NIST entsprechen die Parameter des FFC-Algorithmus L und N den Größen des öffentlichen Schlüssels bzw. des privaten Schlüssels. Bei IFC- und ECC-Algorithmen entsprechen k und f jeweils der Schlüsselgröße. Das NIST stellt fest, dass Algorithmen mit einer Sicherheitsstärke von ≤80 (orangefarbener Hintergrund in der Tabelle) nicht mehr für den staatlichen Informationsschutz zugelassen sind, während andere (gelber Hintergrund) aus Effizienzgründen noch nicht in die NIST-Standards aufgenommen wurden.

Dieser Schritt zu einer höheren Sicherheitsstärke treibt die Entwicklung von Chiffren und empfohlenen Chiffrierprogrammen weiter voran. Zum Beispiel ersetzte die Commercial National Security Algorithm (CNSA) Suite der U.S. National Security Agency (NSA) die frühere NSA Suite B durch Empfehlungen für die Verwendung robusterer Parameter, die zum Schutz von als streng geheim eingestuften Informationen erforderlich sind (Tabelle 2).

Tabelle 2: Die von der NSA empfohlene CNSA Suite enthält Kryptographie-Algorithmen mit Empfehlungen für die zum Schutz hochsensibler Informationen erforderliche Mindestsicherheitsstärke. (Bildquelle: DigiKey, aus NSA-Daten)

Mit Blick auf die Zukunft wird die Verfügbarkeit von Quantencomputer-Fähigkeiten eine dramatische Diskontinuität in der Sicherheit im Allgemeinen und bei den Kryptographie-Algorithmen im Besonderen darstellen.

Fazit

IoT-Geräte und andere damit verbundene Designs sehen sich einer wachsenden Zahl von Bedrohungen gegenüber, die zunehmend robuste Sicherheitsmethoden erfordern, die auf einer breiten Palette von Kryptographie-Algorithmen basieren. Diese Algorithmen, die entwickelt wurden, um das Knacken von Sicherheit zu verhindern, beruhen auf einer Reihe von Transformationen und mathematischen Operationen, um Klartext zu Chiffretext zu verschlüsseln und Chiffretext wieder zu Klartext zu entschlüsseln. Wie gezeigt, ist es möglich, hardwarebasierte Implementierungen dieser Algorithmen zu verwenden, damit Entwickler leichter starke Sicherheit in ein Design einbauen können, ohne dessen primäre Anforderungen an Funktionalität und Leistung zu beeinträchtigen.

Referenzen:

1. Wie ein Aquarium dabei half, ein Kasino zu hacken
2. FIPS PUB 197: der offizielle AES-Standard
3. IETF RFC 3526 (DH)
4. NIST SP 800-56B Rev. 1 (DOI) (RSA)
5. NIST SP 800-56A (ECDH)
6. FIPS Pub 186-4 (digitale Unterschrift)
7. FIPS PUB 180-4: Sicherer Hash-Standard (SHS)
8. IETF RFC 5246 (TLS 1.2)
9. IETF RFC 8446 (TLS 1.3)