Cuándo implementar un módulo PKCS 11 completo Cuándo usar el núcleo de FreeRTOS PKCS11 Portabilidad del núcleo PKCS11 Testeo

Migración de la PKCS11 biblioteca principal

El estándar de criptografía de clave pública 11 define una API independiente de la plataforma para administrar y usar tokens criptográficos. PKCS 11 hace referencia al estándar y a lo que éste APIs define. La API criptográfica de PKCS 11 abstrae propiedades get/set, de almacenamiento de claves para objetos criptográficos y semántica de la sesión. Se usa ampliamente para manipular objetos criptográficos comunes. Sus funciones permiten al software de la aplicación utilizar, crear, modificar y eliminar objetos criptográficos sin exponerlos a la memoria de la aplicación.

Las bibliotecas FreeRTOS y las integraciones de referencia utilizan un subconjunto del estándar de interfaz PCKS 11 y se centran en las operaciones que implican claves asimétricas, generación de números aleatorios y hash. En la siguiente tabla se enumeran los casos de uso y el PKCS #11 necesario APIs para su compatibilidad.

Casos de uso
Caso de uso	Familia de API PKCS 11 necesaria
Todos	Inicializar, finalizar, abrir/cerrar sesión, iniciar sesión GetSlotList
Aprovisionando	GenerateKeyPair, CreateObject, DestroyObject, InitToken, GetTokenInfo
TLS	Aleatorio, Firmar, FindObject GetAttributeValue
FreeRTOS+TCP	Random, Digest
OTA	Verificar, digerir FindObject, GetAttributeValue

Cuándo implementar un módulo PKCS 11 completo

Almacenar claves privadas en una memoria flash de uso general puede resultar práctico en entornos de evaluación y creación rápida de prototipos. Le recomendamos que utilice hardware criptográfico dedicado para reducir las amenazas de robo de datos y duplicación de dispositivos en escenarios de producción. El hardware criptográfico incluye componentes con características que impiden la exportación de las claves criptográficas secretas. Para ello, tendrá que implementar un subconjunto de PKCS 11 necesario para trabajar con las bibliotecas de FreeRTOS, tal y como se define en la tabla anterior.

Cuándo usar el núcleo de FreeRTOS PKCS11

La PKCS11 biblioteca principal contiene una implementación basada en software de la interfaz (API) PKCS #11 que utiliza la funcionalidad criptográfica proporcionada por Mbed TLS. Se proporciona para escenarios de creación rápida de prototipos y evaluación en los que el hardware no tiene un hardware criptográfico dedicado. En este caso, solo tiene que implementar la PKCS11 PAL básica para que la implementación básica PKCS11 basada en software funcione con su plataforma de hardware.

Portabilidad del núcleo PKCS11

Deberá disponer de implementaciones para leer y escribir objetos criptográficos en la memoria no volátil (NVM), como la memoria flash integrada. Los objetos criptográficos deben almacenarse en una sección de la NVM que no esté inicializada y que no se borre en caso de reprogramación del dispositivo. Los usuarios de la PKCS11 biblioteca principal suministrarán credenciales a los dispositivos y, a continuación, reprogramarán el dispositivo con una nueva aplicación que acceda a estas credenciales a través de la interfaz principalPKCS11 . Los puertos PKCS11 PAL principales deben proporcionar una ubicación para almacenar:

El certificado de cliente del dispositivo
La clave privada de cliente del dispositivo
La clave pública de cliente del dispositivo
Una CA raíz de confianza
Una clave pública de verificación de código (o un certificado que contenga la clave pública de verificación de código) para garantizar la seguridad de las actualizaciones del gestor de arranque y (OTA) over-the-air
Just-In-TimeUn certificado de aprovisionamiento

Incluya el archivo de cabecera e implemente el PAL APIs definido.

PAL APIs
Función	Descripción
PKCS11_PAL_Inicializar	Inicializa la capa de PAL. Lo llama la PKCS11 biblioteca principal al comienzo de su secuencia de inicialización.
PKCS11_PAL_ SaveObject	Escribe datos en almacenamiento no volátil.
PKCS11_PAL_ FindObject	Utiliza una etiqueta `CKA_LABEL` de PKCS #11 para buscar el objeto de PKCS # 11 correspondiente en el almacenamiento no volátil y devuelve un identificador del mismo, si existe.
PKCS11_PAL_ GetObjectValue	Obtiene el valor de un objeto a partir del identificador.
PKCS11_PAL_ GetObjectValueCleanup	Limpieza para la llamada `PKCS11_PAL_GetObjectValue`. Se puede utilizar para liberar la memoria asignada en una llamada `PKCS11_PAL_GetObjectValue`.

Testeo

Si utilizas la PKCS11 biblioteca principal de FreeRTOS o implementas el subconjunto necesario de PKCS11 APIs, debes superar las pruebas de FreeRTOS. PKCS11 Estas prueban si las funciones requeridas para las bibliotecas de FreeRTOS funcionan según lo esperado.

En esta sección también se describe cómo puede ejecutar localmente las pruebas de FreeRTOS con PKCS11 las pruebas de calificación.

Requisitos previos

Para configurar las PKCS11 pruebas de Freertos, se debe implementar lo siguiente.

Un puerto compatible de. PKCS11 APIs
Una implementación de las funciones de la plataforma de pruebas de calificación de FreeRTOS, que incluye las siguientes:
- FRTest_ThreadCreate
- FRTest_ThreadTimedJoin
- FRTest_MemoryAlloc
- FRTest_MemoryFree

(Consulte el archivo README.md para ver las pruebas de integración de las bibliotecas FreeRTOS para PKCS #11 en adelante). GitHub

Portabilidad de pruebas

FreeRTOS-Libraries-Integration-TestsAñádelo como submódulo a tu proyecto. El submódulo se puede colocar en cualquier directorio del proyecto, siempre que se pueda crear.
Copie config_template/test_execution_config_template.h y config_template/test_param_config_template.h en una ubicación del proyecto en la ruta de creación y cámbieles el nombre a test_execution_config.h y test_param_config.h.
Incluya los archivos relevantes en el sistema creación. Si utiliza CMake, qualification_test.cmake y src/pkcs11_tests.cmake se pueden usar para incluir los archivos relevantes.
Implemente UNITY_OUTPUT_CHAR de forma que los registros de salida de las pruebas y los registros del dispositivo no se intercalen.
Integre el MbedTLS, que verifica el resultado de la operación cryptoki.
Llame a RunQualificationTest() desde la aplicación.

Configuración de las pruebas

El conjunto PKCS11 de pruebas debe configurarse de acuerdo con la PKCS11 implementación. La siguiente tabla muestra la configuración requerida para las PKCS11 pruebas del archivo de test_param_config.h cabecera.

PKSC11 configuraciones de prueba
Configuración	Descripción
PKCS11_TEST_RSA_KEY_SUPPORT	La portabilidad admite las funciones clave de RSA.
PKCS11_TEST_EC_KEY_SUPPORT	La portabilidad admite las funciones clave de EC.
PKCS11_TEST_IMPORT_PRIVATE_KEY_SUPPORT	La portabilidad admite la importación de la clave privada. La importación de claves RSA y EC se valida en la prueba si las funciones clave auxiliares están habilitadas.
PKCS11_TEST_GENERATE_KEYPAIR_SUPPORT	La portabilidad admite la generación de pares de claves. La importación de pares de claves EC se valida en la prueba si las funciones clave auxiliares están habilitadas.
PKCS11_TEST_PREPROVISIONED_SUPPORT	La portabilidad tiene credenciales previamente aprovisionadas. `PKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS`, `PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLS` y `PKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS` son ejemplos de las credenciales.
PKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS	La etiqueta de la clave privada utilizada en la prueba.
PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLS	La etiqueta de la clave pública utilizada en la prueba.
PKCS11_TEST_LABEL_DEVICE_CERTIFICATE_PARA_TLS	La etiqueta del certificado utilizado en la prueba.
PKCS11_TEST_JITP_CODEVERIFY_ROOT_CERT_SUPPORTED	La portabilidad admite el almacenamiento de JITP. Establézcalo en 1 para habilitar la prueba `codeverify` de JITP.
PKCS11_TEST_LABEL_CODE_VERIFICATION_KEY	La etiqueta de la clave de verificación de código utilizada en la prueba `codeverify` de JITP.
PKCS11_TEST_LABEL_JITP_CERTIFICATE	La etiqueta del certificado de JITP utilizado en la prueba `codeverify` de JITP.
PKCS11_TEST_LABEL_ROOT_CERTIFICATE	La etiqueta del certificado raíz utilizado en la prueba `codeverify` de JITP.

Las bibliotecas Freertos y las integraciones de referencia deben admitir como mínimo una configuración de función clave, como RSA o claves de curva elíptica, y un mecanismo de aprovisionamiento clave compatible con. PKCS11 APIs La prueba debe habilitar las siguientes configuraciones:

Al menos una de las siguientes configuraciones de funciones de clave:
- PKCS11_TEST_RSA_KEY_SUPPORT
- PKCS11_TEST_EC_KEY_SUPPORT
Al menos una de las siguientes configuraciones de aprovisionamiento de clave:
- PKCS11_TEST_IMPORT_PRIVATE_KEY_SUPPORT
- PKCS11_TEST_GENERATE_KEYPAIR_SUPPORT
- PKCS11_TEST_PREPROVISIONED_SUPPORT

La prueba de credenciales del dispositivo aprovisionada previamente debe ejecutarse en las siguientes condiciones:

PKCS11_TEST_PREPROVISIONED_SUPPORT debe estar activado y otros mecanismos de aprovisionamiento inhabilitados.
Solo debe estar habilitada una función: PKCS11_TEST_RSA_KEY_SUPPORT o PKCS11_TEST_EC_KEY_SUPPORT.
Configure las etiquetas de clave previamente aprovisionadas de acuerdo con su función de clave, incluidas PKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS, PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLS y PKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS. Estas credenciales deben existir antes de ejecutar la prueba.

Es posible que la prueba deba ejecutarse varias veces con diferentes configuraciones, si la implementación admite credenciales previamente aprovisionadas y otros mecanismos de aprovisionamiento.

nota

Los objetos con las etiquetas PKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS, PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLS y PKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS se destruyen durante la prueba si PKCS11_TEST_GENERATE_KEYPAIR_SUPPORT o PKCS11_TEST_GENERATE_KEYPAIR_SUPPORT está habilitada.

Ejecución de pruebas

En esta sección se describe cómo se puede probar localmente la interfaz con las pruebas de calificación. PKCS11 También puede utilizar IDT para automatizar la ejecución. Consulte AWS IoT Device Tester para FreeRTOS en la Guía del usuario de FreeRTOS para obtener más información.

Las siguientes instrucciones describen cómo ejecutar las pruebas:

Abra test_execution_config.h y defina CORE_ PKCS11 _TEST_ENABLED en 1.
Cree e instale la aplicación en su dispositivo para ejecutarla. El resultado de la prueba se envía al puerto serie.

A continuación se muestra un ejemplo del resultado de la prueba de salida.



TEST(Full_PKCS11_StartFinish, PKCS11_StartFinish_FirstTest) PASS
TEST(Full_PKCS11_StartFinish, PKCS11_GetFunctionList) PASS
TEST(Full_PKCS11_StartFinish, PKCS11_InitializeFinalize) PASS
TEST(Full_PKCS11_StartFinish, PKCS11_GetSlotList) PASS
TEST(Full_PKCS11_StartFinish, PKCS11_OpenSessionCloseSession) PASS
TEST(Full_PKCS11_Capabilities, PKCS11_Capabilities) PASS
TEST(Full_PKCS11_NoObject, PKCS11_Digest) PASS
TEST(Full_PKCS11_NoObject, PKCS11_Digest_ErrorConditions) PASS
TEST(Full_PKCS11_NoObject, PKCS11_GenerateRandom) PASS
TEST(Full_PKCS11_NoObject, PKCS11_GenerateRandomMultiThread) PASS
TEST(Full_PKCS11_RSA, PKCS11_RSA_CreateObject) PASS
TEST(Full_PKCS11_RSA, PKCS11_RSA_FindObject) PASS
TEST(Full_PKCS11_RSA, PKCS11_RSA_GetAttributeValue) PASS
TEST(Full_PKCS11_RSA, PKCS11_RSA_Sign) PASS
TEST(Full_PKCS11_RSA, PKCS11_RSA_FindObjectMultiThread) PASS
TEST(Full_PKCS11_RSA, PKCS11_RSA_GetAttributeValueMultiThread) PASS
TEST(Full_PKCS11_RSA, PKCS11_RSA_DestroyObject) PASS
TEST(Full_PKCS11_EC, PKCS11_EC_GenerateKeyPair) PASS
TEST(Full_PKCS11_EC, PKCS11_EC_CreateObject) PASS
TEST(Full_PKCS11_EC, PKCS11_EC_FindObject) PASS
TEST(Full_PKCS11_EC, PKCS11_EC_GetAttributeValue) PASS
TEST(Full_PKCS11_EC, PKCS11_EC_Sign) PASS
TEST(Full_PKCS11_EC, PKCS11_EC_Verify) PASS
TEST(Full_PKCS11_EC, PKCS11_EC_FindObjectMultiThread) PASS
TEST(Full_PKCS11_EC, PKCS11_EC_GetAttributeValueMultiThread) PASS
TEST(Full_PKCS11_EC, PKCS11_EC_SignVerifyMultiThread) PASS
TEST(Full_PKCS11_EC, PKCS11_EC_DestroyObject) PASS

-----------------------
27 Tests 0 Failures 0 Ignored
OK

Las pruebas se completan cuando se superan todas.

nota

Para calificar oficialmente un dispositivo para FreeRTOS, debes validar con él el código fuente portado del dispositivo. AWS IoT Device Tester Siga las instrucciones de Uso AWS IoT Device Tester para FreeRTOS de la Guía del usuario de FreeRTOS para configurar AWS IoT Device Tester la validación de puertos. Para probar el puerto de una biblioteca específica, debe estar habilitado el grupo de prueba correcto en el device.json archivo de la AWS IoT Device Tester configs carpeta.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

TCP/IP

Interfaz de transporte de red