Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Portare la libreria principale PKCS11 Il Public Key Cryptography Standard \$111 definisce un'API indipendente dalla piattaforma per gestire e utilizzare i token crittografici. [PKCS 11](https://en.wikipedia.org/wiki/PKCS_11) si riferisce allo standard e a quanto da esso definito. APIs L'API crittografica PKCS \$111 astrae l'archiviazione delle chiavi, le proprietà get/set per gli oggetti crittografici e la semantica delle sessioni. È ampiamente utilizzata per manipolare oggetti crittografici comuni. Le sue funzioni consentono al software applicativo di utilizzare, creare, modificare ed eliminare oggetti crittografici, senza esporre tali oggetti alla memoria dell'applicazione. Le librerie FreerTOS e le integrazioni di riferimento utilizzano un sottoinsieme dello standard di interfaccia PCKS \$111, con particolare attenzione alle operazioni che coinvolgono chiavi asimmetriche, generazione di numeri casuali e hashing. La tabella seguente elenca i casi d'uso e il supporto richiesto da PKCS \$111. APIs **Casi d'uso** | Caso d'uso | Famiglia di API PKCS \$111 richiesta | | --- | --- | | Tutti | Inizializza, finalizza, apri/chiudi sessione, accesso GetSlotList | | Provisioning | GenerateKeyPair, CreateObject, DestroyObject, InitToken, GetTokenInfo | | TLS | Casuale, Firma, FindObject GetAttributeValue | | FreeRTOS\$1TCP | Casuale, Digest | | OTA | Verifica, Digest, FindObject GetAttributeValue | ## Quando implementare un modulo PKCS \$111 completo L'archiviazione di chiavi private nella memoria flash per scopi generici può essere utile nella valutazione e creazione rapida di prototipi di scenari. Si consiglia di utilizzare hardware crittografico dedicato per ridurre le minacce di furto di dati e duplicazione dei dispositivi negli scenari di produzione. L'hardware di crittografia include componenti con caratteristiche che impediscono l'esportazione di chiavi segrete di crittografia. Per supportare ciò, dovrai implementare un sottoinsieme di PKCS \$111 necessario per lavorare con le librerie FreerTOS come definito nella tabella precedente. ## Quando usare il core FreerTOS PKCS11 [La PKCS11 libreria principale contiene un'implementazione basata su software dell'interfaccia (API) PKCS \$111 che utilizza la funzionalità crittografica fornita da Mbed TLS.](https://tls.mbed.org/) Viene fornita per scenari di prototipazione e valutazione rapidi in cui l'hardware non dispone di un hardware crittografico dedicato. In questo caso, è sufficiente implementare il PKCS11 PAL di base per far sì che l'implementazione di PKCS11 base basata sul software funzioni con la piattaforma hardware in uso. ## Porting core PKCS11 Dovrai disporre di implementazioni per leggere e scrivere oggetti crittografici nella memoria non volatile (NVM), come la memoria flash integrata. Gli oggetti crittografici devono essere archiviati in una sezione di NVM che non è inizializzata e non viene cancellata durante la riprogrammazione del dispositivo. Gli utenti della PKCS11 libreria principale forniranno ai dispositivi le credenziali e quindi riprogrammeranno il dispositivo con una nuova applicazione che accede a tali credenziali tramite l'interfaccia principale. PKCS11 Le porte PKCS11 PAL principali devono fornire una posizione in cui archiviare: + Il certificato client del dispositivo + La chiave privata del client del dispositivo + La chiave pubblica del client del dispositivo + Una CA root affidabile + Una chiave pubblica per la verifica del codice (o un certificato che contiene la chiave pubblica per la verifica del codice) per un bootloader sicuro e gli aggiornamenti (OTA) over-the-air + Un certificato di approvvigionamento Just-In-Time [Includi il file di intestazione](https://github.com/FreeRTOS/corePKCS11/blob/main/source/include/core_pkcs11_pal.h) e implementa il PAL APIs definito. **PAL APIs** | Funzione | Descrizione | | --- | --- | | PKCS11\$1PAL\$1inizializza | Inizializza il livello PAL. Chiamato dalla PKCS11 libreria principale all'inizio della sequenza di inizializzazione. | | PKCS11\$1PAL\$1 SaveObject | Scrive i dati in storage non volatile. | | PKCS11\$1PAL\$1 FindObject | Utilizza `CKA_LABEL` PKCS \$1 11 per cercare un oggetto PKCS \$1 11 corrispondente in storage non volatile e restituisce l'handle dell'oggetto, se esistente. | | PKCS11\$1PAL\$1 GetObjectValue | Recupera il valore di un oggetto, specificato l'handle. | | PKCS11\$1PAL\$1 GetObjectValueCleanup | Pulizia per la chiamata `PKCS11_PAL_GetObjectValue`. Può essere utilizzata per liberare memoria allocata in una chiamata `PKCS11_PAL_GetObjectValue`. | ## Test in corso Se si utilizza la libreria PKCS11 principale FreerTOS o si implementa il sottoinsieme richiesto PKCS11 APIs di, è necessario superare i test FreeRTOS. PKCS11 Questi verificano se le funzioni richieste per le librerie FreerTOS funzionano come previsto. Questa sezione descrive anche come eseguire localmente i test PKCS11 FreerTOS con i test di qualificazione. ### Prerequisiti Per configurare i test PKCS11 FreerTOS, è necessario implementare quanto segue. + Una porta supportata di. PKCS11 APIs + Un'implementazione delle funzioni della piattaforma per i test di qualificazione FreerTOS che includono quanto segue: + `FRTest_ThreadCreate` + `FRTest_ThreadTimedJoin` + `FRTest_MemoryAlloc` + `FRTest_MemoryFree` (Vedi il file [README.md](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests/tree/main/src/pkcs11) per i test di integrazione delle librerie FreerTOS per PKCS \$111 in poi.) GitHub ### Test di porting + Aggiungi [ FreeRTOS-Libraries-Integration-Tests](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests/tree/main/src/pkcs11)come sottomodulo al tuo progetto. Il sottomodulo può essere inserito in qualsiasi directory del progetto, purché possa essere creato. + Copia `config_template/test_execution_config_template.h` e `config_template/test_param_config_template.h` in una posizione del progetto nel percorso di creazione e rinominali in e. `test_execution_config.h` `test_param_config.h` + Includi i file pertinenti nel sistema di compilazione. Se si utilizza`CMake`, `qualification_test.cmake` e `src/pkcs11_tests.cmake` può essere utilizzato per includere i file pertinenti. + Implementa `UNITY_OUTPUT_CHAR` in modo che i registri dell'output del test e i registri del dispositivo non si interlacciano. + Integra MbedTLS, che verifica il risultato dell'operazione cryptoki. + Chiama dall'applicazione. `RunQualificationTest()` ### Configurazione dei test La suite PKCS11 di test deve essere configurata in base all' PKCS11 implementazione. La tabella seguente elenca la configurazione richiesta dai PKCS11 test nel file di `test_param_config.h` intestazione. **PKSC11 configurazioni di test** | Configurazione | Descrizione | | --- | --- | | PKCS11\$1TEST\$1RSA\$1KEY\$1SUPPORT | Il porting supporta le funzioni chiave RSA. | | PKCS11\$1TEST\$1EC\$1KEY\$1SUPPORT | Il porting supporta le funzioni chiave EC. | | PKCS11\$1TEST\$1IMPORT\$1PRIVATE\$1KEY\$1SUPPORT | Il porting supporta l'importazione della chiave privata. L'importazione di chiavi RSA ed EC viene convalidata nel test se le funzioni chiave di supporto sono abilitate. | | PKCS11\$1TEST\$1GENERATE\$1KEYPAIR\$1SUPPORT | Il porting supporta la generazione di coppie di chiavi. La generazione di coppie di chiavi EC viene convalidata nel test se le funzioni chiave di supporto sono abilitate. | | PKCS11\$1TEST\$1PREPROVISIONED\$1SUPPORT | Il porting ha credenziali preimpostate. `PKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS`, `PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLS` e`PKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS`, sono esempi delle credenziali. | | PKCS11\$1TEST\$1LABEL\$1DEVICE\$1PRIVATE\$1KEY\$1FOR\$1TLS | L'etichetta della chiave privata utilizzata nel test. | | PKCS11\$1TEST\$1LABEL\$1DEVICE\$1PUBLIC\$1KEY\$1FOR\$1TLS | L'etichetta della chiave pubblica utilizzata nel test. | | PKCS11\$1TEST\$1LABEL\$1DEVICE\$1CERTIFICATE\$1FOR\$1TLS | L'etichetta del certificato utilizzato nel test. | | PKCS11\$1TEST\$1JITP\$1CODEVERIFY\$1ROOT\$1CERT\$1SUPPORTED | Il porting supporta l'archiviazione per JITP. Impostalo su 1 per abilitare il test JITP. `codeverify` | | PKCS11\$1TEST\$1LABEL\$1CODE\$1VERIFICATION\$1KEY | L'etichetta della chiave di verifica del codice utilizzata nel test JITP. `codeverify` | | PKCS11\$1TEST\$1LABEL\$1JITP\$1CERTIFICATE | L'etichetta del certificato JITP utilizzato nel test JITP. `codeverify` | | PKCS11\$1TEST\$1LABEL\$1ROOT\$1CERTIFICATE | L'etichetta del certificato principale utilizzato nel test JITP. `codeverify` | Le librerie FreerTOS e le integrazioni di riferimento devono supportare almeno una configurazione di funzioni chiave come le chiavi RSA o Elliptic curve e un meccanismo di provisioning chiave supportato da. PKCS11 APIs Il test deve abilitare le seguenti configurazioni: + Almeno una delle seguenti configurazioni di funzioni chiave: + PKCS11\$1TEST\$1RSA\$1KEY\$1SUPPORT + PKCS11\$1TEST\$1EC\$1KEY\$1SUPPORT + Almeno una delle seguenti configurazioni di provisioning chiave: + PKCS11\$1TEST\$1IMPORT\$1PRIVATE\$1KEY\$1SUPPORT + PKCS11\$1TEST\$1GENERATE\$1KEYPAIR\$1SUPPORT + PKCS11\$1TEST\$1PREPROVISIONED\$1SUPPORTO\$1 Il test delle credenziali del dispositivo preimpostato deve essere eseguito nelle seguenti condizioni: + `PKCS11_TEST_PREPROVISIONED_SUPPORT`deve essere abilitato e gli altri meccanismi di provisioning devono essere disabilitati. + È abilitata solo una funzione chiave`PKCS11_TEST_EC_KEY_SUPPORT`, una delle due`PKCS11_TEST_RSA_KEY_SUPPORT`. + Imposta le etichette dei tasti preimpostate in base alla tua funzione chiave`PKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS`, `PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLS` tra cui e. `PKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS` Queste credenziali devono esistere prima di eseguire il test. Potrebbe essere necessario eseguire il test più volte con configurazioni diverse, se l'implementazione supporta credenziali preimpostate e altri meccanismi di provisioning. **Nota** Gli oggetti con etichette `PKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS` `PKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS` vengono distrutti durante `PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLS` il test se uno dei due è abilitato. `PKCS11_TEST_GENERATE_KEYPAIR_SUPPORT` `PKCS11_TEST_GENERATE_KEYPAIR_SUPPORT` ### Esecuzione di test. Questa sezione descrive come testare localmente l' PKCS11 interfaccia con i test di qualificazione. In alternativa, puoi anche usare IDT per automatizzare l'esecuzione. Vedi [AWS IoT Device Tester FreerTOS nella FreerTOS](https://docs.aws.amazon.com/freertos/latest/userguide/device-tester-for-freertos-ug.html) User *Guide per i dettagli*. Le seguenti istruzioni descrivono come eseguire i test: + Aprire `test_execution_config.h` e definire **CORE\$1 PKCS11 \$1TEST\$1ENABLED** su 1. + Crea e installa l'applicazione sul tuo dispositivo per eseguirla. I risultati del test vengono inviati alla porta seriale. Di seguito è riportato un esempio del risultato del test di output. ``` 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 ``` Il test è completato quando tutti i test vengono superati. **Nota** Per qualificare ufficialmente un dispositivo per FreerTOS, devi convalidare il codice sorgente portato del dispositivo con. AWS IoT Device Tester Segui le istruzioni in [Using AWS IoT Device Tester for FreerTOS](https://docs.aws.amazon.com/freertos/latest/userguide/device-tester-for-freertos-ug.html) nella FreeRTOS User Guide per configurare la convalida delle porte. AWS IoT Device Tester Per testare la porta di una libreria specifica, è necessario abilitare il gruppo di test corretto nel file nella `device.json` cartella. AWS IoT Device Tester `configs`