Cree un controlador de certificados personalizado para un almacenamiento seguro - Integraciones gestionadas para AWS IoT Device Management
Definición y componentes de la APIEjemplo de compilaciónUso

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Cree un controlador de certificados personalizado para un almacenamiento seguro

La gestión de los certificados de los dispositivos es crucial a la hora de incorporar el centro de integraciones gestionadas. Si bien los certificados se almacenan en el sistema de archivos de forma predeterminada, puede crear un controlador de certificados personalizado para mejorar la seguridad y una administración flexible de las credenciales.

El SDK para dispositivos finales de integraciones administradas proporciona un controlador de certificados para proteger la interfaz de almacenamiento que puede implementar como una biblioteca de objetos compartidos (.so). Cree su implementación de almacenamiento seguro para leer y escribir certificados y, a continuación, vincule el archivo de la biblioteca al HubOnboarding proceso en tiempo de ejecución.

Definición y componentes de la API

Revise el siguiente secure_storage_cert_handler_interface.hpp archivo para comprender los componentes y requisitos de la API para su implementación

Definición de API

Contenido de 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

Componentes principales

  • CERT_TYPE_T: diferentes tipos de certificados en el hub.

    • RECLAMACIÓN: el certificado de reclamación que originalmente estaba en el centro se cambiará por un certificado permanente.

    • DHA: no se ha utilizado por el momento.

    • PERMANENTE: certificado permanente para conectarse con el punto final de integraciones gestionadas.

  • read_cert_and_private_key - (FUNCIÓN A IMPLEMENTAR) Lee el certificado y el valor de la clave en la entrada de referencia. Esta función debe poder leer tanto el certificado CLAIM como el PERMANENTE, y se diferencia por el tipo de certificado mencionado anteriormente.

  • write_permanent_cert_and_private_key: (FUNCIÓN POR IMPLEMENTAR) escribe el certificado permanente y el valor de la clave en la ubicación deseada.

Ejemplo de compilación

Separe los encabezados de implementación internos de la interfaz pública (secure_storage_cert_handler_interface.hpp) para mantener una estructura de proyecto limpia. Con esta separación, puede administrar los componentes públicos y privados mientras crea su controlador de certificados.

nota

secure_storage_cert_handler_interface.hppDeclárelo como público.

Estructura del proyecto

Estructura del proyecto del gestor de certificados de integraciones gestionadas.

Herede la interfaz

Cree una clase concreta que herede la interfaz. Oculte este archivo de encabezado y otros archivos en un directorio independiente para que los encabezados privados y públicos se puedan diferenciar fácilmente al crear.

#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

Implementación

Implemente la clase de almacenamiento definida anteriormente,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;
  }

Implemente la función de fábrica definida en la interfaz,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
      )

Uso

Tras la compilación, dispondrá de un archivo de biblioteca de objetos libSecureStorageCertHandler.so compartido y sus enlaces simbólicos asociados. Copie el archivo de la biblioteca y los enlaces simbólicos en la ubicación de la biblioteca que espera el HubOnboarding binario.

Consideraciones clave

  • Compruebe que su cuenta de usuario tenga permisos de lectura y escritura tanto para el archivo HubOnboarding binario como para la libSecureStorageCertHandler.so biblioteca.

  • Manténgalo secure_storage_cert_handler_interface.hpp como único archivo de encabezado público. Todos los demás archivos de encabezado deben permanecer en su implementación privada.

  • Verifica el nombre de la biblioteca de objetos compartidos. Mientras compilaslibSecureStorageCertHandler.so, HubOnboarding es posible que necesites una versión específica en el nombre del archivo, por ejemplolibSecureStorageCertHandler.so.1.0. Usa el ldd comando para comprobar las dependencias de la biblioteca y crear enlaces simbólicos según sea necesario.

  • Si la implementación de la biblioteca compartida tiene dependencias externas, guárdelas en un directorio al que HubOnboarding pueda acceder, como /usr/lib or the iotmi_common un directorio.

Utilice un almacenamiento seguro

Actualice iotmi_config.json el archivo configurando ambos iot_claim_cert_path valores como y iot_claim_pk_pathSECURE_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"
  }
}