Requêtes HTTPS ESP8266 NodeMCU (IDE Arduino)

Dans ce guide, vous apprendrez à effectuer des requêtes HTTPS avec la carte ESP8266 NodeMCU. Nous allons vous présenter quelques concepts fondamentaux du HTTPS et donner plusieurs exemples : Requêtes HTTPS sans certificat, avec empreinte digitale et avec certificat.

Nous avons un tutoriel similaire pour la carte ESP32 :

Table des matières

Tout au long de cet article, nous aborderons les sujets suivants :

Introduction

Pour comprendre comment faire des requêtes HTTPS avec l’ESP8266, mieux vaut se familiariser avec quelques notions fondamentales que nous expliquerons ensuite. Nous vous conseillons également de consulter l’article suivant :

Qu’est-ce que le HTTPS ?

HTTPS est la version sécurisée du protocole HTTP, d’où le « S », qui signifie sécurisé.

HTTP est un protocole de transfert de données sur Internet. Lorsque ces données sont chiffrées avec SSL/TLS, elles s’appellent HTTPS.

Pour simplifier, HTTPS n’est que le protocole HTTP mais avec des données cryptées à l’aide de SSL/TLS.

Pourquoi avez-vous besoin de HTTPS avec l’ESP8266 ?

L’utilisation de HTTPS garantit ce qui suit :

1) Cryptage : tout le trafic entre l’ESP8266 et un serveur sera crypté : personne ne peut espionner vos requêtes et vos mots de passe, ils ne verront que du charabia.

Lorsque vous utilisez les bibliothèques ESP8266 pour effectuer des requêtes HTTPS, elles prennent en charge le chiffrement et le déchiffrement des messages.

2) Confiance du serveur (identification) : lorsque vous utilisez HTTPS, via des certificats TLS/SSL, vous vous assurez que vous êtes connecté au serveur auquel vous vous attendez, ce qui signifie que vous savez toujours à qui vous êtes connecté.

Pour nous assurer que nous sommes connectés au bon serveur, nous devons vérifier le certificat du serveur sur l’ESP8266 ou l’empreinte du serveur. Cela signifie que nous devons télécharger le certificat du serveur ou l’empreinte digitale et le coder en dur sur notre croquis afin que nous puissions vérifier si nous sommes réellement connectés au serveur que nous attendons.

Certificats TLS/SSL

Les certificats SSL sont émis par des autorités de certification légitimes. L’un des plus connus est LetsEncrypt. Les autorités de certification confirment l’identité du propriétaire du certificat et fournissent la preuve que le certificat est valide. Le certificat contient également la clé publique du serveur pour une communication chiffrée asymétriquement avec un client.

Lorsqu’une autorité de certification émet un certificat, elle signe le certificat avec son certificat root. Ce certificat root doit se trouver dans la base de données de certificats de confiance appelée magasin root. Votre navigateur et le système d’exploitation contiennent une base de données de certificats root auxquels ils peuvent faire confiance (magasin root). La capture d’écran suivante montre certains des certificats root de confiance.

Ainsi, lorsque vous vous connectez à un site Web à l’aide de votre navigateur, celui-ci vérifie si son certificat a été signé par un certificat root appartenant à son magasin root. De nouveaux certificats root sont ajoutés ou supprimés du magasin root à chaque mise à jour du navigateur.

Lorsque vous utilisez un ESP8266, vous devez télécharger les certificats auxquels vous faites confiance sur votre carte. Habituellement, vous n’ajouterez que le certificat du serveur auquel vous souhaitez vous connecter.

Mais, il est également possible de télécharger un magasin root sur votre carte pour avoir plus d’options, et vous n’avez pas à vous soucier de rechercher le certificat d’un site Web spécifique.

Chaîne de certificats

Un certificat SSL fait partie d’une chaîne de certificats SSL. Qu’est-ce qu’une chaîne de certificats ?

Une chaîne de certificats comprend les éléments suivants :

• certificat root (d’une autorité de certification) ;
• un ou plusieurs certificats intermédiaires ;
• le certificat du serveur.

Le certificat de serveur est ce qui fait que votre navigateur affiche une icône de cadenas sécurisé lorsque vous visitez un site Web. Cela signifie que le serveur dispose d’un certificat SSL/TLS valide et que toutes les connexions avec le site Web sont cryptées. Un certificat SSL/TLS valide est un certificat approuvé par votre navigateur. Qu’est-ce qui le rend digne de confiance ?

Comme nous l’avons mentionné précédemment, les certificats SSL/TLS sont émis par les autorités de certification. Cependant, ces autorités ne délivrent pas de certificats directement aux sites Web. Ils utilisent des intermédiaires qui délivreront le certificat du serveur (Autorité de certification > certificat intermédiaire > certificat du serveur). La capture d’écran suivante montre un exemple pour le site Web Github. Vous pouvez voir la hiérarchie des certificats mise en évidence par un rectangle rouge.

Votre navigateur vérifie cette chaîne de certificats jusqu’à ce qu’il trouve le certificat root. Si ce certificat se trouve dans le magasin root du navigateur, il considère que le certificat est valide. Dans ce cas, l’autorité de certification root globale DigiCert se trouve dans le magasin root du navigateur. Ainsi, il affichera l’icône « sécurisé » sur la barre du navigateur.

Le diagramme suivant montre un aperçu de haut niveau de son fonctionnement.

En résumé:

• certificat root : c’est un certificat auto-signé délivré par une autorité de certification. La clé privée de ce certificat est utilisée pour signer le certificat suivant dans la hiérarchie des certificats. Les certificats root sont chargés dans les magasins de confiance des navigateurs et des systèmes d’exploitation.

• certificat intermédiaire : il est signé par la clé privée du certificat root. La clé publique du certificat intermédiaire est celle qui signe le certificat du serveur. Il peut y avoir plus d’un certificat intermédiaire.

• certificat de serveur : ce certificat est délivré à un nom de domaine spécifique sur un serveur. Il est signé par la clé publique du certificat intermédiaire. S’il est valide (chaîne de certificats de confiance), le navigateur affiche un badge de cadenas sécurisé dans la barre de recherche à côté du domaine du site Web.

Avec l’ESP8266, pour vérifier la validité d’un serveur, vous pouvez charger n’importe lequel de ces certificats : certificat root, intermédiaire ou serveur. Au lieu du certificat, vous pouvez également vérifier l’empreinte digitale du certificat. L’empreinte digitale est un hachage du certificat (un identifiant unique du certificat généré à partir des informations du certificat).

Date d’expiration des certificats

Les certificats SSL/TLS ont une date d’expiration. Vous pouvez vérifier sur un navigateur la date d’expiration du certificat pour un serveur particulier. Le certificat du serveur a généralement une validité à court terme et la validité de l’empreinte digitale est encore plus courte.

Ainsi, si vous souhaitez les utiliser dans vos projets ESP8266, vous devrez mettre à jour votre code assez fréquemment. Si vous souhaitez que votre code s’exécute pendant des années sans vous inquiéter, vous pouvez utiliser le certificat root du site Web, qui a généralement une validité de cinq à dix ans ou plus. Cependant, l’utilisation de l’empreinte digitale peut être utile à des fins de test ou peut être une bonne option en fonction de l’application.

Obtenir un certificat de serveur

Il existe différentes manières d’obtenir le certificat du serveur. L’un des moyens les plus simples consiste à télécharger le certificat directement depuis votre navigateur. Vous pouvez aussi utiliser OpenSSL et obtenez toutes les informations de certificat dont vous avez besoin à l’aide de la ligne de commande (nous ne couvrirons pas cette méthode dans ce didacticiel).

Dans cette section, vous apprendrez comment obtenir le certificat du serveur. Nous utiliserons généralement le certificat root, mais vous pouvez utiliser n’importe lequel des autres certificats de la chaîne de certificats. Il vous suffit de connaître la date d’expiration du certificat.

Obtenir un certificat de serveur à l’aide de Google Chrome

Dans cette section, nous allons vous montrer comment obtenir le certificat d’un serveur à l’aide de Google Chrome (c’est le navigateur Web que nous utilisons le plus souvent). Les instructions pour les autres navigateurs Web devraient être similaires.

Les exemples que nous utiliserons plus tard montrent comment faire une requête HTTPS au site Web howmyssl.com. Ainsi, à des fins de démonstration, nous allons vous montrer comment obtenir son certificat root. Il en est de même pour les autres sites Web.

Comment obtenir le certificat de sites Web à l’aide de Google Chrome ?

1. Accédez au site Web pour lequel vous souhaitez obtenir le certificat.

2. Cliquez sur l’icône du cadenas puis cliquez sur Afficher les détails de connexion.

3. Ensuite, cliquez sur Afficher le certificat.

4. Une nouvelle fenêtre s’ouvrira avec toutes les informations sur le certificat du site Web. Cliquez sur l’onglet Détails, assurez-vous de sélectionner le certificat root (c’est ce que nous recherchons dans cet exemple), puis cliquez sur Exporter…

5. Sélectionnez un emplacement sur votre ordinateur pour enregistrer le certificat. Enregistrez-le au format par défaut : ASCII encodé en Base64, certificat unique (*.pem, .crt). Et c’est tout.

Vous pouvez double-cliquer sur le fichier de certificat pour vérifier ses détails, y compris la date d’expiration.

Ouvrez le certificat à l’aide du Bloc-notes ou d’un autre logiciel similaire. Vous devriez obtenir quelque chose de similaire comme indiqué ci-dessous.

Comment obtenir l’empreinte digitale d’un site Web à l’aide de Google Chrome ?

Obtenir l’empreinte digitale du certificat d’un site Web est simple. Suivez les instructions suivantes :

1. Accédez au site Web sur lequel vous souhaitez obtenir l’empreinte digitale.

2. Cliquez sur l’icône du cadenas puis cliquez sur Afficher les détails de connexion.

3. Ensuite, cliquez sur Afficher le certificat.

4. Une nouvelle fenêtre s’ouvrira avec toutes les informations sur le certificat du site Web, y compris les empreintes digitales. Pour les exemples ESP8266, vous utiliserez l’empreinte SHA-1.

Requêtes HTTPS avec le NodeMCU ESP8266

Maintenant que vous connaissez tous les principaux aspects importants des certificats et comment obtenir un certificat de serveur, voyons enfin comment effectuer des requêtes HTTPS avec l’ESP8266 en utilisant le noyau Arduino. Nous aborderons différentes méthodes : sans certificat, avec l’empreinte du site Web et avec le certificat root du serveur.

Vous pouvez trouver différents exemples montrant comment faire des requêtes HTTPS avec l’ESP8266 dans la section des exemples de l’IDE Arduino.

• Client HTTPS de base (bibliothèque ESP8266HTTPClient) : Fichier > Exemples > ESP8266HTTPClient > ClientHTTPBasique
• Client HTTPS de base (bibliothèque WiFiClientSecure) : Fichier > Exemples > ESP8266WiFi > HTTPSRequest

Vous devrez mettre à jour les certificats et les empreintes digitales pour que les exemples fonctionnent. Nous avons créé plusieurs exemples basés sur ceux-ci. Tous les exemples présentés font une demande au www.howsmyssl.com/a/check site Internet. Il renvoie des informations sur la sécurité de la connexion HTTPS. Jetons un coup d’œil à eux.

Requêtes HTTPS ESP8266 NodeMCU – Aucun certificat

Vous pouvez faire des requêtes HTTPS avec l’ESP8266 sans certificat et sans empreinte digitale. La connexion sera cryptée, mais vous ignorerez la vérification du certificat du serveur SSL. Cela signifie que vous ne saurez pas si le serveur auquel vous êtes connecté est vraiment celui qu’il prétend être. Cette situation est utile à des fins de test ou pour effectuer des requêtes HTTPS vers des serveurs locaux à l’intérieur de votre réseau.

Le code suivant était basé sur le Exemple BasicHttpsClientBasicHttpsClient example.

Pour tester le code, insérez simplement vos informations d’identification réseau et téléchargez le code sur votre carte.

/*
  Complete project details: https://Raspberryme.com/esp8266-nodemcu-https-requests/ 
  Based on the BasicHTTPSClient.ino Created on: 20.08.2018 (ESP8266 examples)
*/

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClientSecureBearSSL.h>

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

void setup() {
  Serial.begin(115200);
  //Serial.setDebugOutput(true);

  Serial.println();
  Serial.println();
  Serial.println();

  //Connect to Wi-Fi
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
}

void loop() {
  // wait for WiFi connection
  if ((WiFi.status() == WL_CONNECTED)) {

    std::unique_ptr<BearSSL::WiFiClientSecure>client(new BearSSL::WiFiClientSecure);

    // Ignore SSL certificate validation
    client->setInsecure();
    
    //create an HTTPClient instance
    HTTPClient https;
    
    //Initializing an HTTPS communication using the secure client
    Serial.print("[HTTPS] begin...\n");
    if (https.begin(*client, "https://www.howsmyssl.com/a/check")) {  // HTTPS
      Serial.print("[HTTPS] GET...\n");
      // start connection and send HTTP header
      int httpCode = https.GET();
      // httpCode will be negative on error
      if (httpCode > 0) {
        // HTTP header has been send and Server response header has been handled
        Serial.printf("[HTTPS] GET... code: %d\n", httpCode);
        // file found at server
        if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
          String payload = https.getString();
          Serial.println(payload);
        }
      } else {
        Serial.printf("[HTTPS] GET... failed, error: %s\n", https.errorToString(httpCode).c_str());
      }

      https.end();
    } else {
      Serial.printf("[HTTPS] Unable to connect\n");
    }
  }
  Serial.println();
  Serial.println("Waiting 2min before the next round...");
  delay(120000);
}

Afficher le code brut

Comment fonctionne le code ?

Tout d’abord, vous devez inclure les bibliothèques requises. Vous avez besoin de la bibliothèque WiFiClientSecureBearSSL pour effectuer des requêtes HTTPS.

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClientSecureBearSSL.h>

Insérez vos informations d’identification réseau dans les lignes suivantes.

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Dans le setup(), initialisez le Serial Monitor et connectez la carte à votre réseau Wi-Fi.

void setup() {
  Serial.begin(115200);
  // Serial.setDebugOutput(true);

  Serial.println();
  Serial.println();
  Serial.println();

  //Connect to Wi-Fi
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }

La ligne suivante crée une nouvelle instance WiFiClientSecure appelée client.

std::unique_ptr<BearSSL::WiFiClientSecure>client(new BearSSL::WiFiClientSecure);

Si vous ne souhaitez pas vérifier le certificat du serveur, utilisez la méthode setInsecure() sur le client.

// Ignore SSL certificate validation
client->setInsecure();

Créez une instance HTTPClient appelée https.

//create an HTTPClient instance
HTTPClient https;

Initialisez le client https sur l’hôte spécifié à l’aide de la méthode begin(). Dans ce cas, nous faisons une demande sur l’URL suivante : https://www.howsmyssl.com/a/check.

 if (https.begin(*client, "https://www.howsmyssl.com/a/check")) {  // HTTPS

Obtenez le code de réponse du serveur.

 int httpCode = https.GET();

Si le code de réponse est un nombre positif, cela signifie que la connexion a été établie avec succès, nous pouvons donc lire la charge utile de la réponse à l’aide de la méthode getString() sur l’objet https. Ensuite, nous pouvons imprimer la charge utile dans le moniteur série. Dans une application pratique, vous pouvez effectuer toutes les tâches dont vous avez besoin avec l’ESP8266 en fonction de la charge utile reçue.

if (https.begin(*client, "https://www.howsmyssl.com/a/check")) {  // HTTPS
  Serial.print("[HTTPS] GET...\n");
  // start connection and send HTTP header
  int httpCode = https.GET();
  // httpCode will be negative on error
  if (httpCode > 0) {
    // HTTP header has been send and Server response header has been handled
    Serial.printf("[HTTPS] GET... code: %d\n", httpCode);
    // file found at server
    if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
      String payload = https.getString();
      Serial.println(payload);
    }

Si le code de réponse est un nombre négatif, cela signifie que nous avons une erreur. Nous imprimerons le code d’erreur.

else {
   Serial.printf("[HTTPS] GET... failed, error: %s\n", https.errorToString(httpCode).c_str());
}

Enfin, fermez la connexion HTTPS à l’aide de la méthode end() :

https.end();

Cet exemple spécifique fait une demande toutes les deux minutes. Vous devez le modifier en fonction des exigences de votre projet.

Serial.println("Waiting 2min before the next round...");
delay(120000);

Manifestation

Après avoir téléchargé le code, ouvrez le moniteur série à un débit en bauds de 115200. Appuyez sur le bouton RST intégré pour commencer à exécuter le nouveau code téléchargé.

Vous devriez obtenir quelque chose de similaire, comme indiqué dans l’image ci-dessous.

Vous obtenez le code de réponse 200, ce qui signifie que tout va bien avec la demande.

Si vous faites défiler vers la droite, vous obtiendrez le résultat de la sécurité de la connexion. Vous devriez obtenir un « Probablement d’accord ».

Votre connexion est toujours cryptée, mais avec cet exemple, elle ignorera la vérification SSL.

Requêtes HTTPS ESP8266 NodeMCU – Empreinte digitale

Vous pouvez effectuer des requêtes HTTPS avec l’ESP8266 et vérifier l’authenticité du serveur à l’aide de l’empreinte du serveur. L’un des principaux inconvénients de l’utilisation d’une empreinte digitale est que sa validité est généralement assez courte. Vous devrez donc mettre à jour votre croquis assez souvent.

Voici un exemple utilisant la vérification du serveur avec l’empreinte digitale. Cet exemple est basé sur le Exemple BasicHttpsClientBasicHttpsClient example. Étant donné que l’empreinte digitale change assez souvent, vous devrez peut-être modifier le code avec l’empreinte digitale actuelle du site Web.consultez cette section pour savoir comment obtenir l’empreinte digitale.

/*
  Complete project details: https://Raspberryme.com/esp8266-nodemcu-https-requests/
  Based on the BasicHTTPSClient.ino Created on: 20.08.2018 (ESP8266 examples)
*/

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClientSecureBearSSL.h>

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Fingerprint (might need to be updated)
const uint8_t fingerprint[20] = {0x76, 0x99, 0x2e, 0x6f, 0x04, 0xf4, 0xad, 0x19, 0xba, 0x54, 0xf5, 0x92, 0x50, 0x51, 0x56, 0x2b, 0x86, 0x8b, 0x5a, 0x92};

void setup() {
  Serial.begin(115200);
  //Serial.setDebugOutput(true);

  Serial.println();
  Serial.println();
  Serial.println();

  //Connect to Wi-Fi
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
}

void loop() {
  // wait for WiFi connection
  if ((WiFi.status() == WL_CONNECTED)) {

    std::unique_ptr<BearSSL::WiFiClientSecure>client(new BearSSL::WiFiClientSecure);

    client->setFingerprint(fingerprint);
    // Or, if you happy to ignore the SSL certificate, then use the following line instead:
    // client->setInsecure();

    HTTPClient https;

    Serial.print("[HTTPS] begin...\n");
    if (https.begin(*client, "https://www.howsmyssl.com/a/check")) {  // HTTPS

      Serial.print("[HTTPS] GET...\n");
      // start connection and send HTTP header
      int httpCode = https.GET();

      // httpCode will be negative on error
      if (httpCode > 0) {
        // HTTP header has been send and Server response header has been handled
        Serial.printf("[HTTPS] GET... code: %d\n", httpCode);

        // file found at server
        if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
          String payload = https.getString();
          Serial.println(payload);
        }
      } else {
        Serial.printf("[HTTPS] GET... failed, error: %s\n", https.errorToString(httpCode).c_str());
      }

      https.end();
    } else {
      Serial.printf("[HTTPS] Unable to connect\n");
    }
  }

  Serial.println();
  Serial.println("Waiting 2min before the next round...");
  delay(120000);
}

Afficher le code brut

Comment fonctionne le code ?

Le code de cet exemple est très similaire au précédent mais ajoute les lignes nécessaires pour vérifier l’empreinte du serveur. Nous allons juste jeter un coup d’œil rapide aux lignes pertinentes pour cet exemple. Pour une explication plus détaillée, vérifier l’exemple précédent.

Tout d’abord, vous devez inclure les bibliothèques requises. Vous avez besoin de la bibliothèque WiFiClientSecureBearSSL pour effectuer des requêtes HTTPS.

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClientSecureBearSSL.h>

Insérez vos identifiants réseau dans les lignes suivantes :

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Insérez l’empreinte du serveur dans la ligne suivante :

// Fingerprint for demo URL (might need to be updated)
const uint8_t fingerprint[20] = {0x76, 0x99, 0x2e, 0x6f, 0x04, 0xf4, 0xad, 0x19, 0xba, 0x54, 0xf5, 0x92, 0x50, 0x51, 0x56, 0x2b, 0x86, 0x8b, 0x5a, 0x92};

Dans une section précédente, nous avons vu que l’empreinte digitale de l’URL à laquelle nous ferons la demande est :

76 99 2E 6F 04 F4 AD 19 BA 54 F5 92 50 51 56 2B 86 8B 5A 92

Donc, vous devez l’insérer dans votre code comme ceci :

const uint8_t fingerprint[20] = {0x76, 0x99, 0x2e, 0x6f, 0x04, 0xf4, 0xad, 0x19, 0xba, 0x54, 0xf5, 0x92, 0x50, 0x51, 0x56, 0x2b, 0x86, 0x8b, 0x5a, 0x92};

Étant donné que l’empreinte digitale change fréquemment, vous devrez peut-être revérifier l’empreinte digitale actuelle. Si vous faites une demande sur une URL différente, vous devez obtenir son empreinte digitale comme décrit précédemment.

Vous devez créer une instance WiFiClientSecure appelée client.

std::unique_ptr<BearSSL::WiFiClientSecure>client(new BearSSL::WiFiClientSecure);

Pour définir l’empreinte du serveur, utilisez la méthode setFingerpirnt() sur le client et transmettez l’empreinte comme argument :

client->setFingerprint(fingerprint);

Créez une instance HTTPClient appelée https.

//create an HTTPClient instance
HTTPClient https;

Initialisez le client https sur l’hôte spécifié à l’aide de la méthode begin(). Dans ce cas, nous faisons une demande sur l’URL suivante : https://www.howsmyssl.com/a/check.

 if (https.begin(*client, "https://www.howsmyssl.com/a/check")) {  // HTTPS

Ensuite, il vous suffit de gérer la réponse du serveur. Un code de réponse de 200 signifie que tout s’est déroulé comme prévu. Un code de réponse avec un nombre négatif signifie que quelque chose s’est mal passé avec la demande.

 int httpCode = https.GET();

// httpCode will be negative on error
if (httpCode > 0) {
  // HTTP header has been send and Server response header has been handled
  Serial.printf("[HTTPS] GET... code: %d\n", httpCode);

  // file found at server
  if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
    String payload = https.getString();
    Serial.println(payload);
  }
} else {
  Serial.printf("[HTTPS] GET... failed, error: %s\n", https.errorToString(httpCode).c_str());
}

Manifestation

Après avoir téléchargé le code, ouvrez le moniteur série à un débit en bauds de 115200. Appuyez sur le bouton RST intégré pour commencer à exécuter le nouveau code téléchargé.

Vous devriez obtenir quelque chose de similaire à celui montré dans l’image ci-dessous (exactement comme dans l’exemple précédent).

Vous obtenez le code de réponse 200, ce qui signifie que tout va bien avec la demande.

Si vous faites défiler vers la droite, vous obtiendrez le résultat de la sécurité de la connexion. Vous devriez obtenir un « Probablement d’accord ».

Votre connexion est cryptée et vous avez vérifié l’authenticité du serveur à l’aide de l’empreinte du serveur.

Requêtes HTTPS ESP8266 NodeMCU – Certificat root

Dans cette section, nous allons vous montrer un exemple de requête HTTPS utilisant le certificat root du serveur.

L’utilisation du certificat root du serveur est une excellente option car vous vérifiez le certificat SSL du serveur et vous garantissez ainsi que vous communiquez avec le bon serveur. De plus, le certificat root est généralement valide pendant plus de cinq ans, ce qui signifie que vous n’avez pas besoin de mettre à jour constamment votre croquis ESP8266 (contrairement à la méthode des empreintes digitales).

Nous fournissons un exemple basé sur l’exemple ESP8266_HTTPSRequest, que vous pouvez trouver dans votre IDE Arduino : Fichier > Exemples > ESP8266WiFi > HTTPSRequest.

/*
  Complete project details: https://Raspberryme.com/esp8266-nodemcu-https-requests/
  Based on the example created by Ivan Grokhotkov, 2015 (File > Examples > ESP8266WiFi > HTTPSRequests)
*/

#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
#include <ESP8266HTTPClient.h>

// Root certificate for howsmyssl.com
const char IRG_Root_X1 [] PROGMEM = R"CERT(
-----BEGIN CERTIFICATE-----
MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
-----END CERTIFICATE-----
)CERT";

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Create a list of certificates with the server certificate
X509List cert(IRG_Root_X1);

void setup() {
  Serial.begin(115200);
  //Serial.setDebugOutput(true);

  Serial.println();
  Serial.println();
  Serial.println();

  //Connect to Wi-Fi
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }

  // Set time via NTP, as required for x.509 validation
  configTime(3 * 3600, 0, "pool.ntp.org", "time.nist.gov");

  Serial.print("Waiting for NTP time sync: ");
  time_t now = time(nullptr);
  while (now < 8 * 3600 * 2) {
    delay(500);
    Serial.print(".");
    now = time(nullptr);
  }
  Serial.println("");
  struct tm timeinfo;
  gmtime_r(&now, &timeinfo);
  Serial.print("Current time: ");
  Serial.print(asctime(&timeinfo));
}

void loop() {
  WiFiClientSecure client;

  // wait for WiFi connection
  if ((WiFi.status() == WL_CONNECTED)) {

    client.setTrustAnchors(&cert);

    HTTPClient https;

    Serial.print("[HTTPS] begin...\n");
    if (https.begin(client, "https://www.howsmyssl.com/a/check")) {  // HTTPS

      Serial.print("[HTTPS] GET...\n");
      // start connection and send HTTP header
      int httpCode = https.GET();

      // httpCode will be negative on error
      if (httpCode > 0) {
        // HTTP header has been send and Server response header has been handled
        Serial.printf("[HTTPS] GET... code: %d\n", httpCode);

        // file found at server
        if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
          String payload = https.getString();
          Serial.println(payload);
        }
      } else {
        Serial.printf("[HTTPS] GET... failed, error: %s\n", https.errorToString(httpCode).c_str());
      }

      https.end();
    } else {
      Serial.printf("[HTTPS] Unable to connect\n");
    }
  }

  Serial.println();
  Serial.println("Waiting 2min before the next round...");
  delay(10000);
}

Afficher le code brut

Cet exemple fait exactement la même chose que les précédents (fait une requête au site www.howsmyssl.com), mais il vérifie le certificat du serveur. Vous pouvez faire une demande à n’importe quel autre site Web, tant que vous obtenez son certificat de serveur.

Pour cette section, vous aurez besoin du certificat du serveur (voir cette section pour savoir comment obtenir le certificat du serveur).

Comment fonctionne le code ?

Cet exemple est similaire aux précédents mais ajoute les lignes nécessaires pour vérifier le certificat du serveur.

Tout d’abord, incluez les bibliothèques requises. Vous utiliserez la bibliothèque WiFiClientSecure pour effectuer des requêtes à l’aide de TLS, et la bibliothèque ESP8266HTTPClient pour faciliter la création des requêtes.

#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
#include <ESP8266HTTPClient.h>

Le certificat root du serveur pour le site Web howsmyssl.com est enregistré dans la variable IRG_Root_X1.

// Root certificate for howsmyssl.com
const char IRG_Root_X1 [] PROGMEM = R"CERT(
-----BEGIN CERTIFICATE-----
MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
-----END CERTIFICATE-----
)CERT";

Insérez vos identifiants réseau dans les lignes suivantes :

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Ensuite, vous devez créer une liste de certificats cert (même si vous n’avez qu’un seul certificat) avec le certificat serveur que vous souhaitez utiliser :

// Create a list of certificates with the server certificate
X509List cert(IRG_Root_X1);

Dans le setup (), vous devez configurer l’heure sur l’ESP8266, ce qui est nécessaire pour valider le certificat.

// Set time via NTP, as required for x.509 validation
configTime(3 * 3600, 0, "pool.ntp.org", "time.nist.gov");

Serial.print("Waiting for NTP time sync: ");
time_t now = time(nullptr);
while (now < 8 * 3600 * 2) {
  delay(500);
  Serial.print(".");
  now = time(nullptr);
}
Serial.println("");
struct tm timeinfo;
gmtime_r(&now, &timeinfo);
Serial.print("Current time: ");
Serial.print(asctime(&timeinfo));

Tout d’abord, pour faire une requête HTTPS, vous devez créer un objet WiFiClientSecure.

WiFiClientSecure client;

Ensuite, vous devez indiquer à quels certificats le client peut faire confiance en utilisant la méthode setTrustAnchors() et en passant en argument le certificat de liste de certificats (dans ce cas, nous n’avons ajouté qu’un seul certificat).

client.setTrustAnchors(&cert);

Désormais, le code est le même que les projets précédents.

Vous devez créer une instance HTTPClient (https), initialiser le client https sur l’hôte spécifié à l’aide de la méthode begin(), puis gérer la réponse du serveur.

client.setTrustAnchors(&cert);

HTTPClient https;

Serial.print("[HTTPS] begin...\n");
if (https.begin(client, "https://www.howsmyssl.com/a/check")) {  // HTTPS

  Serial.print("[HTTPS] GET...\n");
  // start connection and send HTTP header
  int httpCode = https.GET();

 
 // httpCode will be negative on error
  if (httpCode > 0) {
    // HTTP header has been send and Server response header has been handled
    Serial.printf("[HTTPS] GET... code: %d\n", httpCode);

     // file found at server
    if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
      String payload = https.getString();
      Serial.println(payload);
    }
  } else {
    Serial.printf("[HTTPS] GET... failed, error: %s\n", https.errorToString(httpCode).c_str());
  }

Après avoir téléchargé ce code sur la carte ESP8266, vous devriez obtenir les mêmes messages sur le Serial Monitor que dans les exemples précédents.

Requêtes HTTPS ESP8266 – Magasin root

Au lieu de simplement enregistrer un certificat sur l’ESP8266, vous pouvez enregistrer plusieurs certificats. Vous pouvez ajouter deux, trois certificats ou plus, et vous pouvez même ajouter un magasin root. Comme nous l’avons vu précédemment, un magasin root est une base de données de certificats root à laquelle votre navigateur ou votre système d’exploitation peut faire confiance.

Vous pouvez télécharger l’intégralité du magasin de certificats Mozilla et le télécharger sur votre ESP8266 afin qu’il se comporte comme un navigateur. Ainsi, vous pourrez envoyer des requêtes HTTPS en toute sécurité à n’importe quel serveur (qui utilise TLS) sans avoir à coder en dur son certificat.

Cet article est déjà assez long, nous aborderons donc ce sujet dans un autre tutoriel (à paraître prochainement).

Si vous êtes curieux à propos de ce sujet, je vous recommande de jeter un œil à l’exemple officiel ESP8266 Certificate Store : BearSSL_CertStore. Vous pouvez également le trouver sur votre IDE Arduino : Fichier > Exemples > ESP8266WiFi > BearSSL_CertStore.

Conclusion

Dans ce tutoriel, vous avez appris à faire des requêtes HTTPS avec l’ESP8266.

Nous vous avons montré différentes façons de faire des requêtes HTTPS avec l’ESP8266 : sans certificat, avec une empreinte digitale et avec un certificat. Il est également possible d’utiliser plusieurs certificats ou un magasin root. Nous aborderons ce sujet dans un prochain didacticiel. Vous avez également appris les concepts de base du protocole HTTPS et les certificats SSL/TLS.

Autres tutoriels connexes qui pourraient vous intéresser :

Nous espérons que vous avez trouvé ce tutoriel utile. Nous avons l’intention de créer plus de tutoriels sur HTTPS et la communication sécurisée. Faites-nous savoir dans les commentaires ci-dessous ce que vous en pensez.

En savoir plus sur l’ESP8266 avec nos ressources :

Merci d’avoir lu.

Apprenez l’histoire de Raspberry Pi à travers cette vidéo :