IoT-Anwendungen schnell und sicher mit der Google Cloud verbinden

Cloud-Dienste für Unternehmen, beispielsweise Google Cloud, bieten IoT-Entwicklern eine umfassende Auswahl an Funktionalitäten, von skalierbaren virtuellen Maschinendiensten bis zu schlüsselfertigen Anwendungen im Bereich der Künstlichen Intelligenz (KI). Eine grundlegende Voraussetzung für diese Dienste ist die Nutzung spezieller Sicherheitsverfahren zur Einrichtung und Aufrechterhaltung sicherer Verbindungen zwischen den IoT-Geräten und der Cloud. Für Entwickler kann die Implementierung geeigneter Sicherheitsmechanismen jedoch zu Verzögerungen führen und die Umsetzung von Design-Projekten, bei denen der Zeitrahmen ohnehin sehr eng gesteckt ist, zusätzlich erschweren.

Das Entwicklungsboard PIC-IoT WG von Microchip Technology beinhaltet einen speziellen Sicherheits-IC und bietet damit eine schlüsselfertige Lösung für die Verbindung zur Google Cloud. Mit dem speziellen Sicherheits-IC bietet das Kit eine umfassende Plattform zur schnellen Entwicklung von IoT-Designs, die sich sicher mit Google Cloud-Diensten verbinden können. In diesem Artikel werden die wichtigsten Anforderungen an sichere Verbindungen beschrieben, und es wird dargestellt, wie Entwickler mithilfe des PIC-IoT WG bei einem typischen IoT-Design diese Anforderungen erfüllen können.

Sicherheit erfordert Komplexität

Die Möglichkeit, Verbindungen zwischen IoT-Geräten und Remote-Host-Servern sicher zu gestalten, ist eine grundlegende Voraussetzung für den generellen Schutz von IoT-Anwendungen und den entsprechenden Ressourcen im Unternehmensnetzwerk. Die Server und andere unternehmensweit genutzte Systeme können eine Leistung und Möglichkeiten bereitstellen, die in IoT-Geräten einfach nicht vorhanden sind, da sie aus Mikrocontrollern mit begrenzten Ressourcen und geringem Speicherplatz bestehen. Für einfache IoT-Geräte, die Sensordaten liefern oder zum richtigen Zeitpunkt Aktuatoren steuern sollen, können bereits die Prozessanforderungen für die Umsetzung der grundlegendsten Sicherheitsalgorithmen schlicht nicht umsetzbar sein.

Sicherheitsverfahren basieren auf dem einfachen Grundsatz, dass das Durchdringen einer Sicherheitsbarriere aufwendiger sein sollte als der Wert, der durch die Barriere geschützt wird. Bei auf Algorithmen basierenden Sicherheitsverfahren bedeutet das, dass die Entschlüsselung einer verschlüsselten Nachricht oder die Verletzung eines Authentifizierungsprotokolls aufgrund der benötigten Rechenkapazitäten unmöglich sein sollte. Wenigstens sollte die Verletzung dieser Sicherheitsverfahren ein Maß an Rechnerressourcen und Zeitaufwand erfordern, welche den Wert oder die zeitliche Verfügbarkeit der geschützten Daten oder Kommunikationskanäle übersteigt. Somit sind kryptographische Algorithmen darauf ausgerichtet, wertvolle Daten mithilfe eines geheimen Schlüssels hinter einer Reihe von komplexen, rechenintensiven Prozessschritten zu verstecken. So sorgt beispielsweise der vielfach genutzte Algorithmus Advanced Encryption Standard (AES) dafür, dass Daten über mehrere Runden verarbeitet werden, wobei jede einzelne eine Reihe von Schritten umfasst, angefangen bei einem geheimen Schlüssel über Byte-Substitution und Verschiebungen bis zu Matrix-Berechnungen (Abbildung 1).

Abbildung 1: Um eine Entschlüsselung zu aufwendig und damit unmöglich zu machen, verwenden kryptographische Algorithmen bewusst eine Reihe komplexer Manipulationen wie diesen Schritt im AES-Algorithmus, der Daten mit Bits von einem individuellen Schlüssel verbindet. (Bildquelle: Wikimedia Commons)

Bei symmetrischen kryptographischen Algorithmen wie AES nutzt der Empfänger der verschlüsselten Nachricht denselben Schlüssel zur Entschlüsselung der Daten. Im Gegensatz dazu nutzen asymmetrische Algorithmen ein Schlüssel-Paar, d.h. einen privaten und einen öffentlichen Schlüssel. Dadurch sinken die Risiken, die durch die gemeinsame Nutzung eines Schlüssels entstehen, allerdings nimmt die Rechenkomplexität zu. Bei diesem Verfahren tauschen der Sender und der Empfänger die öffentlichen Schlüssel aus, halten ihre jeweiligen privaten Schlüssel jedoch geheim. So kann eine Seite den öffentlichen Schlüssel der anderen Seite nutzen, um eine Nachricht zu verschlüsseln – eine Entschlüsselung ist aber nur mit dem privaten Schlüssel der anderen Seite möglich.

Um einen höheren Schutz zu gewährleisten, setzen fortschrittliche Algorithmen auf Verschlüsselungsverfahren mit einem asymmetrischen öffentlichen Schlüssel, um einen kurzfristig gültigen privaten Schlüssel sicher auszutauschen, welcher dann für die Verschlüsselung der Daten verwendet wird, und zwar nur für die Dauer des Austauschs der Nachrichten. Da der Schlüsselaustausch besonders kritisch ist, verbergen moderne Algorithmen wie das Verfahren Elliptic Curve Diffie-Hellman (ECDH) die geheimen Daten noch tiefer unter komplexen Berechnungen elliptischer Kurven. Authentifizierungsprotokolle wie Transport Layer Security (TLS) verbinden Verfahren wie den Diffie-Hellman-Schlüsselaustausch mit formalen Identifizierungsmethoden. Dabei kommen digitale Zertifikate zum Einsatz, die einen öffentlichen Schlüssel in eine nachprüfbare digitale Signatur von einer Zertifizierungsstelle (CA) einbetten, welche die Echtheit des Zertifikats bestätigt.

Wie sich aus dieser kurzen Beschreibung entnehmen lässt, setzen Sicherheitsverfahren auf mehrere Schichten kryptographischer Algorithmen und Protokolle, die letztlich auf privaten Schlüsseln basieren. Obwohl diese Schichten regelmäßig von Hackern angegriffen werden, bricht die gesamte Sicherheitsstruktur in dem Moment zusammen, wenn die privaten Schlüssel bekannt werden können.

Aus diesem Grund ist die hardwarebasierte Speicherung von sicheren Schlüsseln eine grundlegende Voraussetzung für die Sicherheit von IoT-Geräten. Darüber hinaus macht die Rechenkomplexität der Algorithmen und Protokolle den Einsatz spezieller Kryptographiesysteme erforderlich, die Mikrocontroller mit begrenzten Ressourcen von komplexen Berechnungen entlasten können.

Hardwarebasierte Sicherheit

Spezielle Hardware-Geräte für sichere Elemente wie der ATECC608A CryptoAuthentication-IC von Microchip Technology bieten die benötigten Merkmale, um Daten geheim zu halten und die Ausführung kryptographischer Algorithmen zu beschleunigen. Zu den Merkmalen des ATECC608A zählt ein EEPROM auf dem Chip für die sichere Speicherung von bis zu 16 Schlüsseln, Zertifikaten und anderen Daten, und er bietet auch weitere wichtige Funktionen wie einen NIST SP 800-90A/B/C-kompatiblen Zufallszahlengenerator.

Damit ist der ATECC608A nicht nur ein sicheres Speichergerät, sondern es beschleunigt auch die Durchführung verschiedener Algorithmen wie AES für symmetrische Kryptographie und ECDH für asymmetrische Kryptographie. Außerdem unterstützt das Gerät Dienste auf höheren Ebenen wie Secure Boot (siehe „Secure Boot in IoT-Gerätedesigns mit Krypto-Chip implementieren“).

Neben den direkten Leistungsvorteilen, die durch die Entlastung bei der Ausführung dieser Algorithmen entstehen, schafft die Integration der Krypto-Systeme, der sicheren Speicherung und anderer Merkmale gleichzeitig auch eine weitere Sicherheitsebene: Die Schlüssel kommen nicht mit nicht vertrauenswürdigen Instanzen in Verbindung. Zu diesen Instanzen zählen Mikrocontroller, die nicht auf Sicherheit ausgelegt sind, die Software auf diesen Mikrocontrollern und die Personen, die diese Software nutzen. Die Tatsache, dass das Gerät private Schlüssel erstellen kann, ermöglicht mehr Sicherheit bei der Bereitstellung an Produktions- oder Distributionsstandorten.

Somit verringert sich die Anzahl der Angriffsvektoren gegenüber konventionellen softwarebasierten Sicherheitsverfahren. Unterstützt wird damit die Art von mehrstufigem Sicherheitskonzept, die wirksamen Sicherheitsstrategien zugrunde liegt.

Die umfassende Integration der Funktionalitäten in den ATECC608A vereinfacht die Anforderungen an die Hardware-Schnittstelle. Das Gerät fungiert als ein weiteres I²C-Peripheriegerät, das sogar den I²C-Bus eines Mikrocontrollers mit anderen Geräten teilen kann, beispielsweise mit digitalen Sensoren wie dem MCP9808 von Microchip Technology (Abbildung 2).

Abbildung 2: Da der ATECC608A CryptoAuthentication-IC von Microchip Technology (links) seine Sicherheitsprozesse vollständig auf dem Chip durchführt, kann er eine einfache I²C-Hardware-Schnittstelle zur gemeinsamen Nutzung mit anderen I²C-Geräten wie dem I²C-Digitaltemperatursensor MCP9808 von Microchip Technology (rechts) bieten. (Bildquelle: Microchip Technology)

Auf Software-Ebene führt die umfangreiche Funktionalität des ATECC608A jedoch zu einer komplexeren Schnittstelle. Das CryptoAuthLib-Archiv von Microchip Technology unterteilt die Schnittstelle in eine Reihe intuitiver Funktionsaufrufe, die über die Anwendungsprogrammierschnittstelle (API) des CryptoAuthLib verfügbar sind. Das Archiv ist mit den entsprechenden Treibern und der Middleware in der MPLAB X Integrierten Entwicklungsumgebung (IDE) von Microchip Technology zusammengefasst. Obwohl die API und die Treiber des CryptoAuthLib-Archivs die Grundelemente für individuelle Designs mit dem ATECC608A bilden, stehen die Entwickler vor weiteren Herausforderungen, wenn sie die vollständige Sicherheitskette implementieren sollen, die für die sichere Verbindung mit der Google Cloud erforderlich ist. Das Entwicklungsboard PIC-IoT WG von Microchip Technology bietet auch hierfür eine Lösung.

Entwicklung einer End-to-End-IoT-Anwendung

Das auf dem ATECC608A und dem günstigen 16-Bit-Microcontroller PIC24FJ128GA705 von Microchip Technology basierende PIC-IoT-Board ist ein drahtloses IoT-Design und umfasst das Wi-Fi-Modul ATWINC1510 von Microchip Technology, den Umgebungslichtsensor TEMT6000X01 von Vishay Semiconductor und den I²C-Temperatursensor MCP9808. Darüber hinaus können Entwickler die Hardware-Grundplattform problemlos erweitern, indem sie Sensoren und Aktuatoren hinzufügen, die von den Hunderten verfügbaren Click-Boards von MikroElektronika bereitgestellt werden. Für die Softwareentwicklung bietet Microchip Technology die MPLAB X IDE und das dazugehörige Rapid-Prototyping-Tool MPLAB Code Configurator (MCC).

Die Entwicklungskarte und die dazugehörige Software bilden eine schlüsselfertige Plattform für die Erschließung einer einfachen End-to-End-IoT-Anwendung, bei der das IoT-Sensorgerät sicher mit den Google Cloud-Diensten verbunden ist. Das Kit setzt ein einzigartiges Verfahren um, das die gegenseitige Authentifizierung sogar bei IoT-Geräten mit begrenzten Ressourcen ermöglicht. Bei diesem Verfahren kann das IoT-Gerät leichte TLS-Dienste, um die Google-Seite der Verbindung zu authentifizieren, und JavaScript Object Notation (JSON) Web Tokens (JWT) nutzen, um sich selbst bei den Google-Servern zu authentifizieren (siehe „Eine einfachere Lösung für die sichere Verbindung von IoT-Geräten mit der Cloud“). Zusammen mit Gerätetreibern, Kartenunterstützungspaketen und Middleware-Diensten präsentiert Microchip Technology dieses Verfahren als Teil einer vollständigen Muster-IoT-Anwendung, die über die MPLAB-Entwicklungssuite für das PIC-IoT-Board verfügbar ist.

Beim Durcharbeiten der Muster-Anwendung können die Entwickler Erfahrungen sammeln, und zwar nicht nur mit Cloud-Anwendungen, sondern auch mit IoT-spezifischen Diensten, die von den großen Cloud-Dienstleistern für die Verbindung zwischen den IoT-Geräten und ihrer Cloud angeboten werden. So können IoT-Geräte über Google Cloud IoT Core auf Ressourcen in der Google Cloud zugreifen. Damit stehen eine Reihe von Diensten zur Verfügung, die für die Verbindung der Geräte, die Verwaltung der dazugehörigen Metadaten und darüber hinaus benötigt werden (Abbildung 3).

Abbildung 3: Wie bei anderen Cloud-Anbietern für Unternehmen hat auch die Google Cloud ein spezielles Dienstangebot, Google Cloud IoT Core, das die besonderen Anforderungen unterstützen soll, die mit der Integration von IoT-Geräten in Cloud-Ressourcen verbunden sind. (Bildquelle: Google)

Nutzung von Cloud-Diensten

Im Backend bietet Google Cloud IoT Core den Geräten Zugriff auf hochwertige Ressourcen in der Google Cloud über eine Datenvermittlung mithilfe eines Publication/Subscription(Pub/Sub)-Modells. Im Frontend bietet IoT Core eine Brücke für die Verbindung des IoT-Geräts über Hypertext Transfer Protocol (HTTP) oder Message Queuing Telemetry Transport (MQTT). MQTT ist ein standardisiertes Nachrichtenprotokoll der Internationalen Organisation für Normung (ISO), das auf minimale Kommunikationsbandweite und die Ressourcen von IoT-Geräten ausgelegt ist. Die Softwareanwendung von Microchip Technology für das PIC-IoT-Board zeigt die Nutzung von MQTT auf Grundlage einer Verbindung über einen Transmission Control Protocol/Internet Protocol(TCP/IP)-Sockel, die mit dem oben beschriebenen Verfahren der gegenseitigen Authentifizierung TLS/JWT gesichert ist.

Nach dem Aufbau der sicheren Verbindung nutzt die Software MQTT, um mit den Google Cloud IoT Core-Diensten zu kommunizieren und einen Kanal oder eine „Topic“ einzurichten, über die Sensordaten an die Google Cloud gesendet werden und auf Befehle von den Cloud-Diensten reagiert wird. Google fordert die Software des IoT-Geräts auf, sich anzumelden, und sendet dann Daten an eine bestimmte Topic in der Form /devices/{deviceID}/events; dabei besteht auch die Möglichkeit, unter der allgemeinen Topic events noch Subtopics einzurichten. Neben weiteren Topics, beispielsweise für Merkmale zur Geräteverwaltung, erstellt Google eine Topic /devices/{device-id}/commands, um Befehle aus der Cloud an das IoT-Gerät zu senden. Google bietet sogar eine allgemeine Topic (/devices/{device-id}/commands/#), über die IoT-Geräte sämtliche Befehle empfangen können, die durch eine beliebige Subtopic gesendet werden.

Die PIC-IoT-Anwendung stellt die verschiedenen Verfahren mithilfe einer erweiterbaren Softwarearchitektur dar, die auf Timern und Callbacks basiert. Aufgrund dieser Architektur muss das Hauptmodul (main.c) nur die Hauptroutine (main()) und die Routinen auf Anwendungsebene bereitstellen, um Nachrichten senden (sendToCloud()) und empfangen (receivedFromCloud()) zu können. Die Hauptroutine main() selbst ruft lediglich zwei Initialisierungsroutinen auf, bevor sie in eine Endlosschleife übergeht, die den Timer-Scheduler ausführt und einen Platzhalter für Nutzerroutinen bietet (Listing 1).

Kopieren void receivedFromCloud(uint8_t *topic, uint8_t *payload) {     char *toggleToken = "\"toggle\":";     char *subString;         if ((subString = strstr((char*)payload, toggleToken)))     {         LED_holdYellowOn( subString[strlen(toggleToken)] == '1' );     }         debug_printer(SEVERITY_NONE, LEVEL_NORMAL, "topic: %s", topic);     debug_printer(SEVERITY_NONE, LEVEL_NORMAL, "payload: %s", payload); }   // This will get called every 1 second only while we have a valid Cloud connection void sendToCloud(void) {    static char json[70];             // This part runs every CFG_SEND_INTERVAL seconds    int rawTemperature = SENSORS_getTempValue();    int light = SENSORS_getLightValue();    int len = sprintf(json, "{\"Light\":%d,\"Temp\":\"%d.%02d\"}", light,rawTemperature/100,abs(rawTemperature)%100);      if (len >0) {       CLOUD_publishData((uint8_t*)json, len);       LED_flashYellow();    } }   #include "mcc_generated_files/application_manager.h"   /*                          Main application  */ int main(void) {     // initialize the device     SYSTEM_Initialize();     application_init();       while (1)     {         // Add your application code         runScheduler();     }       return 1; } 

Listing 1: Die Muster-Anwendung von Microchip Technology für das PIC-IoT-Board nutzt eine Reihe von Timern und Callbacks, um die Hauptschleife zu vereinfachen, sodass die Entwickler problemlos ihre eigenen Dienst- und Anwendungsroutinen hinzufügen können. (Codequelle: Microchip Technology)

Die Routine SYSTEM_Initialize(), die vor der Endlosschleife aufgerufen wird, initialisiert die Hardwarekomponenten, insbesondere die Uhr, den Analog-Digital-Wandler (ADC), Interrupts und andere. Die Routine application_init() initialisiert verschiedene Softwaresysteme, insbesondere das CryptoAuthentication-Archiv, und sie stellt die Verbindung zum Wi-Fi und zur Cloud her. Als Letztes stellt die Routine application_init() einen Timer auf 100 Millisekunden (ms) für die Ausführung von MAIN_dataTask(). Wenn der Timer abgelaufen und MAIN_dataTask() aufgerufen ist, prüft die Routine die Verbindung zur Cloud und ruft einmal pro Sekunde sendToCloud() auf, wodurch die LEDs der Karte so eingestellt werden, dass sie den jeweiligen Betriebszustand der Anwendung anzeigen (Listing 2). Gleichzeitig können die Entwickler auf einem frei zugänglichen Sandbox-Account, der von Microchip Technology auf der Google Cloud bereitgestellt wird, die Anzeige der Sensorwerte sehen.

Kopieren // This gets called by the scheduler approximately every 100ms uint32_t MAIN_dataTask(void *payload) {    static time_t previousTransmissionTime = 0;       // Get the current time. This uses the C standard library time functions    time_t timeNow = time(NULL);       // Example of how to send data when MQTT is connected every 1 second based on the system clock    if (CLOUD_isConnected())    {       // How many seconds since the last time this loop ran?
int32_t delta = difftime(timeNow,previousTransmissionTime);          if (delta >= CFG_SEND_INTERVAL)       {          previousTransmissionTime = timeNow;                   // Call the data task in main.c          sendToCloud();       }    }       if(shared_networking_params.haveAPConnection)     {         LED_BLUE_SetLow();     }     else     {         LED_BLUE_SetHigh();     }     if(shared_networking_params.haveERROR)     {         LED_RED_SetLow();     }     else     {         LED_RED_SetHigh();     }     if (LED_isBlinkingGreen() == false)     {         if(CLOUD_isConnected())         {             LED_GREEN_SetLow();         }         else         {             LED_GREEN_SetHigh();         }     }       // This is milliseconds managed by the RTC and the scheduler, this return makes the    //      timer run another time, returning 0 will make it stop    return MAIN_DATATASK_INTERVAL; } 

Listing 2: Mit einem Mechanismus aus Timern und Callbacks sendet die Muster-Anwendung des PIC-IoT von Microchip Technology einmal pro Sekunde Sensordaten an die Cloud (CFG_SEND_INTERVAL=1) und aktualisiert die LEDs der Karte, sodass sie den jeweils aktuellen Betriebszustand anzeigen. (Codequelle: Microchip Technology)

Die Verarbeitung von Befehlen aus der Cloud ist genauso einfach. Die Muster-Anwendung zeigt, wie sich eine Callback-Routine wie receivedFromCloud() für die Verarbeitung erhaltener Nachrichten einsetzen lässt. In der Initialisierungsphase ruft die oben genannte Routine application_init() eine Routine (CLOUD_subscribe()) auf, die den Anmeldungsprozess in der Google Cloud durchführt. Während dieses Prozesses aktualisiert die Software eine Tabelle (imqtt_publishReceiveCallBackTable) mit dem Callback zu receivedFromCloud() (Listing 3). In diesem Fall nutzt die Muster-Anwendung die Topic config und hartkodiert den Index in die Tabelle, da NUM_TOPICS_SUBSCRIBE=1, doch hier wären auch die allgemeineren Befehls-Topics und die entsprechenden Subtopics möglich.

Kopieren
void CLOUD_subscribe(void)
{
   mqttSubscribePacket cloudSubscribePacket;
   uint8_t topicCount = 0;
 
   // Variable header
   cloudSubscribePacket.packetIdentifierLSB = 1;
   cloudSubscribePacket.packetIdentifierMSB = 0;
 
   // Payload
   for(topicCount = 0; topicCount < NUM_TOPICS_SUBSCRIBE; topicCount++)
   {
      sprintf(mqttSubscribeTopic, "/devices/%s/config", deviceId);
      cloudSubscribePacket.subscribePayload[topicCount].topic = (uint8_t *)mqttSubscribeTopic;
      cloudSubscribePacket.subscribePayload[topicCount].topicLength = strlen(mqttSubscribeTopic);
      cloudSubscribePacket.subscribePayload[topicCount].requestedQoS = 0;
 
      imqtt_publishReceiveCallBackTable[0].topic = mqttSubscribeTopic;
      imqtt_publishReceiveCallBackTable[0].mqttHandlePublishDataCallBack = receivedFromCloud;
      MQTT_SetPublishReceptionHandlerTable(imqtt_publishReceiveCallBackTable);
   }
   
   if(MQTT_CreateSubscribePacket(&cloudSubscribePacket) == true)
   {
      debug_printInfo("CLOUD: SUBSCRIBE packet created");
      sendSubscribe = false;
   }
}

Listing 3: Die Muster-Anwendung von Microchip Technology zeigt, wie die Entwickler Callback-Routinen einfach mit erhaltenen MQTT-Nachrichten verbinden können; in diesem Fall wird die Funktion receivedFromCloud() als Callback für erhaltene Nachrichten von der Standard-Topic definiert. (Codequelle: Microchip Technology)

Das Hardware- und Softwarepaket PIC-IoT ist sofort einsatzbereit, und die Entwickler können gleich damit beginnen, verschiedene Szenarien für das Senden und Empfangen von Daten aus der Google Cloud durchzuspielen. Die PIC-IoT-Hardware und das ATECC608A CryptoAuthentication-Gerät sind so vorkonfiguriert, dass sie Google Cloud IoT Core und dieses Nutzungsmodell unterstützen. Die Entwickler können die MPLAB X IDE und den MPLAB-Code-Konfigurator problemlos nutzen, um eine IoT-Anwendung zu verändern oder eine völlig neue IoT-Anwendung zu erstellen, die sich sicher mit der Google Cloud verbindet.

Fazit

Die Gewährleistung einer sicheren Verbindung zwischen IoT-Geräten und Netzwerkressourcen ist für jede Netzwerkumgebung wichtig und für die Arbeit mit kommerziellen Cloud-Diensten unabdingbar. Der Aufbau der Schichten, die ein Softwaredienst für eine sichere Verbindung benötigt, kann bei IoT-Projekten zu erheblichen Verzögerungen führen und bei vielen IoT-Designs mit begrenzten Ressourcen sogar unmöglich sein. Durch die Nutzung eines Entwicklungsboards wie PIC-IoT von Microchip Technology, das einen speziellen Sicherheits-IC enthält, können die Entwickler in kurzer Zeit eine IoT-Anwendung erstellen, die sich sicher mit der Google Cloud verbindet.