Comment connecter rapidement et en toute sécurité des applications IoT à Google Cloud

Les services cloud de niveau entreprise, tels que Google Cloud, offrent aux développeurs IoT un large éventail de capacités, qui varient de services de machine virtuelle évolutifs à des applications d'intelligence artificielle (IA) clés en main. Une exigence fondamentale pour ces services est l'utilisation de méthodes de sécurité spécifiques pour établir et maintenir des connexions sécurisées entre les dispositifs IoT et le cloud. Cependant, pour les développeurs, l'implémentation de mécanismes de sécurité appropriés peut entraîner des retards et rendre plus complexe la conception de projets avec des délais serrés.

Conçue avec un circuit intégré de sécurité dédié, la carte de développement PIC-IoT WG de Microchip Technology offre une solution clés en main pour la connectivité Google Cloud. Grâce à un circuit intégré de sécurité dédié, le kit fournit une plateforme complète conçue pour accélérer le développement de conceptions IoT capables de se connecter en toute sécurité à des services Google Cloud. Cet article décrit les principales exigences pour une connectivité sécurisée et montre comment les développeurs peuvent respecter ces exigences à l'aide de la carte PIC-IoT WG dans une conception IoT typique.

Complexité de la sécurité

La capacité à sécuriser les connexions entre les dispositifs IoT et les serveurs hôtes distants est fondamentale pour une protection globale des applications IoT et des ressources d'entreprise en réseau associées. Ces serveurs et d'autres systèmes à l'échelle de l'entreprise peuvent fournir les capacités et les performances qui sont tout simplement indisponibles dans les dispositifs IoT conçus avec des microcontrôleurs à ressources limitées et une quantité de mémoire minimale. Pour des dispositifs IoT simples, prévus pour fournir des données de capteur ou faire fonctionner des actionneurs au moment opportun, rien que les exigences de traitement pour implémenter les algorithmes de sécurité les plus fondamentaux peuvent être prohibitives de par leur nature.

Les méthodes de sécurité reposent sur le principe de base selon lequel l'action visant à violer une barrière de sécurité devrait être plus coûteuse que les ressources que la barrière est censée protéger. Pour les méthodes de sécurité algorithmiques, cela signifie que le décryptage d'un message crypté ou la violation d'un protocole d'authentification devrait nécessiter des calculs prohibitifs. Au minimum, la violation d'une sécurité algorithmique devrait nécessiter un certain niveau de ressources de calcul et du temps nécessaire qui dépassent la valeur ou l'opportunité des données protégées ou du canal de communication. Par conséquent, les algorithmes cryptographiques cherchent à enfouir les données les plus précieuses sous une série d'étapes de traitement complexes nécessitant un calcul intensif et impliquant une clé secrète. Par exemple, l'algorithme largement utilisé appelé Advanced Encryption Standard (AES) soumet les données à plusieurs opérations de traitement, qui comprennent chacune une série d'étapes commençant par une clé secrète et se poursuivant par des substitutions d'octets, de décalages et de calculs matriciels (Figure 1).

Figure 1 : Conçus pour rendre le décryptage difficile et impossible dans les faits, les algorithmes cryptographiques utilisent délibérément une série de manipulations complexes, comme cette étape dans l'algorithme AES qui associe des données avec des bits dérivés d'une clé privée. (Source de l'image : Wikimedia Commons)

Avec les algorithmes cryptographiques symétriques, tels qu'AES, les récepteurs d'un message crypté utilisent la même clé secrète pour décrypter les données. En revanche, les algorithmes asymétriques utilisent une paire de clés, une privée et une publique, permettant d'éliminer les risques associés à l'utilisation d'une clé partagée, au prix d'un niveau de complexité de traitement accru. Dans cette approche, un expéditeur et un récepteur échangent des clés publiques, tout en gardant secrètes leurs clés privées. À son tour, une partie peut utiliser la clé publique de l'autre partie pour crypter un message qui peut être décrypté uniquement avec la clé privée de l'autre partie.

Pour une meilleure protection, les algorithmes avancés utilisent des méthodes de cryptographie à clé publique pour permettre un échange sécurisé d'une clé privée partagée de courte durée, utilisée pour crypter des données seulement pendant la durée d'une session particulière d'échange de messages. Étant donné le caractère critique de ces échanges de clés, des algorithmes plus avancés, tels que les échanges de clés Diffie-Hellman basés sur les courbes elliptiques (ECDH) enfouissent encore plus profondément les données secrètes au moyen de calculs de courbes elliptiques complexes. Les protocoles d'authentification comme TLS (Transport Layer Security) associent des mécanismes, tels que les échanges de clés Diffie-Hellman, avec des méthodes d'identification formelles, en utilisant des certificats numériques qui intègrent une clé publique avec une signature numérique vérifiable provenant d'une autorité de certification qui atteste de l'authenticité du certificat.

Selon cette brève description, les méthodes de sécurité reposent sur des couches d'algorithmes cryptographiques et de protocoles qui dépendent au final de clés privées. Bien que ces couches soient constamment la cible d'attaques de pirates informatiques, l'intégralité de la structure de sécurité risque de s'effondrer rapidement si les clés privées peuvent être découvertes.

C'est la raison pour laquelle le stockage de clés sécurisé au niveau matériel est une exigence fondamentale pour la sécurité des dispositifs IoT. En outre, la complexité des calculs associés à ces algorithmes et protocoles définit le besoin en moteurs de cryptographie dédiés, capables de décharger les calculs complexes des microcontrôleurs à ressources limitées.

Sécurité au niveau matériel

Les dispositifs matériels dotés d'éléments de sécurité spécialisés, tels que le circuit intégré CryptoAuthentication ATECC608A de Microchip Technology, fournissent les fonctionnalités nécessaires pour protéger des données secrètes et accélérer l'exécution d'algorithmes cryptographiques. Parmi ses fonctionnalités, l'ATECC608A fournit une mémoire EEPROM sur puce permettant de stocker en toute sécurité jusqu'à 16 clés, certificats et autres données, ainsi que d'autres capacités nécessaires, y compris un générateur de nombres aléatoires conforme aux publications NIST SP 800-90A/B/C.

En plus d'être un dispositif de stockage sécurisé, l'ATECC608A peut accélérer l'exécution de nombreux algorithmes, y compris AES pour une cryptographie symétrique et ECDH pour une cryptographie asymétrique. Le dispositif prend également en charge des services de niveau plus élevé, y compris le démarrage sécurisé (voir « Utilisation d'une puce de cryptographie pour ajouter un démarrage sécurisé aux conceptions de dispositifs IoT »).

En plus des avantages de performances directes obtenus grâce au déchargement de l'exécution de ces algorithmes, l'intégration de ces moteurs cryptographiques, de ce stockage sécurisé et d'autres fonctionnalités dans l'ATECC608A confère intrinsèquement une couche de sécurité supplémentaire : les clés restent isolées d'entités non fiables. Ces entités incluent des microcontrôleurs non conçus pour la sécurité, le logiciel qui s'exécute sur le microcontrôleur et les individus qui utilisent le logiciel. La capacité du dispositif à générer des clés privées fournit une sécurité renforcée pendant le provisionnement dans des installations de fabrication ou de distribution.

Cela se traduit par une réduction du nombre de vecteurs de menaces, par rapport aux méthodes de sécurité traditionnelles au niveau logiciel. Cela prend en charge le type de défense en profondeur qui se trouve au cœur des politiques de sécurité efficaces.

Cette intégration complète de fonctionnalités dans l'ATECC608A simplifie les exigences en matière d'interface matérielle. Le dispositif fonctionne comme un autre périphérique I²C qui peut même partager le bus I²C d'un microcontrôleur avec d'autres dispositifs, tels que des capteurs numériques comme le MCP9808 de Microchip Technology (Figure 2).

Figure 2 : Étant donné que le circuit intégré CryptoAuthentication ATECC608A de Microchip Technology (à gauche) effectue son traitement de sécurité entièrement sur puce, il peut fournir une interface matérielle I²C simple pouvant être utilisée avec d'autres dispositifs I²C, tels que le capteur de température numérique MCP9808 I²C de Microchip Technology (à droite). (Source de l'image : Microchip Technology)

Cependant, au niveau logiciel, les nombreuses fonctionnalités de l'ATECC608A génèrent une interface plus complexe. La bibliothèque CryptoAuthLib de Microchip Technology résume cette interface en un ensemble d'appels de fonctions intuitives disponible dans l'interface de programmation (API) CryptoAuthLib. Cette bibliothèque est fournie avec les intergiciels et pilotes associés dans l'environnement de développement intégré (IDE) MPLAB X de Microchip Technology. Bien que l'API CryptoAuthLib et les pilotes fournissent les éléments de base pour des conceptions personnalisées avec l'ATECC608A, les développeurs sont confrontés à des défis supplémentaires quant à l'implémentation de la chaîne de sécurité complète pour une connectivité sécurisée avec Google Cloud. La carte de développement PIC-IoT WG de Microchip Technology permet également de surmonter cet obstacle.

Développement d'une application IoT de bout en bout

Basée sur l'ATECC608A et le microcontrôleur 16 bits PIC24FJ128GA705 économique de Microchip Technology, la carte PIC-IoT est une conception IoT sans fil qui inclut le module Wi-Fi ATWINC1510 de Microchip Technology, le capteur de lumière ambiante TEMT6000X01 de Vishay Semiconductor et le capteur de température I²C MCP9808. De plus, les développeurs peuvent facilement étendre la plateforme de base matérielle en ajoutant des capteurs et des actionneurs fournis avec les centaines de cartes Click disponibles de MikroElektronika. Pour le développement de logiciels, Microchip Technology fournit son IDE MPLAB X et l'outil de prototypage rapide MPLAB Code Configurator (MCC) associé.

La carte et le logiciel associé fournissent une plateforme clés en main pour l'évaluation d'une application IoT de bout en bout basique qui s'exécute à partir du dispositif de capteur IoT vers les services Google Cloud par l'intermédiaire de connexions sécurisées. Le kit implémente une approche unique conçue pour permettre une authentification mutuelle, même avec des dispositifs IoT à ressources limitées. Dans cette approche, le dispositif IoT peut utiliser des services TLS légers pour authentifier le côté Google de la connexion et des jetons JWT (Web Token) JSON (JavaScript Object Notation) pour s'authentifier eux-mêmes auprès des serveurs Google (voir « Une solution plus simple pour connecter des dispositifs IoT au cloud en toute sécurité »). Avec les pilotes, les options BSP (board support packages) et les services d'intergiciel, Microchip Technology démontre cette approche dans le cadre d'une application IoT d'exemple complète, disponible pour la carte PIC-IoT par l'intermédiaire de la suite de développement MPLAB.

En travaillant avec l'application d'exemple, les développeurs peuvent acquérir de l'expérience non seulement dans les applications cloud, mais également dans les services spécifiques à l'IoT proposés par les principaux fournisseurs de services pour la connexion de dispositifs IoT à leur cloud. Par exemple, les dispositifs IoT accèdent aux ressources Google Cloud par l'intermédiaire de Google Cloud IoT Core, qui fournit divers services nécessaires pour connecter ces dispositifs, gérer leurs métadonnées associées et plus encore (Figure 3).

Figure 3 : À l'instar d'autres fournisseurs de cloud d'entreprise, Google Cloud offre un service spécialisé, Google Cloud IoT Core, qui est conçu pour répondre aux exigences uniques associées à l'intégration de dispositifs IoT à des ressources cloud. (Source de l'image : Google)

Utilisation de services cloud

En arrière-plan, Google Cloud IoT Core fournit aux dispositifs un accès aux ressources Google Cloud de haut niveau via un intermédiaire de données (data broker) en utilisant un modèle publication/enregistrement (pub/sub). À l'avant-plan, IoT Core fournit un pont qui prend en charge la connectivité de dispositifs IoT en utilisant le protocole HTTP (Hypertext Transfer Protocol) ou MQTT (Message Queuing Telemetry Transport). MQTT est un protocole de messagerie conforme à la norme ISO (International Organization for Standardization) conçu pour s'exécuter avec un minimum de bande passante pour les communications et de ressources des dispositifs IoT. L'application logicielle de Microchip Technology pour la carte PIC-IoT démontre l'utilisation du protocole MQTT s'exécutant sur une connexion socket TCP/IP (Transmission Control Protocol/Internet Protocol) qui est sécurisée avec la méthode d'authentification mutuelle TLS/JWT décrite précédemment.

Après avoir établi la connexion sécurisée, le logiciel utilise le protocole MQTT pour communiquer avec les services Google Cloud IoT Core pour établir un canal, ou un « objet » (topic), utilisé pour envoyer les données de capteur à Google Cloud et répondre aux commandes provenant de services cloud. Google appelle un logiciel de dispositif IoT pour s'enregistrer et envoyer ensuite des données à un objet désigné sous la forme /devices/{deviceID}/events et fournit l'option pour des sous-objets sous l'objet events plus large. En plus d'autres objets, tels que ceux pour les fonctionnalités de gestion de dispositifs, Google désigne un objet /devices/{device-id}/commands pour l'envoi de commandes à partir du cloud vers le dispositif IoT. Google fournit même un objet passe-partout (/devices/{device-id}/commands/#) qui permet aux dispositifs IoT de recevoir les commandes envoyées par l'intermédiaire de n'importe quel sous-objet.

L'application PIC-IoT démontre ces diverses procédures au moyen d'une architecture logicielle extensible basée sur des temporisateurs et des rappels. En raison de cette architecture, le module principal (main.c) a besoin de fournir uniquement la routine principale (main()) et les routines de niveau application pour l'envoi (sendToCloud()) et la réception (receivedFromCloud()) de messages. La routine main() en elle-même appelle simplement une paire de routines d'initialisation avant d'entrer dans une boucle sans fin qui exécute le planificateur de temporisation et fournit un paramètre fictif pour les routines d'utilisateur (Liste 1).

Copier 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; } 

Liste 1 : L'application d'exemple de Microchip Technology pour la carte PIC-IoT utilise une série de temporisateurs et de rappels qui simplifie la boucle principale et permet aux développeurs d'ajouter facilement leurs propres services et routines d'application. (Source du code : Microchip Technology)

Appelée avant la boucle sans fin, la routine SYSTEM_Initialize() initialise les composants matériels, y compris l'horloge, le convertisseur analogique-numérique (CAN), les interruptions, etc. La routine application_init() initialise les divers systèmes logiciels, y compris la bibliothèque CryptoAuthentication, se connecte au Wi-Fi et au cloud lui-même. En guise de dernière tâche, la routine application_init() définit un temporisateur de 100 millisecondes (ms) pour l'exécution de MAIN_dataTask(). Lorsque le temporisateur expire et que la fonction MAIN_dataTask() est appelée, elle vérifie la connexion au cloud et appelle sendToCloud() une fois par seconde, en définissant les LED de la carte comme approprié pour indiquer l'état de fonctionnement actuel de l'application (Liste 2). Les développeurs peuvent à leur tour voir un affichage des valeurs de capteur sur un compte sandbox gratuit fourni par Microchip Technology sur Google Cloud.

Copier // 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; } 

Liste 2 : L'application d'exemple PIC-IoT de Microchip Technology utilise un mécanisme de temporisateur et de rappel pour envoyer des données de capteur au cloud une fois par seconde (CFG_SEND_INTERVAL=1) et pour mettre à jour les LED de la carte afin d'indiquer l'état de fonctionnement actuel. (Source du code : Microchip Technology)

Le traitement des commandes à partir du cloud est très simple. L'application d'exemple démontre la façon d'associer une routine de rappel, telle que receivedFromCloud() pour gérer les messages reçus. Dans le cadre de la phase d'initialisation, la routine application_init() mentionnée précédemment appelle une routine (CLOUD_subscribe()) qui effectue le processus d'enregistrement de Google Cloud. Dans le cadre de ce processus, le logiciel met à jour un tableau (imqtt_publishReceiveCallBackTable) avec le rappel pour receivedFromCloud() (Liste 3). Dans ce cas, l'application d'exemple utilise l'objet config et code en dur l'index dans le tableau depuis NUM_TOPICS_SUBSCRIBE=1, mais l'objet de commandes plus générales et les sous-objets dérivés sont une autre option.

Copier 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; } } 

Liste 3 : L'application d'exemple de Microchip Technology montre comment les développeurs peuvent facilement associer des routines de rappel aux messages MQTT reçus, dans ce cas en définissant la fonction receivedFromCloud() en tant que rappel pour les messages reçus de l'objet par défaut. (Source du code : Microchip Technology)

Les développeurs peuvent utiliser l'ensemble matériel et logiciel PIC-IoT tel qu'il est livré pour commencer immédiatement à explorer différents scénarios d'envoi et de réception de données à partir de Google Cloud. Le matériel PIC-IoT, y compris le dispositif CryptoAuthentication ATECC608A, est préconfiguré pour prendre en charge le service Google Cloud IoT Core et ce modèle d'utilisation. Les développeurs peuvent facilement utiliser l'IDE MPLAB X et l'outil MPLAB Code Configurator pour modifier ou créer une application IoT entièrement nouvelle et ainsi se connecter en toute sécurité à Google Cloud.

Conclusion

Fournir des connexions sécurisées entre les périphériques IoT et les ressources en réseau est essentiel pour tout environnement de service en réseau, et obligatoire pour travailler avec les services cloud commerciaux. La création des couches de services logiciels nécessaires pour une connectivité sécurisée peut entraîner des retards considérables dans les projets IoT, et peut même s'avérer impossible dans des conceptions IoT à ressources limitées. En utilisant une carte de développement, telle que la carte PIC-IoT de Microchip Technology, qui inclut un circuit intégré de sécurité spécialisé, les développeurs peuvent rapidement faire en sorte qu'une application IoT puisse se connecter en toute sécurité à Google Cloud.