Portage de la bibliothèque CorePKCS11 - FreeRTOS

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Portage de la bibliothèque CorePKCS11

Le Public Key Cryptography Standard #11 définit une API indépendante de la plate-forme pour gérer et utiliser des jetons cryptographiques. PCS 11fait référence à la norme et aux API définies par celui-ci. L'API cryptographique PKCS #11 extrait le stockage de clés, les propriétés get/set des objets cryptographiques et la sémantique de session. Il est largement utilisé pour manipuler des objets cryptographiques courants. Ses fonctions permettent aux logiciels d'application d'utiliser, de créer, de modifier et de supprimer des objets cryptographiques, sans exposer ces objets à la mémoire de l'application.

Les bibliothèques FreeRTOS et les intégrations de référence utilisent un sous-ensemble de la norme d'interface PCKS #11, en mettant l'accent sur les opérations impliquant des clés asymétriques, la génération de nombres aléatoires et le hachage. Le tableau ci-dessous répertorie les cas d'utilisation et les API PKCS #11 requises pour prendre en charge.

Cas d'utilisation
Cas d'utilisation Famille d'API PKCS #11 requise
Tous Initialiser, Finaliser, Ouvrir/Fermer la session, GetSlotList, Connexion
PROVISIONING GenerateKeyPair, CreateObject, DestroyObject, Init Token, GetTokenInfo
TLS Aléatoire, Signer, FindObject, GetAttributeValue
FreeRTOS+TCP Aléatoire, Digest
OTA Vérifier, Digester, FindObject, GetAttributeValue

Quand implémenter un module PKCS #11 complet

Le stockage des clés privées dans la mémoire flash à usage général peut être pratique dans les scénarios d'évaluation et de prototype rapide. Nous vous recommandons d'utiliser du matériel cryptographique dédié pour réduire les menaces de vol de données et de duplication de périphérique dans les scénarios de production. Le matériel cryptographique inclut les composants ayant des fonctionnalités qui empêchent que les clés de chiffrement secrètes soient exportées. Pour ce faire, vous devrez implémenter un sous-ensemble de PKCS #11 requis pour fonctionner avec les bibliothèques FreeRTOS telles que définies dans le tableau ci-dessus.

Quand utiliser FreeRTOS CorePKCS11

La bibliothèque CorePKCS11 contient une implémentation logicielle de l'interface PKCS #11 (API) qui utilise la fonctionnalité cryptographique fournie parIncorporer TLS. Ceci est fourni pour les scénarios de prototypage et d'évaluation rapides dans lesquels le matériel ne dispose pas de matériel cryptographique dédié. Dans ce cas, il suffit d'implémenter CorePKCS11 PAL pour que l'implémentation basée sur le logiciel CorePKCS11 fonctionne avec votre plate-forme matérielle.

Coeur de portage PKCS11

Vous devrez disposer d'implémentations pour lire et écrire des objets cryptographiques dans une mémoire non volatile (NVM), par exemple, la mémoire flash embarquée. Les objets cryptographiques doivent être stockés dans une section de la NVM qui n'est pas initialisée et qui n'est pas effacée lors de la reprogrammation du périphérique. Les utilisateurs de la bibliothèque CorePKCS11 approvisionnent les périphériques en informations d'identification, puis reprogramment le périphérique avec une nouvelle application pouvant accéder à ces informations d'identification via l'interface CorePKCS11. Les ports PAL CorePKCS11 doivent fournir un emplacement pour stocker :

  • Le certificat de périphérique client

  • La clé privée de périphérique client

  • La clé publique de périphérique client

  • Une autorité de certification racine fiable

  • Une clé publique de vérification de code (ou un certificat qui contient la clé de vérification de code) pour le chargeur de démarrage sécurisé et over-the-air Mises à jour (OTA)

  • Un certificat de mise en service « juste-à-temps »

Inclurele fichier d'en-têteet implémentez les API PAL définies.

API PAL
Fonction Description
PKCS11_PAL_Initialize

Initialise la couche PAL. Appelé par la bibliothèque CorePKCS11 au début de sa séquence d'initialisation.

Objet PKCS11_PAL_Save'

Écrit les données sur un espace de stockage non volatile.

PKCS11_PAL_FindObject

Utilise un CKA_LABEL PKCS #11 pour rechercher un objet PKCS #11 correspondant espace de stockage non volatile et renvoie le handle d'objet, le cas échéant.

PKCS11_PAL_GetObjectValue

Récupère la valeur d'un objet, en prenant l’exemple du handle.

PKCS11_PAL_GetObject ValeurCleanup

Effectue un nettoyage pour l'appel de PKCS11_PAL_GetObjectValue. Peut être utilisée pour libérer de la mémoire dédiée à un appel PKCS11_PAL_GetObjectValue.

Test

Si vous utilisez la bibliothèque FreeRTOS CorePKCS11 ou si vous implémentez le sous-ensemble requis d'API PKCS11, vous devez passer les tests FreeRTOS PKCS11. Ces tests testent si les fonctions requises pour les bibliothèques FreeRTOS fonctionnent comme prévu.

Elle explique également comment exécuter localement les tests FreeRTOS PKCS11 avec les tests de qualification.

Prérequis

Pour configurer les tests FreeRTOS PKCS11, les éléments suivants doivent être implémentés.

  • Port pris en charge des API PKCS11.

  • Une implémentation de tests de qualification FreeRTOSfonctions de plateformequi incluent les éléments suivants :

    • FRTest_ThreadCreate

    • FRTest_ThreadTimedJoin

    • FRTest_MemoryAlloc

    • FRTest_MemoryFree

Essais de portage

  • AdditionTests d'intégration des bibliothèques FreerTOSen tant que sous-module de votre projet. Le sous-module peut être placé dans n'importe quel répertoire du projet, tant qu'il peut être créé.

  • Copierconfig_template/test_execution_config_template.hetconfig_template/test_param_config_template.hvers un emplacement de projet dans le chemin de construction, puis renommez-le entest_execution_config.hettest_param_config.h.

  • Incluez les fichiers pertinents dans le système de génération. Si vous utilisezCMake,qualification_test.cmakeetsrc/pkcs11_tests.cmakepeut être utilisé pour inclure des fichiers pertinents.

  • Implémentez .UNITY_OUTPUT_CHARde sorte que les journaux de sortie de test et les journaux de périphériques ne s'entremêlent pas.

  • Intégrez les MBEDTLS, qui vérifie le résultat de l'opération cryptoki.

  • AppelezRunQualificationTest()depuis l'application.

Configuration des tests

La suite de tests PKCS11 doit être configurée conformément à l'implémentation PKCS11. Le tableau suivant répertorie la configuration requise par les tests PKCS11 dans letest_param_config.hfichier d'en-tête.

Configurations de test PKSC11
Configuration Description
PKCS11_TEST_RSA_KEY_SUPPORT

Le portage prend en charge les fonctions clés RSA.

PKCS11_TEST_EC_KEY_SUPPORT

Le portage prend en charge les fonctions clés EC.

PKCS11_TEST_IMPORT_PRIVATE_KEY_SUPPORT

Le portage prend en charge l'importation de la clé privée. L'importation de clés RSA et EC est validée dans le test si les fonctions clés de prise en charge sont activées.

PKCS11_TEST_GENERATE_KEYPAIR_SUPPORT

Le portage prend en charge la génération de paires de clés. La génération de paires de clés EC est validée dans le test si les fonctions clés prises en charge sont activées.

PKCS11_TEST_PREPROVISIONED_SUPPORT

Le portage comporte des informations d'identification préprovisionnées.PKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS,PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLSetPKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS, sont des exemples d'informations d'identification.

PKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS

Étiquette de la clé privée utilisée dans le test.

PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLS

Étiquette de la clé publique utilisée dans le test.

PKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS

Étiquette du certificat utilisé dans le test.

PKCS11_TEST_JITP_CODEVERIFY_ROOT_CERT_SUPPORTÉ

Le portage prend en charge le stockage pour JITP. Pour activer le JITP, définissez ce paramètre sur 1.codeverifytest.

PKCS11_TEST_LABEL_CODE_VERIFICATION_KEY

L'étiquette de la clé de vérification du code utilisée dans JITPcodeverifytest.

PKCS11_TEST_LABEL_JITP_CERTIFICATE

L'étiquette du certificat JITP utilisé dans JITPcodeverifytest.

PKCS11_TEST_LABEL_ROOT_CERTIFICATE

L'étiquette du certificat racine utilisé dans JITPcodeverifytest.

Les bibliothèques FreeRTOS et les intégrations de référence doivent prendre en charge au moins une configuration de fonction clé telle que les clés de courbe RSA ou elliptique, et un mécanisme de provisionnement de clés pris en charge par les API PKCS11. Le test doit activer les configurations suivantes :

  • Au moins l'une des configurations de fonctions clés suivantes :

    • PKCS11_TEST_RSA_KEY_SUPPORT

    • PKCS11_TEST_EC_KEY_SUPPORT

  • Au moins l'une des configurations de provisioning de clés suivantes :

    • PKCS11_TEST_IMPORT_PRIVATE_KEY_SUPPORT

    • PKCS11_TEST_GENERATE_KEYPAIR_SUPPORT

    • PKCS11_TEST_PREPROVISIONED_SUPPORT

Le test d'informations d'identification de périphérique préprovisionné doit être exécuté dans les conditions suivantes :

  • PKCS11_TEST_PREPROVISIONED_SUPPORTdoivent être activés et les autres mécanismes de provisionnement doivent être désactivés.

  • Une seule fonction clé, soitPKCS11_TEST_RSA_KEY_SUPPORTouPKCS11_TEST_EC_KEY_SUPPORT, est activé.

  • Configurez les étiquettes de clés préprovisionnées en fonction de votre fonction clé, y comprisPKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS,PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLSetPKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS. Ces informations d'identification doivent exister avant d'exécuter le test.

Le test peut devoir être exécuté plusieurs fois avec des configurations différentes, si l'implémentation prend en charge les informations d'identification préprovisionnées et d'autres mécanismes de provisionnement.

Note

Les objets avec des étiquettesPKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS,PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLSetPKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLSsont détruits pendant le test si l'un ou l'autrePKCS11_TEST_GENERATE_KEYPAIR_SUPPORTouPKCS11_TEST_GENERATE_KEYPAIR_SUPPORTest activé.

Exécution de tests

Cette section décrit comment tester localement l'interface PKCS11 avec les tests de qualification. Sinon, vous pouvez utiliser IDT pour automatiser l'exécution. VoirAWS IoT Device Testerpour FreeRTOSdans leGuide de l'utilisateur FreeRTOSpour de plus amples informations.

Les instructions suivantes expliquent comment exécuter les tests :

  • Ouvrirtest_execution_config.het définirCORE_PKCS11_TEST_ENABLEDà 1.

  • Créez et flashez l'application sur votre périphérique pour l'exécuter. Le résultat du test est envoyé au port série.

Voici un exemple du résultat du test en sortie.

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

Les tests sont terminés lorsque chacun des tests est réussi.

Note

Pour qualifier officiellement un périphérique pour FreeRTOS, vous devez valider le code source porté du périphérique avecAWS IoT Device Tester. Suivez les instructions de la sectionA l'aide deAWS IoT Device Testerpour FreeRTOSdans le guide de l'utilisateur FreeRTOS pour configurerAWS IoT Device Testerpour la validation des ports. Pour tester le port d'une bibliothèque spécifique, le groupe de test correct doit être activé dans le champ dedevice.jsondans le fichierAWS IoT Device Tester configsfolder.