Quando implementare un modulo PKCS #11 completo Quando usare FreerTOS CorePKCS11 Portare CorePKCS11 Test in corso

Portare la libreria CorePKCS11

Il Public Key Cryptography Standard #11 definisce un'API indipendente dalla piattaforma per gestire e utilizzare i token crittografici. PKCS 11 fa riferimento allo standard e alle API da esso definite. L'API crittografica PKCS #11 astrae l'archiviazione delle chiavi, get/set le proprietà degli 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 #11, con particolare attenzione alle operazioni che coinvolgono chiavi asimmetriche, generazione di numeri casuali e hashing. La tabella seguente elenca i casi d'uso e le API PKCS #11 richieste da supportare.

Casi d'uso
Caso d'uso	Famiglia di API PKCS #11 richiesta
Tutti	Inizializzazione, finalizzazione, Open/Close sessione, accesso GetSlotList
Approvvigionamento	GenerateKeyPair, CreateObject, DestroyObject, InitToken, GetTokenInfo
TLS	Casuale, Sign, FindObject GetAttributeValue
FreeRTOS+TCP	Casuale, Digest
OTA	Verifica, Digest, FindObject GetAttributeValue

Quando implementare un modulo PKCS #11 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 #11 necessario per lavorare con le librerie FreerTOS come definito nella tabella precedente.

Quando usare FreerTOS CorePKCS11

La libreria CorePKCS11 contiene un'implementazione basata su software dell'interfaccia (API) PKCS #11 che utilizza la funzionalità crittografica fornita da Mbed TLS. Viene fornita per scenari di prototipazione e valutazione rapida in cui l'hardware non dispone di un hardware crittografico dedicato. In questo caso, è sufficiente implementare CorePKCS11 PAL per far funzionare l'implementazione basata sul software CorePKCS11 con la piattaforma hardware in uso.

Portare CorePKCS11

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 libreria CorePKCS11 forniranno ai dispositivi le credenziali e quindi riprogrammeranno il dispositivo con una nuova applicazione che accede a tali credenziali tramite l'interfaccia CorePKCS11. Le porte PAL CorePKCS11 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 over-the-air (OTA)
Un certificato di approvvigionamento Just-In-Time

Includi il file di intestazione e implementa le API PAL definite.

API PAL
Funzione	Description
PKCS11_PAL_inizializza	Inizializza il livello PAL. Chiamato dalla libreria CorePKCS11 all'inizio della sequenza di inizializzazione.
PKCS11_PAL_ SaveObject	Scrive i dati in storage non volatile.
PKCS11_PAL_ FindObject	Utilizza `CKA_LABEL` PKCS # 11 per cercare un oggetto PKCS # 11 corrispondente in storage non volatile e restituisce l'handle dell'oggetto, se esistente.
PKCS11_PAL_ GetObjectValue	Recupera il valore di un oggetto, specificato l'handle.
PKCS11_PAL_ 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 utilizzi la libreria FreerTOS CorePKCS11 o implementi il sottoinsieme richiesto di API PKCS11, devi 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 FreerTOS PKCS11 con i test di qualificazione.

Prerequisiti

Per configurare i test FreerTOS PKCS11, è necessario implementare quanto segue.

Una porta supportata di API PKCS11.
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 README.mdfile per i test di integrazione delle librerie FreerTOS per PKCS #11 in poi.) GitHub

Test di portabilità

Aggiungi FreeRTOS-Libraries-Integration-Testscome 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 utilizzaCMake, 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 di test PKCS11 deve essere configurata in base all'implementazione PKCS11. La tabella seguente elenca la configurazione richiesta dai test PKCS11 nel file di intestazione. test_param_config.h

Configurazioni di test PKSC11
Configurazione	Description
PKCS11_TEST_RSA_KEY_SUPPORT	Il porting supporta le funzioni chiave RSA.
PKCS11_TEST_EC_KEY_SUPPORT	Il porting supporta le funzioni chiave EC.
PKCS11_TEST_IMPORT_PRIVATE_KEY_SUPPORT	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_TEST_GENERATE_KEYPAIR_SUPPORT	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_TEST_PREPROVISIONED_SUPPORT	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_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS	L'etichetta della chiave privata utilizzata nel test.
PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLS	L'etichetta della chiave pubblica utilizzata nel test.
PKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS	L'etichetta del certificato utilizzato nel test.
PKCS11_TEST_JITP_CODEVERIFY_ROOT_CERT_SUPPORTED	Il porting supporta l'archiviazione per JITP. Impostalo su 1 per abilitare il test JITP. `codeverify`
PKCS11_TEST_LABEL_CODE_VERIFICATION_KEY	L'etichetta della chiave di verifica del codice utilizzata nel test JITP. `codeverify`
PKCS11_TEST_LABEL_JITP_CERTIFICATE	L'etichetta del certificato JITP utilizzato nel test JITP. `codeverify`
PKCS11_TEST_LABEL_ROOT_CERTIFICATE	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 dalle API PKCS11. Il test deve abilitare le seguenti configurazioni:

Almeno una delle seguenti configurazioni di funzioni chiave:
- PKCS11_TEST_RSA_KEY_SUPPORT
- PKCS11_TEST_EC_KEY_SUPPORT
Almeno una delle seguenti configurazioni di provisioning chiave:
- PKCS11_TEST_IMPORT_PRIVATE_KEY_SUPPORT
- PKCS11_TEST_GENERATE_KEYPAIR_SUPPORT
- PKCS11_TEST_PREPROVISIONED_SUPPORT

Il test delle credenziali del dispositivo preimpostato deve essere eseguito nelle seguenti condizioni:

PKCS11_TEST_PREPROVISIONED_SUPPORTdeve essere abilitato e gli altri meccanismi di provisioning devono essere disabilitati.
È abilitata solo una funzione chiavePKCS11_TEST_EC_KEY_SUPPORT, una delle duePKCS11_TEST_RSA_KEY_SUPPORT.
Imposta le etichette dei tasti preimpostate in base alla tua funzione chiavePKCS11_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'interfaccia PKCS11 con i test di qualificazione. In alternativa, puoi anche usare IDT per automatizzare l'esecuzione. Vedi AWS IoT Device Tester FreerTOS nella FreerTOS User Guide per i dettagli.

Le seguenti istruzioni descrivono come eseguire i test:

Aprire test_execution_config.h e definire CORE_PKCS11_TEST_ENABLED su 1.
Compilate e installate l'applicazione sul 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 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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

TCP/IP

Interfaccia di trasporto di rete