Snabbstart: Etablera en simulerad TPM-enhet

• Visual Studio 2019 med arbetsbelastningen "Desktop development with C++" (Skrivbordsutveckling med C++) aktiverad. Visual Studio 2015 och Visual Studio 2017 stöds också.

• Installera .NET Core 2.1 SDK eller senare Windows din dator. Du kan använda följande kommando för att kontrollera din version.

  dotnet --info
  

• Installera Node.js v4.0+.

• Installera Python 2.x eller 3.x. Se till att använda en 32-bitars eller 64-bitars installation beroende på vad som krävs för din konfiguration. Se till att du lägger till Python i de plattformsspecifika miljövariablerna när du uppmanas att göra det under installationen.

• Om du använder ett Windows-operativsystem installerar du Visual C++ redistributable package så att du kan använda inbyggda DLL:er från Python.

• Visual Studio 2019 med arbetsbelastningen "Desktop development with C++" (Skrivbordsutveckling med C++) aktiverad. Visual Studio 2015 och Visual Studio 2017 stöds också.

• CMake-buildsystemet.

• Installera Java SE Development Kit 8 eller senare installerat på datorn.

• Ladda ned och installera Maven.

I det här avsnittet förbereder du en utvecklingsmiljö som används för att skapa Azure IoT C SDK och exemplet på TPM-enhetssimulator.

1. Ladda ned det senaste CMake-byggsystemet.

   Viktigt

   Kontrollera att Visual Studio (Visual Studio och arbetsbelastningen "Desktop development with C++" (Skrivbordsutveckling med C++) är installerade på datorn innan du startar CMake installationen. När förutsättningarna är uppfyllda och nedladdningen har verifierats installerar du CMake-byggesystemet. Tänk också på att äldre versioner av CMake-byggsystemet inte kan generera lösningsfilen som används i den här artikeln. Se till att använda den senaste versionen av CMake.

2. Öppna en webbläsare och gå till sidan Version i Azure IoT C SDK.

3. Välj fliken Taggar överst på sidan.

4. Kopiera taggnamnet för den senaste versionen av Azure IoT C SDK.

5. Öppna en kommandotolk eller Git Bash-gränssnittet. Kör följande kommandon för att klona den senaste versionen av Azure IoT C SDK GitHub lagringsplatsen. (ersätt <release-tag> med taggen som du kopierade i föregående steg).

   git clone -b <release-tag> https://github.com/Azure/azure-iot-sdk-c.git
   cd azure-iot-sdk-c
   git submodule update --init
   

   Den här åtgärden kan ta flera minuter att slutföra.

6. När åtgärden har slutförts kör du följande kommandon från azure-iot-sdk-c katalogen :

   mkdir cmake
   cd cmake
   

1. Öppna en Git CMD- eller Git Bash-kommandoradsmiljö.

2. Klona Azure IoT-exempel för C# GitHub lagringsplatsen med följande kommando:

   git clone https://github.com/Azure-Samples/azure-iot-samples-csharp.git
   

1. Öppna en Git CMD- eller Git Bash-kommandoradsmiljö.

2. Klona lagringsplatsen azure-utpm-c GitHub med följande kommando:

   git clone https://github.com/Azure/azure-utpm-c.git --recursive
   

1. Öppna en Git CMD- eller Git Bash-kommandoradsmiljö.

2. Klona Python GitHub-lagringsplatsen med följande kommando:

   git clone --single-branch --branch v1-deprecated https://github.com/Azure/azure-iot-sdk-python.git --recursive
   

3. Skapa en mapp i din lokala kopia av den GitHub lagringsplatsen för CMake-byggprocessen.

   cd azure-iot-sdk-python/c
   mkdir cmake
   cd cmake
   

4. Skapa Python-paketen med hjälp av de här instruktionerna.

   Anteckning

   Om du kör build_client.cmd använder du --use-tpm-simulator-flagan.

   Anteckning

   Om du använder pip ska du även installera azure-iot-provisioning-device-client-paketet. Obs! De utgivna PIP-paketen använder verkliga TPM, inte simulatorn. Om du vill använda simulatorn måste du kompilera från källan med --use-tpm-simulator-flaggan.

1. Öppna en Git CMD- eller Git Bash-kommandoradsmiljö.

2. Klona Java GitHub-lagringsplatsen med följande kommando:

   git clone https://github.com/Azure/azure-iot-sdk-java.git --recursive
   

1. Kör följande kommando för att skapa Azure IoT C SDK som innehåller exempelkoden för TPM-enhetssimulatorn. En Visual Studio lösning för den simulerade enheten genereras i cmake katalogen . Det här exemplet tillhandahåller en TPM-attesteringsmekanism via SAS-tokenautentisering (signatur för delad åtkomst).

   cmake -Duse_prov_client:BOOL=ON ..
   

   Tips

   Om cmake inte hittar din C++-kompilator kan du få kompileringsfel när du kör kommandot ovan. Om det händer kan du försöka köra kommandot i Visual Studio kommandotolken.

2. När bygget har lyckats ser de sista utdataraderna ut ungefär som följande utdata:

   $ cmake -Duse_prov_client:BOOL=ON ..
   -- Building for: Visual Studio 16 2019
   -- The C compiler identification is MSVC 19.23.28107.0
   -- The CXX compiler identification is MSVC 19.23.28107.0
   
   ...
   
   -- Configuring done
   -- Generating done
   -- Build files have been written to: C:/code/azure-iot-sdk-c/cmake
   

3. Gå till rotmappen för git-lagringsplatsen som du klonade.

4. Kör TPM-simulatorn med hjälp av sökvägen som visas nedan.

   cd ..
   .\provisioning_client\deps\utpm\tools\tpm_simulator\Simulator.exe
   

   Simulatorn visar inga utdata. Låt den fortsätta att köras när den simulerar en TPM-enhet.

1. I huvudmenyn för device provisioning-tjänsten väljer du Översikt.

2. Kopiera värdet FÖR ID-omfång.

   

3. I en kommandotolk ändrar du kataloger till projektkatalogen för TPM-enhetsetableringsexemplet.

   cd .\azure-iot-samples-csharp\provisioning\Samples\device\TpmSample
   

4. Skriv följande kommando för att skapa och köra TPM-enhetsetableringsexempel (ersätt <IDScope> med ID-omfånget för din etableringstjänst).

   dotnet run <IDScope>
   

   Anteckning

   Det här kommandot startar simulatorn för TPM-chip i en separat kommandotolk. På Windows kan du stöta på en Windows-säkerhet-avisering som frågar om du vill Simulator.exe tillåta kommunikation i offentliga nätverk. I det här exemplet kan du avbryta begäran.

5. Det ursprungliga kommandofönstret visar bekräftelsenyckeln, registrerings-ID och ett föreslaget enhets-ID som krävs för enhetsregistrering. Anteckna värdena. Du använder dessa värden för att skapa en enskild registrering i instansen av enhetsetableringstjänsten.

   Anteckning

   Blanda inte ihop fönstret som innehåller utdata från kommandot med fönstret som innehåller utdata från TPM-simulatorn. Du kan behöva välja det ursprungliga kommandofönstret för att få det till förgrunden.

1. Gå till GitHub rotmappen.

2. Kör TPM-simulatorn som HSM för den simulerade enheten.

   .\azure-utpm-c\tools\tpm_simulator\Simulator.exe
   

3. Skapa en ny tom mapp med namnet registerdevice. I mappen registerdevice skapar du en package.json-fil med följande kommando i kommandotolken (se till att besvara alla frågor som ställs av eller acceptera standardinställningarna om de npm passar dig):

   npm init
   

4. Installera följande tidigare paket:

   npm install node-gyp -g
   npm install ffi -g
   

   Anteckning

   Det finns några kända problem som kan uppstå när du installerar ovanstående paket. För att lösa dessa problem kan du köra npm install --global --production windows-build-tools med hjälp av en kommandotolk i läget Kör som administratör. Kör SET VCTargetsPath=C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\V140 efter att du ersatt sökvägen med den installerade versionen och kör sedan installationskommandona igen.

5. Installera alla nödvändiga paket som kör följande kommando i kommandotolken i mappen registerdevice:

   npm install --save azure-iot-device azure-iot-device-mqtt azure-iot-security-tpm azure-iot-provisioning-device-http azure-iot-provisioning-device
   

   Kommandot installerar följande paket:

   • en säkerhetsklient som fungerar med TPM: azure-iot-security-tpm

   • en transport för att enheten ska kunna ansluta till enhetsetableringstjänsten: antingen azure-iot-provisioning-device-http eller azure-iot-provisioning-device-amqp

   • en klient som använder transport- och säkerhetsklienten: azure-iot-provisioning-device

   • enhetsklienten: azure-iot-device

   • en transport: antingen azure-iot-device-amqp, azure-iot-device-mqtt eller azure-iot-device-http

   • säkerhetsklienten som du redan har installerat: azure-iot-security-tpm

     Anteckning

     Exemplen i den här snabbstarten använder azure-iot-provisioning-device-http azure-iot-device-mqtt transporterna och .

6. Öppna en textredigerare med dina val.

7. I mappen registerdevice skapar du en ny ExtractDevice.js fil.

8. Lägg till följande require-instruktioner i början av ExtractDevice.js-filen:

   
   'use strict';
   
   var tpmSecurity = require('azure-iot-security-tpm');
   var tssJs = require("tss.js");
   
   var myTpm = new tpmSecurity.TpmSecurityClient(undefined, new tssJs.Tpm(true));
   

9. Lägg till följande funktion för att implementera metoden:

   
   myTpm.getEndorsementKey(function(err, endorsementKey) {
     if (err) {
       console.log('The error returned from get key is: ' + err);
     } else {
       console.log('the endorsement key is: ' + endorsementKey.toString('base64'));
       myTpm.getRegistrationId((getRegistrationIdError, registrationId) => {
         if (getRegistrationIdError) {
           console.log('The error returned from get registration id is: ' + getRegistrationIdError);
         } else {
           console.log('The Registration Id is: ' + registrationId);
           process.exit();
         }
       });
     }
   });
   

10. Spara och stäng ExtractDevice.js-filen.

    node ExtractDevice.js
    

11. Kör exemplet.

12. Utdatafönstret visar bekräftelsenyckeln och det registrerings-ID som krävs för enhetsregistrering. Kopiera de här värdena.

1. Kör följande kommando för att aktivera AUTENTISERING av SAS-token (kommandot genererar även en Visual Studio lösning för den simulerade enheten):

   cmake -Duse_prov_client:BOOL=ON -Duse_tpm_simulator:BOOL=ON ..
   

2. Öppna en andra kommandotolk.

3. I den andra kommandotolken navigerar du till TPM-simulatormappen.

4. Kör TPM-simulatorn som HSM för den simulerade enheten.

5. Välj Tillåt åtkomst. Simulatorn lyssnar via en socket på portarna 2321 och 2322. Stäng inte det här kommandofönstret. du måste se till att simulatorn fortsätter att köras till slutet av den här snabbstartsguiden.

.\azure-iot-sdk-python\c\provisioning_client\deps\utpm\tools\tpm_simulator\Simulator.exe

1. Kör TPM-simulatorn som HSM för den simulerade enheten.

2. Välj Tillåt åtkomst. Simulatorn lyssnar via en socket på portarna 2321 och 2322. Stäng inte det här kommandofönstret. du måste se till att simulatorn fortsätter att köras till slutet av den här snabbstartsguiden.

   .\azure-iot-sdk-java\provisioning\provisioning-tools\tpm-simulator\Simulator.exe
   

   

3. Öppna en andra kommandotolk.

4. I den andra kommandotolken navigerar du till rotmappen och skapar exempelberoendena.

   cd azure-iot-sdk-java
   mvn install -DskipTests=true
   

5. Navigera till exempelmappen.

   cd provisioning/provisioning-samples/provisioning-tpm-sample
   

Läsa kryptografiska nycklar från TPM-enheten

I det här avsnittet skapar och kör du ett exempel som läser bekräftelsenyckeln och registrerings-ID:t från TPM-simulatorn som du slutade köra och som fortfarande lyssnar via portarna 2321 och 2322. Dessa värden används för enhetsregistrering med din instans för enhetsetableringstjänst.

1. Starta Visual Studio.

2. Öppna lösningen som genererades i cmake-mappen med namnet azure_iot_sdks.sln .

3. På Visual Studio väljer du Skapa > bygglösning för att skapa alla projekt i lösningen.

4. I fönstret Solution Explorer i Visual Studio går du till mappen Provision (Etablera)_Verktyg. Högerklicka på projektet tpm_device_provision och markera Set as Startup Project (Ange som startprojekt).

5. På Visual Studio väljer du Felsök > Starta utan felsökning för att köra lösningen. Appen läser och visar ett registrerings-ID och en bekräftelsenyckel. Anteckna eller kopiera dessa värden. Dessa kommer att användas i nästa avsnitt för enhetsregistrering.

1. Starta Visual Studio.

2. Öppna lösningen som genererades i cmake-mappen med namnet azure_iot_sdks.sln .

3. På Visual Studio väljer du Skapa > bygglösning för att skapa alla projekt i lösningen.

4. Högerklicka på projektet tpm_device_provision och markera Set as Startup Project (Ange som startprojekt).

5. Kör lösningen. Utdatafönstret visar bekräftelsenyckeln och det registrerings-ID som krävs för enhetsregistrering. Kopiera de här värdena.

1. Logga in på Azure Portal, välj knappen Alla resurser på den vänstra menyn och öppna Device Provisioning-tjänsten. Anteckna ID-omfånget och den globala slutpunkten för etableringstjänsten.

   

2. Redigera src/main/java/samples/com/microsoft/azure/sdk/iot/ProvisioningTpmSample.java så att ID-omfång och Global slutpunkt för etableringstjänsten inkluderas enligt tidigare notering.

   private static final String idScope = "[Your ID scope here]";
   private static final String globalEndpoint = "[Your Provisioning Service Global Endpoint here]";
   private static final ProvisioningDeviceClientTransportProtocol PROVISIONING_DEVICE_CLIENT_TRANSPORT_PROTOCOL = ProvisioningDeviceClientTransportProtocol.HTTPS;
   

3. Spara filen.

4. Använd följande kommandon för att skapa projektet, navigera till målmappen och kör den skapade .jar-filen (ersätt {version} med din version av Java):

   mvn clean install
   cd target
   java -jar ./provisioning-tpm-sample-{version}-with-deps.jar
   

5. När programmet börjar köras visas bekräftelsenyckeln och registrerings-ID:t. Kopiera dessa värden för nästa avsnitt. Se till att lämna programmet igång.

1. I Azure Portal väljer du fliken Översikt för enhetsetableringstjänsten.

2. Kopiera värdet FÖR ID-omfång.

   

3. I fönstret Solution Explorer i Visual Studio går du till mappen Provision (Etablera)_Exempel. Expandera exempelprojektet som heter prov_dev_client_sample. Expandera Källfiler och öppna prov_dev_client_sample.c.

4. Längst upp i filen hittar du #define-uttrycken för varje enhetsprotokoll enligt nedan. Se till att endast SAMPLE_AMQP saknar kommentarer.

   För närvarande stöds inte MQTT-protokollet för enskild TPM-registrering.

   //
   // The protocol you wish to use should be uncommented
   //
   //#define SAMPLE_MQTT
   //#define SAMPLE_MQTT_OVER_WEBSOCKETS
   #define SAMPLE_AMQP
   //#define SAMPLE_AMQP_OVER_WEBSOCKETS
   //#define SAMPLE_HTTP
   

5. Hitta konstanten id_scope och ersätt värdet med ditt värde för ID-omfång som du kopierade tidigare.

   static const char* id_scope = "0ne00002193";
   

6. Hitta definitionen för funktionen main() i samma fil. Kontrollera att variabeln hsm_type anges till SECURE_DEVICE_TYPE_X509 i stället för SECURE_DEVICE_TYPE_TPM enligt nedan.

   SECURE_DEVICE_TYPE hsm_type;
   //hsm_type = SECURE_DEVICE_TYPE_TPM;
   hsm_type = SECURE_DEVICE_TYPE_X509;
   

7. Högerklicka på projektet prov_dev_client_sample och välj Set as Startup Project (Ange som startprojekt).

8. På Visual Studio väljer du Felsök > Starta utan felsökning för att köra lösningen. När du uppmanas att återskapa projektet väljer du Ja för att återskapa projektet innan du kör det.

   Följande utdata är ett exempel på när etableringsenhetens klientprov lyckas med starten och ansluter till en instans av enhetsetableringstjänst för att hämta IoT-hubbinformation och registrera:

   Provisioning API Version: 1.2.7
   
   Registering... Press enter key to interrupt.
   
   Provisioning Status: PROV_DEVICE_REG_STATUS_CONNECTED
   Provisioning Status: PROV_DEVICE_REG_STATUS_ASSIGNING
   Provisioning Status: PROV_DEVICE_REG_STATUS_ASSIGNING
   
   Registration Information received from service:
   test-docs-hub.azure-devices.net, deviceId: test-docs-cert-device
   

1. I Azure Portal väljer du fliken Översikt för enhetsetableringstjänsten.

2. Kopiera värdet FÖR ID-omfång.

   

3. Öppna en valfri textredigerare.

4. I mappen registerdevice skapar du en ny RegisterDevice.js fil.

5. Lägg till följande require -instruktioner i börjanRegisterDevice.jsfilen:

   
   'use strict';
   
   var ProvisioningTransport = require('azure-iot-provisioning-device-http').Http;
   var iotHubTransport = require('azure-iot-device-mqtt').Mqtt;
   var Client = require('azure-iot-device').Client;
   var Message = require('azure-iot-device').Message;
   var tpmSecurity = require('azure-iot-security-tpm');
   var ProvisioningDeviceClient = require('azure-iot-provisioning-device').ProvisioningDeviceClient;
   

   Anteckning

   Azure IoT SDK för Node.js har stöd för fler protokoll, exempelvis AMQP, AMQP WS och MQTT WS. Fler exempel finns i Exempel på enhetsetableringstjänstens SDK för Node.js.

6. Lägg till variablerna globalDeviceEndpoint och idScope och använd dem för att skapa en ProvisioningDeviceClient-instans. Ersätt {globalDeviceEndpoint} och {idScope} med värdena i Global enhetsslutpunkt och ID-omfång från Steg 1:

   
   var provisioningHost = '{globalDeviceEndpoint}';
   var idScope = '{idScope}';
   
   var tssJs = require("tss.js");
   var securityClient = new tpmSecurity.TpmSecurityClient('', new tssJs.Tpm(true));
   // if using non-simulated device, replace the above line with following:
   //var securityClient = new tpmSecurity.TpmSecurityClient();
   
   var provisioningClient = ProvisioningDeviceClient.create(provisioningHost, idScope, new ProvisioningTransport(), securityClient);
   

7. Lägg till följande funktion för att implementera metoden på enheten:

   
   provisioningClient.register(function(err, result) {
     if (err) {
       console.log("error registering device: " + err);
     } else {
       console.log('registration succeeded');
       console.log('assigned hub=' + result.registrationState.assignedHub);
       console.log('deviceId=' + result.registrationState.deviceId);
       var tpmAuthenticationProvider = tpmSecurity.TpmAuthenticationProvider.fromTpmSecurityClient(result.registrationState.deviceId, result.registrationState.assignedHub, securityClient);
       var hubClient = Client.fromAuthenticationProvider(tpmAuthenticationProvider, iotHubTransport);
   
       var connectCallback = function (err) {
         if (err) {
           console.error('Could not connect: ' + err.message);
         } else {
           console.log('Client connected');
           var message = new Message('Hello world');
           hubClient.sendEvent(message, printResultFor('send'));
         }
       };
   
       hubClient.open(connectCallback);
   
       function printResultFor(op) {
         return function printResult(err, res) {
           if (err) console.log(op + ' error: ' + err.toString());
           if (res) console.log(op + ' status: ' + res.constructor.name);
           process.exit(1);
         };
       }
     }
   });
   

8. Spara och stäng RegisterDevice.js-filen.

9. Kör följande kommando:

   node RegisterDevice.js
   

10. Lägg märke till de meddelanden som simulerar enhetsstart och anslutning till Device Provisioning-tjänsten för att hämta IoT-hubinformationen.

1. Navigera till exempelmappen på Git-lagringsplatsen.

   cd azure-iot-sdk-python/provisioning_device_client/samples
   

2. Med python-IDE:n redigerar du Python-skriptet med namnet provisioning _ device client _ _ sample.py (replace ) (Ersätt ) och till de {globalServiceEndpoint} värden som du {idScope} kopierade tidigare). Kontrollera också att TYP av _ _ SÄKERHETSENHET är inställt på ProvisioningSecurityDeviceType.TPM .

   GLOBAL_PROV_URI = "{globalServiceEndpoint}"
   ID_SCOPE = "{idScope}"
   SECURITY_DEVICE_TYPE = ProvisioningSecurityDeviceType.TPM
   PROTOCOL = ProvisioningTransportProvider.HTTP
   

   

3. Kör exemplet.

   python provisioning_device_client_sample.py
   

4. Lägg märke till de meddelanden som simulerar enhetsstart och anslutning till Device Provisioning-tjänsten för att hämta IoT-hubinformationen.

1. I kommandofönstret som kör Java-exempelkoden på datorn trycker du på Retur för att fortsätta köra programmet. Lägg märke till de meddelanden som simulerar enhetsstart och anslutning till Device Provisioning-tjänsten för att hämta IoT-hubinformationen.