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 PKCS11 Kernbibliothek
Der Public Key Cryptography Standard \$111 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 \$111 abstrahiert die Speicherung von Schlüsseln, das Abrufen/Setzen von Eigenschaften für kryptografische Objekte und die 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 \$111, wobei der Schwerpunkt auf Operationen liegt, die asymmetrische Schlüssel, Zufallszahlengenerierung und Hashing beinhalten. In der folgenden Tabelle sind die Anwendungsfälle und die für die Unterstützung erforderlichen PKCS \$111 aufgeführt. APIs
**Anwendungsfälle**
| Anwendungsfall | Erforderliche PKCS \$111 -API-Familie |
| --- | --- |
| Alle | Sitzung initialisieren, abschließen, Sitzung öffnen/schließen, Anmelden GetSlotList |
| Bereitstellung | GenerateKeyPair, CreateObject, DestroyObject, InitToken, GetTokenInfo |
| TLS | Zufällig, Signieren, FindObject GetAttributeValue |
| FreeRTOS\$1TCP | Zufällig, Digest |
| OTA | Verifizieren, Digest, FindObject GetAttributeValue |
## Wann sollte ein vollständiges PKCS \$111 -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 \$111 implementieren, die für die Arbeit mit FreeRTOS-Bibliotheken erforderlich ist, wie in der obigen Tabelle definiert.
## Wann sollte FreeRTOS Core verwendet werden PKCS11
[Die PKCS11 Kernbibliothek enthält eine softwarebasierte Implementierung der PKCS \$111 -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 PKCS11 Core-PAL implementieren, damit die PKCS11 softwarebasierte Kernimplementierung mit Ihrer Hardwareplattform funktioniert.
## Core portieren PKCS11
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 PKCS11 Kernbibliothek stellen den Geräten Anmeldeinformationen zur Verfügung und programmieren das Gerät anschließend mit einer neuen Anwendung neu, die über die Kernschnittstelle auf diese Anmeldeinformationen zugreift. PKCS11 Die wichtigsten PKCS11 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 (OTA-) Updates over-the-air
+ 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 APIs definierte PAL.
**PAL APIs**
| Funktion | Beschreibung |
| --- | --- |
| PKCS11\$1PAL\$1initialisieren | Initialisiert die PAL-Ebene. Wird von der PKCS11 Kernbibliothek zu Beginn ihrer Initialisierungssequenz aufgerufen. |
| PKCS11\$1PAL\$1 SaveObject | Schreibt Daten in den nichtflüchtigen Speicher. |
| PKCS11\$1PAL\$1 FindObject | Verwendet einen PKCS \$1 11 `CKA_LABEL`, um nach einem entsprechenden PKCS \$111-Objekt im nichtflüchtigen Speicher zu suchen, und gibt das Handle dieses Objekts zurück, falls es existiert. |
| PKCS11\$1PAL\$1 GetObjectValue | Liefert den Wert eines Objekts entsprechend dem Handle. |
| PKCS11\$1PAL\$1 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 PKCS11 FreeRTOS-Kernbibliothek verwenden oder die erforderliche Teilmenge davon implementieren PKCS11 APIs, müssen Sie die FreeRTOS-Tests bestehen. PKCS11 Diese testen, ob die erforderlichen Funktionen für FreeRTOS-Bibliotheken erwartungsgemäß funktionieren.
In diesem Abschnitt wird auch beschrieben, wie Sie die PKCS11 FreeRTOS-Tests mit den Qualifikationstests lokal ausführen können.
### Voraussetzungen
Um die PKCS11 FreeRTOS-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 Datei [README.md](https://github.com/FreeRTOS/FreeRTOS-Libraries-Integration-Tests/tree/main/src/pkcs11) finden Sie die Integrationstests für PKCS \$111 von FreeRTOS Libraries.) 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 Konfiguration aufgeführt, die für PKCS11 Tests in der `test_param_config.h` Header-Datei erforderlich ist.
**PKSC11 Testkonfigurationen**
| Konfiguration | Beschreibung |
| --- | --- |
| PKCS11\$1TEST\$1RSA\$1KEY\$1SUPPORT | Die Portierung unterstützt RSA-Schlüsselfunktionen. |
| PKCS11\$1TEST\$1EC\$1KEY\$1SUPPORT | Die Portierung unterstützt EC-Schlüsselfunktionen. |
| PKCS11\$1TEST\$1IMPORT\$1PRIVATE\$1KEY\$1SUPPORT | 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\$1TEST\$1GENERATE\$1KEYPAIR\$1SUPPORT | 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\$1TEST\$1PREPROVISIONED\$1SUPPORT | Für die Portierung wurden vorab Anmeldeinformationen 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\$1TEST\$1LABEL\$1DEVICE\$1PRIVATE\$1KEY\$1FOR\$1TLS | Die Bezeichnung des privaten Schlüssels, der im Test verwendet wurde. |
| PKCS11\$1TEST\$1LABEL\$1DEVICE\$1PUBLIC\$1KEY\$1FOR\$1TLS | Die Bezeichnung des öffentlichen Schlüssels, der im Test verwendet wurde. |
| PKCS11\$1TEST\$1LABEL\$1DEVICE\$1CERTIFICATE\$1FOR\$1TLS | Die Bezeichnung des im Test verwendeten Zertifikats. |
| PKCS11\$1TEST\$1JITP\$1CODEVERIFY\$1ROOT\$1CERT\$1SUPPORTED | Die Portierung unterstützt Speicher für JITP. Stellen Sie diesen Wert auf 1 ein, um den `codeverify` JITP-Test zu aktivieren. |
| PKCS11\$1TEST\$1LABEL\$1CODE\$1VERIFICATION\$1KEY | Die Bezeichnung des Code-Bestätigungsschlüssels, der im JITP-Test verwendet wird. `codeverify` |
| PKCS11\$1TEST\$1LABEL\$1JITP\$1CERTIFICATE | Die Bezeichnung des JITP-Zertifikats, das im JITP-Test verwendet wird. `codeverify` |
| PKCS11\$1TEST\$1LABEL\$1ROOT\$1CERTIFICATE | Die Bezeichnung des im JITP-Test verwendeten Stammzertifikats. `codeverify` |
FreeRTOS-Bibliotheken und Referenzintegrationen müssen mindestens eine Tastenfunktionskonfiguration wie RSA- oder Elliptic Curve-Tasten und einen von der unterstützten Schlüsselbereitstellungsmechanismus unterstützen. PKCS11 APIs Der Test muss die folgenden Konfigurationen ermöglichen:
+ Mindestens eine der folgenden Konfigurationen der wichtigsten Funktionen:
+ PKCS11\$1TEST\$1RSA\$1KEY\$1SUPPORT
+ PKCS11\$1TEST\$1EC\$1KEY\$1SUPPORT
+ Mindestens eine der folgenden wichtigen Bereitstellungskonfigurationen:
+ PKCS11\$1TEST\$1IMPORT\$1PRIVATE\$1KEY\$1SUPPORT
+ PKCS11\$1TEST\$1GENERATE\$1KEYPAIR-UNTERSTÜTZUNG
+ PKCS11\$1TEST\$1VORAB BEREITGESTELLTE\$1UNTERSTÜTZUNG
Der Test der vorab bereitgestellten Geräteanmeldedaten muss unter den folgenden Bedingungen ausgeführt werden:
+ `PKCS11_TEST_PREPROVISIONED_SUPPORT`muss aktiviert und andere Bereitstellungsmechanismen deaktiviert sein.
+ Nur eine Schlüsselfunktion, 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\$1 PKCS11 \$1TEST\$1ENABLED** 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`