Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Portierung der CorePKCS11-Bibliothek
Der Public Key Cryptography Standard \#11 definiert eine plattformunabhängige API zur Verwaltung und Verwendung kryptografischer Token. [PKCS 11](https://en.wikipedia.org/wiki/PKCS_11) bezieht sich auf den Standard und die durch ihn definierten APIs. Die kryptografische API PKCS \#11 abstrahiert Schlüsselspeicher, get/set Eigenschaften für kryptografische Objekte und Sitzungssemantik. Sie wird häufig zur Manipulation gängiger kryptografischer Objekte verwendet. Seine Funktionen ermöglichen es Anwendungssoftware, kryptografische Objekte zu verwenden, zu erstellen, zu ändern und zu löschen, ohne dass diese Objekte dem Speicher der Anwendung zugänglich gemacht werden.
FreeRTOS-Bibliotheken und Referenzintegrationen verwenden eine Teilmenge des Schnittstellenstandards PCKS \#11, wobei der Schwerpunkt auf Operationen liegt, die asymmetrische Schlüssel, Zufallszahlengenerierung und Hashing beinhalten. In der folgenden Tabelle sind die Anwendungsfälle und die zu unterstützenden PKCS \#11 -APIs aufgeführt.
**Anwendungsfälle**
| Anwendungsfall | Erforderliche PKCS \#11 -API-Familie |
| --- | --- |
| Alle | Initialisieren, Abschließen, Open/Close Sitzung, Anmeldung GetSlotList |
| Bereitstellung | GenerateKeyPair, CreateObject, DestroyObject, InitToken, GetTokenInfo |
| TLS | Zufällig, Signieren, FindObject GetAttributeValue |
| FreeRTOS\+TCP | Zufällig, Digest |
| OTA | Verifizieren, Digest, FindObject GetAttributeValue |
## Wann sollte ein vollständiges PKCS \#11 -Modul implementiert werden
Die Speicherung privater Schlüssel in einem universellen Flash-Speicher kann in Evaluierungs- und Rapid-Prototyping-Szenarien nützlich sein. Wir empfehlen die Verwendung spezieller kryptografischer Hardware, um die Gefahr von Datendiebstahl und Geräteduplizierung in Produktionsszenarien zu verringern. Die kryptographische Hardware enthält Komponenten mit Funktionen, die den Export kryptographischer Geheimschlüssel verhindern. Um dies zu unterstützen, müssen Sie eine Teilmenge von PKCS \#11 implementieren, die für die Arbeit mit FreeRTOS-Bibliotheken erforderlich ist, wie in der obigen Tabelle definiert.
## Wann sollte FreeRTOS CorePKCS11 verwendet werden
[Die CorePKCS11-Bibliothek enthält eine softwarebasierte Implementierung der PKCS \#11 -Schnittstelle (API), die die von Mbed TLS bereitgestellten kryptografischen Funktionen verwendet.](https://tls.mbed.org/) Dies ist für schnelle Prototyping- und Evaluierungsszenarien vorgesehen, in denen die Hardware nicht über eine spezielle kryptografische Hardware verfügt. In diesem Fall müssen Sie nur CorePKCS11 PAL implementieren, damit die softwarebasierte CorePKCS11-Implementierung mit Ihrer Hardwareplattform funktioniert.
## Portierung von CorePKCS11
Sie benötigen Implementierungen zum Lesen und Schreiben kryptografischer Objekte in nichtflüchtigen Speicher (NVM), z. B. im integrierten Flash-Speicher. Kryptografische Objekte müssen in einem NVM-Abschnitt gespeichert werden, der nicht initialisiert und bei einer Neuprogrammierung des Geräts nicht gelöscht wird. Benutzer der CorePKCS11-Bibliothek stellen Geräten Anmeldeinformationen zur Verfügung und programmieren das Gerät anschließend mit einer neuen Anwendung neu, die über die CorePKCS11-Schnittstelle auf diese Anmeldeinformationen zugreift. Die CorePKCS11 PAL-Ports müssen einen Speicherort für Folgendes bereitstellen:
+ Das Geräte-Client-Zertifikat
+ Der private Schlüssel des Geräteclients
+ Der öffentliche Schlüssel des Geräteclients
+ Eine vertrauenswürdige Root-CA
+ Ein öffentlicher Schlüssel zur Codeverifizierung (oder ein Zertifikat, das den öffentlichen Schlüssel zur Codeverifizierung enthält) für sichere Bootloader- und Over-the-Air-Updates (OTA)
+ Ein Bereitstellungszertifikat Just-In-Time
Fügen [Sie die Header-Datei hinzu](https://github.com/FreeRTOS/corePKCS11/blob/main/source/include/core_pkcs11_pal.h) und implementieren Sie die definierten PAL-APIs.
**PAL-APIs**
| Funktion | Description |
| --- | --- |
| PKCS11\_PAL\_initialisieren | Initialisiert die PAL-Ebene. Wird von der CorePKCS11-Bibliothek zu Beginn ihrer Initialisierungssequenz aufgerufen. |
| PKCS11\_PAL\_ SaveObject | Schreibt Daten in den nichtflüchtigen Speicher. |
| PKCS11\_PAL\_ FindObject | Verwendet einen PKCS \# 11 `CKA_LABEL`, um nach einem entsprechenden PKCS \#11-Objekt im nichtflüchtigen Speicher zu suchen, und gibt das Handle dieses Objekts zurück, falls es existiert. |
| PKCS11\_PAL\_ GetObjectValue | Liefert den Wert eines Objekts entsprechend dem Handle. |
| PKCS11\_PAL\_ GetObjectValueCleanup | Bereinigung für den `PKCS11_PAL_GetObjectValue`-Aufruf. Kann verwendet werden, um den in einem `PKCS11_PAL_GetObjectValue`-Aufruf zugewiesenen Speicherplatz freizugeben. |
## Testen
Wenn Sie die FreeRTOS CorePKCS11-Bibliothek verwenden oder die erforderliche Teilmenge der PKCS11-APIs implementieren, müssen Sie die FreeRTOS-PKCS11-Tests bestehen. Diese testen, ob die erforderlichen Funktionen für FreeRTOS-Bibliotheken erwartungsgemäß funktionieren.
In diesem Abschnitt wird auch beschrieben, wie Sie die FreeRTOS PKCS11-Tests mit den Qualifikationstests lokal ausführen können.
### Voraussetzungen
Um die FreeRTOS PKCS11-Tests einzurichten, muss Folgendes implementiert werden.
+ Ein unterstützter Port von PKCS11-APIs.
+ Eine Implementierung von Funktionen der FreeRTOS-Plattform für Qualifizierungstests, die Folgendes umfassen:
+ `FRTest_ThreadCreate`
+ `FRTest_ThreadTimedJoin`
+ `FRTest_MemoryAlloc`
+ `FRTest_MemoryFree`
(In der [ README.md](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests/tree/main/src/pkcs11)Datei finden Sie die FreeRTOS Libraries Integration Tests for PKCS \#11 auf.) GitHub
### Tests portieren
+ Fügen Sie [ FreeRTOS-Libraries-Integration-Tests](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests/tree/main/src/pkcs11)es als Submodul zu Ihrem Projekt hinzu. Das Submodul kann in einem beliebigen Verzeichnis des Projekts platziert werden, sofern es erstellt werden kann.
+ Kopieren Sie `config_template/test_execution_config_template.h` und `config_template/test_param_config_template.h` an einen Projektspeicherort im Build-Pfad und benennen Sie sie in `test_execution_config.h` und `test_param_config.h` um.
+ Fügen Sie relevante Dateien in das Build-System ein. Falls verwendet`CMake`, `qualification_test.cmake` und `src/pkcs11_tests.cmake` kann verwendet werden, um relevante Dateien einzubeziehen.
+ Implementieren Sie `UNITY_OUTPUT_CHAR` es so, dass sich Testausgabeprotokolle und Geräteprotokolle nicht überschneiden.
+ Integrieren Sie das MbedTLS, das das Ergebnis des Cryptoki-Vorgangs verifiziert.
+ Rufen Sie `RunQualificationTest()` von der Anwendung aus an.
### Tests konfigurieren
Die PKCS11-Testsuite muss entsprechend der PKCS11-Implementierung konfiguriert werden. In der folgenden Tabelle ist die für PKCS11-Tests erforderliche Konfiguration in der Header-Datei aufgeführt. `test_param_config.h`
**PKS-C11-Testkonfigurationen**
| Konfiguration | Description |
| --- | --- |
| PKCS11\_TEST\_RSA\_KEY\_SUPPORT | Die Portierung unterstützt RSA-Schlüsselfunktionen. |
| PKCS11\_TEST\_EC\_KEY\_SUPPORT | Die Portierung unterstützt EC-Schlüsselfunktionen. |
| PKCS11\_TEST\_IMPORT\_PRIVATE\_KEY\_SUPPORT | Die Portierung unterstützt den Import des privaten Schlüssels. Der Import von RSA- und EC-Schlüsseln wird im Test validiert, wenn die unterstützenden Schlüsselfunktionen aktiviert sind. |
| PKCS11\_TEST\_GENERATE\_KEYPAIR\_SUPPORT | Die Portierung unterstützt die Generierung von Schlüsselpaaren. Die Generierung von EC-Schlüsselpaaren wird im Test validiert, wenn die unterstützenden Tastenfunktionen aktiviert sind. |
| PKCS11\_TEST\_PREPROVISIONED\_SUPPORT | Für die Portierung wurden vorab Zugangsdaten bereitgestellt. `PKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS`, `PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLS` und`PKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS`, sind Beispiele für die Anmeldeinformationen. |
| PKCS11\_TEST\_LABEL\_DEVICE\_PRIVATE\_KEY\_FOR\_TLS | Die Bezeichnung des privaten Schlüssels, der im Test verwendet wurde. |
| PKCS11\_TEST\_LABEL\_DEVICE\_PUBLIC\_KEY\_FOR\_TLS | Die Bezeichnung des öffentlichen Schlüssels, der im Test verwendet wurde. |
| PKCS11\_TEST\_LABEL\_DEVICE\_CERTIFICATE\_FOR\_TLS | Die Bezeichnung des im Test verwendeten Zertifikats. |
| PKCS11\_TEST\_JITP\_CODEVERIFY\_ROOT\_CERT\_SUPPORTED | Die Portierung unterstützt Speicher für JITP. Stellen Sie diesen Wert auf 1 ein, um den `codeverify` JITP-Test zu aktivieren. |
| PKCS11\_TEST\_LABEL\_CODE\_VERIFICATION KEY | Die Bezeichnung des Code-Bestätigungsschlüssels, der im JITP-Test verwendet wird. `codeverify` |
| PKCS11\_TEST\_LABEL\_JITP\_CERTIFICATE | Die Bezeichnung des JITP-Zertifikats, das im JITP-Test verwendet wird. `codeverify` |
| PKCS11\_TEST\_LABEL\_ROOT\_CERTIFICATE | Die Bezeichnung des im JITP-Test verwendeten Stammzertifikats. `codeverify` |
FreeRTOS-Bibliotheken und Referenzintegrationen müssen mindestens eine Tastenfunktionskonfiguration wie RSA oder Elliptic Curve Keys sowie einen von den PKCS11-APIs unterstützten Schlüsselbereitstellungsmechanismus unterstützen. Der Test muss die folgenden Konfigurationen ermöglichen:
+ Mindestens eine der folgenden Konfigurationen der wichtigsten Funktionen:
+ PKCS11\_TEST\_RSA\_KEY\_SUPPORT
+ PKCS11\_TEST\_EC\_KEY\_SUPPORT
+ Mindestens eine der folgenden wichtigen Bereitstellungskonfigurationen:
+ PKCS11\_TEST\_IMPORT\_PRIVATE\_KEY\_SUPPORT
+ PKCS11\_TEST\_GENERATE\_KEYPAIR\_SUPPORT
+ PKCS11\_TEST\_PREPROVISIONED\_SUPPORT
Der Test der vorab bereitgestellten Geräte-Anmeldeinformationen muss unter den folgenden Bedingungen ausgeführt werden:
+ `PKCS11_TEST_PREPROVISIONED_SUPPORT`muss aktiviert und andere Bereitstellungsmechanismen deaktiviert sein.
+ Nur eine Tastenfunktion, entweder `PKCS11_TEST_RSA_KEY_SUPPORT` oder`PKCS11_TEST_EC_KEY_SUPPORT`, ist aktiviert.
+ Richten Sie die vorab bereitgestellten Tastenbezeichnungen entsprechend Ihrer Tastenfunktion ein, einschließlich`PKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS`, und`PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLS`. `PKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS` Diese Anmeldeinformationen müssen vorhanden sein, bevor der Test ausgeführt werden kann.
Der Test muss möglicherweise mehrmals mit unterschiedlichen Konfigurationen ausgeführt werden, wenn die Implementierung vorab bereitgestellte Anmeldeinformationen und andere Bereitstellungsmechanismen unterstützt.
**Anmerkung**
Die Objekte mit Labels `PKCS11_TEST_LABEL_DEVICE_PUBLIC_KEY_FOR_TLS` und `PKCS11_TEST_LABEL_DEVICE_CERTIFICATE_FOR_TLS` werden während des Tests zerstört`PKCS11_TEST_LABEL_DEVICE_PRIVATE_KEY_FOR_TLS`, wenn entweder `PKCS11_TEST_GENERATE_KEYPAIR_SUPPORT` oder `PKCS11_TEST_GENERATE_KEYPAIR_SUPPORT` aktiviert ist.
### Ausführen von Tests
In diesem Abschnitt wird beschrieben, wie Sie die PKCS11-Schnittstelle mit den Qualifikationstests lokal testen können. Alternativ können Sie IDT auch verwenden, um die Ausführung zu automatisieren. Einzelheiten finden Sie unter [AWS IoT Device Tester für FreeRTOS](https://docs.aws.amazon.com/freertos/latest/userguide/device-tester-for-freertos-ug.html) im *FreeRTOS-Benutzerhandbuch*.
Die folgenden Anweisungen beschreiben, wie die Tests ausgeführt werden:
+ Öffnen `test_execution_config.h` und definieren Sie **CORE\_PKCS11\_TEST\_ENABLED** auf 1.
+ Erstellen Sie die Anwendung und flashen Sie sie auf Ihr Gerät, um sie auszuführen. Die Testergebnisse werden an die serielle Schnittstelle ausgegeben.
Das Folgende ist ein Beispiel für das ausgegebene Testergebnis.
```
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
```
Der Test ist abgeschlossen, wenn alle Tests erfolgreich absolviert wurden.
**Anmerkung**
Um ein Gerät offiziell für FreeRTOS zu qualifizieren, müssen Sie den portierten Quellcode des Geräts mit validieren. AWS IoT Device Tester Folgen Sie den Anweisungen [unter Using AWS IoT Device Tester for FreeRTOS](https://docs.aws.amazon.com/freertos/latest/userguide/device-tester-for-freertos-ug.html) im FreeRTOS User Guide, um die Port-Validierung einzurichten AWS IoT Device Tester . Um den Port einer bestimmten Bibliothek zu testen, muss die richtige Testgruppe in der `device.json` Datei im Ordner aktiviert sein. AWS IoT Device Tester `configs`