Erstellen Sie einen benutzerdefinierten Zertifikatshandler für sicheren Speicher

Die Verwaltung von Gerätezertifikaten ist beim Onboarding des Managed Integrations Hubs von entscheidender Bedeutung. Zertifikate werden zwar standardmäßig im Dateisystem gespeichert, Sie können jedoch einen benutzerdefinierten Zertifikatshandler erstellen, um die Sicherheit zu erhöhen und die Anmeldeinformationen flexibel zu verwalten.

Das Endgeräte-SDK für verwaltete Integrationen stellt einen Zertifikatshandler zur sicheren Speicherschnittstelle bereit, den Sie als Bibliothek für gemeinsam genutzte Objekte (.so) implementieren können. Erstellen Sie Ihre sichere Speicherimplementierung zum Lesen und Schreiben von Zertifikaten und verknüpfen Sie dann die Bibliotheksdatei zur Laufzeit mit dem HubOnboarding Prozess.

API-Definition und Komponenten

Sehen Sie sich die folgende secure_storage_cert_handler_interface.hpp Datei an, um die API-Komponenten und Anforderungen für Ihre Implementierung zu verstehen

API-Definition

Inhalt von secure_storage_cert_hander_interface.hpp

/* 
    * Copyright 2024 Amazon.com, Inc. or its affiliates. All rights reserved. 
    *
    * AMAZON PROPRIETARY/CONFIDENTIAL 
    *
    * You may not use this file except in compliance with the terms and
    * conditions set forth in the accompanying LICENSE.txt file.
    *
    * THESE MATERIALS ARE PROVIDED ON AN "AS IS" BASIS. AMAZON SPECIFICALLY 
    * DISCLAIMS, WITH RESPECT TO THESE MATERIALS, ALL WARRANTIES, EXPRESS, 
    * IMPLIED, OR STATUTORY, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY, 
    * FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. 
    */ 
    #ifndef SECURE_STORAGE_CERT_HANDLER_INTERFACE_HPP
    #define SECURE_STORAGE_CERT_HANDLER_INTERFACE_HPP 
    
    #include <iostream>
    #include <memory>
    
    namespace IoTManagedIntegrationsDevice { 
    namespace CertHandler {
    /**
     * @enum CERT_TYPE_T
     * @brief enumeration defining certificate types. 
     */ 
     typedef enum { CLAIM = 0, DHA = 1, PERMANENT = 2 } CERT_TYPE_T;
     class SecureStorageCertHandlerInterface {
      public:
       /** 
        * @brief Read certificate and private key value of a particular certificate
        * type from secure storage.
        */ 
        virtual bool read_cert_and_private_key(const CERT_TYPE_T cert_type, 
                                              std::string &cert_value, 
                                              std::string &private_key_value) = 0; 
        /** 
          * @brief Write permanent certificate and private key value to secure storage.
          */
        virtual bool write_permanent_cert_and_private_key(
            std::string_view cert_value, std::string_view private_key_value) = 0; 
        };
        std::shared_ptr<SecureStorageCertHandlerInterface> createSecureStorageCertHandler();
    } //namespace CertHandler
    } //namespace IoTManagedIntegrationsDevice
  
    #endif //SECURE_STORAGE_CERT_HANDLER_INTERFACE_HPP

Zentrale Komponenten

• CERT_TYPE_T — verschiedene Arten von Zertifikaten auf dem Hub.

  • CLAIM — Das ursprünglich auf dem Hub befindliche Antragszertifikat wird gegen ein permanentes Zertifikat ausgetauscht.

  • DHA — vorerst unbenutzt.

  • PERMANENT — permanentes Zertifikat für die Verbindung mit dem Endpunkt für verwaltete Integrationen.

• read_cert_and_private_key — (ZU IMPLEMENTIERENDE FUNKTION) Liest Zertifikat und Schlüsselwert in die Referenzeingabe ein. Diese Funktion muss in der Lage sein, sowohl das CLAIM- als auch das PERMANENT-Zertifikat zu lesen, und unterscheidet sich durch den oben genannten Zertifikatstyp.

• write_permanent_cert_and_private_key — (ZU IMPLEMENTIERENDE FUNKTION) schreibt das permanente Zertifikat und den Schlüsselwert an den gewünschten Ort.

Beispiel für einen Build

Trennen Sie Ihre internen Implementierungsheader von der öffentlichen Schnittstelle (secure_storage_cert_handler_interface.hpp), um eine saubere Projektstruktur aufrechtzuerhalten. Durch diese Trennung können Sie öffentliche und private Komponenten verwalten und gleichzeitig Ihren Zertifikatshandler erstellen.

Anmerkung

secure_storage_cert_handler_interface.hppAls öffentlich deklarieren.

Themen

• Struktur des Projekts

• Erben Sie die Schnittstelle

• Implementierung

• CMakeList.txt

Struktur des Projekts

Erben Sie die Schnittstelle

Erstellen Sie eine konkrete Klasse, die die Schnittstelle erbt. Verstecken Sie diese Header-Datei und andere Dateien in einem separaten Verzeichnis, sodass private und öffentliche Header beim Erstellen leicht unterschieden werden können.

#ifndef IOTMANAGEDINTEGRATIONSDEVICE_SDK_STUB_SECURE_STORAGE_CERT_HANDLER_HPP
  #define IOTMANAGEDINTEGRATIONSDEVICE_SDK_STUB_SECURE_STORAGE_CERT_HANDLER_HPP 
  
  #include "secure_storage_cert_handler_interface.hpp" 
  
  namespace IoTManagedIntegrationsDevice::CertHandler { 
    class StubSecureStorageCertHandler : public SecureStorageCertHandlerInterface { 
      public:
        StubSecureStorageCertHandler() = default; 
        
        bool read_cert_and_private_key(const CERT_TYPE_T cert_type,
                                      std::string &cert_value, 
                                      std::string &private_key_value) override; 
                                      
        bool write_permanent_cert_and_private_key(
            std::string_view cert_value, std::string_view private_key_value) override; 
            /*
            * any other resource for function you might need 
            */
            
            
          }; 
      } 
    #endif //IOTMANAGEDINTEGRATIONSDEVICE_SDK_STUB_SECURE_STORAGE_CERT_HANDLER_HPP
  
  

Implementierung

Implementieren Sie die oben definierte Speicherklasse,src/stub_secure_storage_cert_handler.cpp.

/* 
  * Copyright 2024 Amazon.com, Inc. or its affiliates. All rights reserved. 
  * 
  * AMAZON PROPRIETARY/CONFIDENTIAL 
  *
  * You may not use this file except in compliance with the terms and
  * conditions set forth in the accompanying LICENSE.txt file. 
  * 
  * THESE MATERIALS ARE PROVIDED ON AN "AS IS" BASIS. AMAZON SPECIFICALLY 
  * DISCLAIMS, WITH RESPECT TO THESE MATERIALS, ALL WARRANTIES, EXPRESS, 
  * IMPLIED, OR STATUTORY, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY, 
  * FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. 
  */

  #include "stub_secure_storage_cert_handler.hpp" 
  
  using namespace IoTManagedIntegrationsDevice::CertHandler;
  
  bool StubSecureStorageCertHandler::write_permanent_cert_and_private_key( 
              std::string_view cert_value, std::string_view private_key_value) { 
            // TODO: implement write function 
            return true;
  }
  
  bool StubSecureStorageCertHandler::read_cert_and_private_key(const CERT_TYPE_T cert_type, 
                                                          std::string &cert_value,
                                                          std::string &private_key_value) {
          std::cout<<"Using Stub Secure Storage Cert Handler, returning dummy values";
          cert_value = "StubCertVal"; 
          private_key_value = "StubKeyVal"; 
          // TODO: implement read function 
          return true;
  }

  

Implementieren Sie die in der Schnittstelle definierte Factory-Funktion,src/secure_storage_cert_handler.cpp.

#include "stub_secure_storage_cert_handler.hpp"
        
        std::shared_ptr<IoTManagedIntegrationsDevice::CertHandler::SecureStorageCertHandlerInterface>
        IoTManagedIntegrationsDevice::CertHandler::createSecureStorageCertHandler() { 
          // TODO: replace with your implementation 
        return std::make_shared<IoTManagedIntegrationsDevice::CertHandler::StubSecureStorageCertHandler>(); 
      }

      

CMakeList.txt

#project name must stay the same
      project(SecureStorageCertHandler) 
      
      # Public Header files. The interface definition must be in top level with exactly the same name 
      #ie. Not in anotherDir/secure_storage_cert_hander_interface.hpp 
      set(PUBLIC_HEADERS
                ${PROJECT_SOURCE_DIR}/include 
      )
      
      # private implementation headers.
      set(PRIVATE_HEADERS 
                ${PROJECT_SOURCE_DIR}/internal/stub 
      )
      
      #set all sources 
      set(SOURCES 
                ${PROJECT_SOURCE_DIR}/src/secure_storage_cert_handler.cpp 
                ${PROJECT_SOURCE_DIR}/src/stub_secure_storage_cert_handler.cpp 
        )
        
      # Create the shared library
      add_library(${PROJECT_NAME} SHARED ${SOURCES})
      target_include_directories( 
                ${PROJECT_NAME} 
                PUBLIC
                    ${PUBLIC_HEADERS} 
                PRIVATE 
                    ${PRIVATE_HEADERS}
      )
      
      # Set the library output location. Location can be customized but version must stay the same
      set_target_properties(${PROJECT_NAME} PROPERTIES 
                LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/../lib 
                VERSION 1.0 
                SOVERSION 1
      )
      
      # Install rules
      install(TARGETS ${PROJECT_NAME} 
                LIBRARY DESTINATION lib 
                ARCHIVE DESTINATION lib 
      )
      
      install(FILES ${HEADERS} 
                DESTINATION include/SecureStorageCertHandler
      ) 

    

Verwendung

Nach der Kompilierung verfügen Sie über eine libSecureStorageCertHandler.so gemeinsam genutzte Objektbibliotheksdatei und die zugehörigen symbolischen Links. Kopieren Sie sowohl die Bibliotheksdatei als auch die symbolischen Links an den Bibliotheksort, den die HubOnboarding Binärdatei erwartet.

Themen

• Die wichtigsten Überlegungen

• Verwenden Sie sicheren Speicher

Die wichtigsten Überlegungen

• Stellen Sie sicher, dass Ihr Benutzerkonto Lese- und Schreibberechtigungen sowohl für die HubOnboarding Binärdatei als auch für die libSecureStorageCertHandler.so Bibliothek besitzt.

• Behalten Sie secure_storage_cert_handler_interface.hpp es als Ihre einzige öffentliche Header-Datei bei. Alle anderen Header-Dateien sollten in Ihrer privaten Implementierung verbleiben.

• Überprüfen Sie den Namen Ihrer Shared Object Library. Während des Builds libSecureStorageCertHandler.so ist HubOnboarding möglicherweise eine bestimmte Version im Dateinamen erforderlich, z. libSecureStorageCertHandler.so.1.0 B. Verwenden Sie den ldd Befehl, um die Bibliotheksabhängigkeiten zu überprüfen und bei Bedarf symbolische Links zu erstellen.

• Wenn Ihre Implementierung der gemeinsam genutzten Bibliothek externe Abhängigkeiten aufweist, speichern Sie diese in einem Verzeichnis, auf das zugegriffen HubOnboarding werden kann, z. B. /usr/lib or the iotmi_common Verzeichnis.

Verwenden Sie sicheren Speicher

Aktualisieren Sie Ihre iotmi_config.json Datei, indem Sie iot_claim_cert_path sowohl als auch iot_claim_pk_path auf einstellenSECURE_STORAGE.

{
  "ro": { 
    "iot_provisioning_method": "FLEET_PROVISIONING", 
    "iot_claim_cert_path": "SECURE_STORAGE",
    "iot_claim_pk_path": "SECURE_STORAGE", 
    "fp_template_name": "device-integration-example",
    "iot_endpoint_url": "[ACCOUNT-PREFIX]-ats.iot.AWS-REGION.amazonaws.com", 
    "SN": "1234567890", 
    "UPC": "1234567890" 
  },
  "rw": { 
    "iot_provisioning_state": "NOT_PROVISIONED"
  }
}