Hinweis zum Ende des Supports: Am 7. Oktober 2026 AWS wird der Support für eingestellt. AWS IoT Greengrass Version 1 Nach dem 7. Oktober 2026 können Sie nicht mehr auf die Ressourcen zugreifen. AWS IoT Greengrass V1 Weitere Informationen finden Sie unter [Migrieren von AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).
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.
# Modul 7: Simulation der Hardware-Sicherheitsintegration
Diese Funktion ist für AWS IoT Greengrass Core v1.7 und höher verfügbar.
Dieses Modul für Fortgeschrittene zeigt Ihnen, wie Sie ein simuliertes Hardware-Sicherheitsmodul (HSM) für die Verwendung mit einem Greengrass Core konfigurieren. Die Konfiguration verwendet SoftHSM. Dabei handelt es sich um eine reine Software-Implementierung mithilfe der [PKCS\$111](#console-mod7-see-also) Application Programming Interface (API). Zweck dieses Moduls ist es, Ihnen die Einrichtung einer Umgebung zu ermöglichen, in der Sie lernen und erste Tests in einer reinen Software-Implementierung der PKCS\$111-API durchführen können. Das Modul wird nur für Lern- und Ersttests bereitgestellt, nicht für den produktiven Einsatz jeglicher Art.
Mit dieser Konfiguration können Sie mit einem PKCS\$111-kompatiblen Service zum Speichern Ihrer privaten Schlüssel experimentieren. Weitere Informationen über die reine Software-Implementierung finden Sie unter [SoftHSM](https://www.opendnssec.org/softhsm/). Weitere Informationen zur Integration der Hardwaresicherheit auf einem AWS IoT Greengrass Core, einschließlich allgemeiner Anforderungen, finden Sie unter[Integration von Hardware-Sicherheit](hardware-security.md).
**Wichtig**
Dieses Modul ist nur für Experimentierzwecke gedacht. Wir raten dringend davon ab, SoftHSM in einer Produktionsumgebung einzusetzen, da dies ein falsches Gefühl von zusätzlicher Sicherheit vermitteln könnte. Die resultierende Konfiguration bietet jedoch keine tatsächlichen Sicherheitsvorteile. Die in SoftHSM gespeicherten Schlüssel sind nicht sicherer als jede andere Art der Geheimhaltung in der Greengrass-Umgebung.
Dieses Modul soll Ihnen ermöglichen, sich über die PKCS\$111-Spezifikation zu informieren und erste Tests Ihrer Software durchzuführen, wenn Sie planen, in Zukunft ein echtes hardwarebasiertes HSM einzusetzen.
Sie müssen Ihre zukünftige Hardware-Implementierung separat und vollständig vor jeder Produktionsnutzung testen, da es Unterschiede zwischen der in SoftHSM bereitgestellten PKCS\$111-Implementierung und einer hardwarebasierten Implementierung geben kann.
Wenn Sie Hilfe beim Onboarding eines [unterstützten Hardware-Sicherheitsmoduls](hardware-security.md#hardware-security-reqs) benötigen, wenden Sie sich an Ihren AWS Enterprise Support-Mitarbeiter.
Bevor Sie beginnen, führen Sie das [Greengrass Device Setup-Skript](quick-start.md) aus oder stellen Sie sicher, dass Sie [Modul 1](module1.md) und [Modul 2](module2.md) des Lernprogramms „Erste Schritte“ abgeschlossen haben. In diesem Modul gehen wir davon aus, dass Ihr Core bereits bereitgestellt ist und mit ihm kommuniziert. AWS Dieses Modul sollte etwa 30 Minuten in Anspruch nehmen.
## Installieren der SoftHSM-Software
In diesem Schritt installieren Sie SoftHSM und die pkcs11-Tools, mit denen Sie Ihre SoftHSM-Instance verwalten.
+ Führen Sie in einem Terminal auf Ihrem AWS IoT Greengrass Core-Gerät den folgenden Befehl aus:
```
sudo apt-get install softhsm2 libsofthsm2-dev pkcs11-dump
```
Weitere Informationen zu diesen Paketen finden Sie unter [Installieren von softhsm2](https://www.howtoinstall.co/en/ubuntu/xenial/softhsm2), [Installieren von libsofthsm2-dev](https://www.howtoinstall.co/en/ubuntu/xenial/libsofthsm2-dev) und [Installieren von pkcs11-dump](https://www.howtoinstall.co/en/ubuntu/xenial/pkcs11-dump).
**Anmerkung**
Wenn Sie bei der Verwendung dieses Befehls auf Ihrem System auf Probleme stoßen, lesen Sie [SoftHSM Version 2](https://github.com/opendnssec/SoftHSMv2) auf. GitHub Diese Seite bietet weitere Installationsinformationen, einschließlich der Anleitung zum Erstellen aus dem Quellcode.
## Konfigurieren von SoftHSM
In diesem Schritt [konfigurieren Sie SoftHSM](https://github.com/opendnssec/SoftHSMv2#configure-1).
1. Wechseln Sie zum Root-Benutzer.
```
sudo su
```
1. Verwenden Sie die Handbuchseite, um den systemweiten `softhsm2.conf`-Speicherort zu suchen. Ein häufiger Speicherort ist `/etc/softhsm/softhsm2.conf`, jedoch kann der Speicherort auf einigen Systemen abweichen.
```
man softhsm2.conf
```
1. Erstellen Sie das Verzeichnis für die softhsm2-Konfigurationsdatei im systemweiten Speicherort. In diesem Beispiel nehmen wir an, der Speicherort lautet `/etc/softhsm/softhsm2.conf`.
```
mkdir -p /etc/softhsm
```
1. Erstellen Sie das Token-Verzeichnis im Verzeichnis `/greengrass`.
**Anmerkung**
Wenn dieser Schritt übersprungen wird, meldet softhsm2 `ERROR: Could not initialize the library`.
```
mkdir -p /greengrass/softhsm2/tokens
```
1. Konfigurieren Sie das Token-Verzeichnis.
```
echo "directories.tokendir = /greengrass/softhsm2/tokens" > /etc/softhsm/softhsm2.conf
```
1. Konfigurieren Sie eine Datei-basierte Backend.
```
echo "objectstore.backend = file" >> /etc/softhsm/softhsm2.conf
```
**Anmerkung**
Diese Konfigurationseinstellungen sind nur für Experimentierzwecke gedacht. Um alle Konfigurationsoptionen anzuzeigen, lesen Sie die Handbuchseite für die Konfigurationsdatei.
```
man softhsm2.conf
```
## Importieren des privaten Schlüssels in SoftHSM
In diesem Schritt initialisieren Sie das SoftHSM-Token, konvertieren das Format des privaten Schlüssels und importieren dann den privaten Schlüssel.
1. Initialisieren Sie das SoftHSM-Token.
```
softhsm2-util --init-token --slot 0 --label greengrass --so-pin 12345 --pin 1234
```
**Anmerkung**
Geben Sie bei Aufforderung den SO-Pin `12345` und den Benutzer-Pin `1234` ein. AWS IoT Greengrass verwendet nicht den SO (Supervisor) Pin, sodass Sie jeden beliebigen Wert verwenden können.
Wenn Sie die Fehlermeldung `CKR_SLOT_ID_INVALID: Slot 0 does not exist` erhalten, versuchen Sie es stattdessen mit dem folgenden Befehl:
```
softhsm2-util --init-token --free --label greengrass --so-pin 12345 --pin 1234
```
1. Konvertieren Sie den privaten Schlüssel in ein Format, das vom SoftHSM-Import-Tool verwendet werden kann. Für dieses Tutorial konvertieren Sie den privaten Schlüssel, den Sie von der Option **Default Group creation (Standard-Gruppenerstellung)** in [Modul 2](module2.md) des Tutorials „Erste Schritte“ erhalten haben.
```
openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in hash.private.key -out hash.private.pem
```
1. Importieren Sie den privaten Schlüssel in SoftHSM. Führen Sie nur einen der folgenden Befehle aus, je nach Ihrer softhsm2-Version.
**Raspbian softhsm2-util v2.2.0**-Syntax
```
softhsm2-util --import hash.private.pem --token greengrass --label iotkey --id 0000 --pin 12340
```
**Ubuntu softhsm2-util v2.0.0**-Syntax
```
softhsm2-util --import hash.private.pem --slot 0 --label iotkey --id 0000 --pin 1234
```
Dieser Befehl identifiziert den Slot als `0` und definiert das Schlüssel-Label als `iotkey`. Sie brauchen diese Werte im nächsten Abschnitt.
Nachdem der private Schlüssel importiert wurde, können Sie ihn optional aus dem Verzeichnis `/greengrass/certs` entfernen. Achten Sie darauf, dass sich die Stammzertifikate für CA und Gerät im Verzeichnis befinden.
## Konfigurieren des GreengrassCore für die Verwendung von SoftHSM
In diesem Schritt ändern Sie die Greengrass Core-Konfigurationsdatei für die Verwendung von SoftHSM.
1. Suchen Sie den Pfad zur SoftHSM-Anbieterbibliothek (`libsofthsm2.so`) auf Ihrem System:
1. Holen Sie sich die Liste der installierten Pakete für die Bibliothek.
```
sudo dpkg -L libsofthsm2
```
Die Datei `libsofthsm2.so` befindet sich im Verzeichnis `softhsm`.
1. Kopieren Sie den vollständigen Pfad in die Datei (z. B. `/usr/lib/x86_64-linux-gnu/softhsm/libsofthsm2.so`). Sie benötigen sie später.
1. Stoppen Sie den Greengrass-Daemon.
```
cd /greengrass/ggc/core/
sudo ./greengrassd stop
```
1. Öffnen Sie die Greengrass-Konfigurationsdatei. Dies ist die Datei [`config.json`](gg-core.md#config-json) im Verzeichnis `/greengrass/config`.
**Anmerkung**
Die Beispiele in diesem Verfahren sind unter der Annahme verfasst, dass die Datei `config.json` das Format verwendet, das aus der Option **Easy Group creation (Einfache Gruppenerstellung)** in [Modul 2](module2.md) des Tutorials „Erste Schritte“ erzeugt wird.
1. Fügen Sie in das Objekt `crypto.principals` das folgende MQTT Server-Zertifikat-Objekt ein. Fügen Sie bei Bedarf ein Komma hinzu, um eine gültige JSON-Datei zu erstellen.
```
"MQTTServerCertificate": {
"privateKeyPath": "path-to-private-key"
}
```
1. Fügen Sie in das Objekt `crypto` das folgende `PKCS11`-Objekt ein. Fügen Sie bei Bedarf ein Komma hinzu, um eine gültige JSON-Datei zu erstellen.
```
"PKCS11": {
"P11Provider": "/path-to-pkcs11-provider-so",
"slotLabel": "crypto-token-name",
"slotUserPin": "crypto-token-user-pin"
}
```
Die Datei sollte wie folgt aussehen:
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "hash.cert.pem",
"keyPath" : "hash.private.key",
"thingArn" : "arn:partition:iot:region:account-id:thing/core-thing-name",
"iotHost" : "host-prefix.iot.region.amazonaws.com",
"ggHost" : "greengrass.iot.region.amazonaws.com",
"keepAlive" : 600
},
"runtime" : {
"cgroup" : {
"useSystemd" : "yes"
}
},
"managedRespawn" : false,
"crypto": {
"PKCS11": {
"P11Provider": "/path-to-pkcs11-provider-so",
"slotLabel": "crypto-token-name",
"slotUserPin": "crypto-token-user-pin"
},
"principals" : {
"MQTTServerCertificate": {
"privateKeyPath": "path-to-private-key"
},
"IoTCertificate" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key",
"certificatePath" : "file:///greengrass/certs/hash.cert.pem"
},
"SecretsManager" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key"
}
},
"caPath" : "file:///greengrass/certs/root.ca.pem"
}
}
```
**Anmerkung**
Um over-the-air (OTA-) Updates mit Hardwaresicherheit verwenden zu können, muss das `PKCS11` Objekt auch die `OpenSSLEngine` Eigenschaft enthalten. Weitere Informationen finden Sie unter [Konfigurieren Sie die Unterstützung für Updates over-the-air](hardware-security.md#hardware-security-ota-updates).
1. Bearbeiten Sie das Objekt `crypto`:
1. Konfigurieren Sie das Objekt `PKCS11`.
+ Geben Sie für `P11Provider` den vollständigen Pfad zur Datei `libsofthsm2.so` ein.
+ Geben Sie unter `slotLabel` den Wert `greengrass` ein.
+ Geben Sie unter `slotUserPin` den Wert `1234` ein.
1. Konfigurieren Sie die privaten Schlüsselpfade im Objekt `principals`. Bearbeiten Sie die Eigenschaft `certificatePath` nicht.
+ Geben Sie für die Eigenschaften `privateKeyPath` den folgenden RFC 7512 PKCS\$111-Pfad ein (der die Bezeichnung des Schlüssels angibt). Machen Sie dies für die Prinzipale von `IoTCertificate`, `SecretsManager` und `MQTTServerCertificate`.
```
pkcs11:object=iotkey;type=private
```
1. Prüfen Sie das `crypto`-Objekt. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
"crypto": {
"PKCS11": {
"P11Provider": "/usr/lib/x86_64-linux-gnu/softhsm/libsofthsm2.so",
"slotLabel": "greengrass",
"slotUserPin": "1234"
},
"principals": {
"MQTTServerCertificate": {
"privateKeyPath": "pkcs11:object=iotkey;type=private"
},
"SecretsManager": {
"privateKeyPath": "pkcs11:object=iotkey;type=private"
},
"IoTCertificate": {
"certificatePath": "file://certs/core.crt",
"privateKeyPath": "pkcs11:object=iotkey;type=private"
}
},
"caPath": "file://certs/root.ca.pem"
}
```
1. Entfernen Sie die Werte für `caPath`, `certPath` und `keyPath` aus dem `coreThing`-Objekt. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
"coreThing" : {
"thingArn" : "arn:partition:iot:region:account-id:thing/core-thing-name",
"iotHost" : "host-prefix-ats.iot.region.amazonaws.com",
"ggHost" : "greengrass-ats.iot.region.amazonaws.com",
"keepAlive" : 600
}
```
**Anmerkung**
Für dieses Tutorial geben Sie für alle Prinzipale den gleichen privaten Schlüssel an. Weitere Informationen zur Auswahl des privaten Schlüssels für den lokalen MQTT-Server finden Sie unter [Performance](hardware-security.md#hsm-performance). Weitere Informationen über den Manager lokaler Secrets finden Sie unter [Setzen Sie Geheimnisse bis ins AWS IoT Greengrass Mark ein](secrets.md).
## Testen der Konfiguration
+ Halten Sie den Greengrass-Daemon an.
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
Wenn der Daemon erfolgreich startet, dann ist Ihr Core korrekt konfiguriert.
Sie sind nun bereit, die PKCS\$111-Spezifikation kennenzulernen und erste Tests mit der PKCS\$111-API durchzuführen, die von der SoftHSM-Implementierung bereitgestellt wird.
**Wichtig**
Auch hier ist es äußerst wichtig zu wissen, dass dieses Modul nur zum Lernen und Testen gedacht ist. Es erhöht nicht wirklich den Sicherheitsstatus Ihrer Greengrass-Umgebung.
Stattdessen soll das Modul Ihnen ermöglichen, mit dem Lernen und Testen zu beginnen, um sich auf den Einsatz eines echten hardwarebasierten HSM in der Zukunft vorzubereiten. Zu diesem Zeitpunkt müssen Sie Ihre Software vor jeder Produktionsnutzung separat und vollständig mit dem hardwarebasierten HSM testen, da es Unterschiede zwischen der in SoftHSM bereitgestellten PKCS\$111-Implementierung und einer hardwarebasierten Implementierung geben kann.
## Weitere Informationen finden Sie auch unter
+ *PKCS \$111 Kryptographische Token-Schnittstelle, Bedienungsanleitung Version 2.40*. Herausgegeben von John Leiseboer und Robert Griffin. 16. November 2014. Anmerkung 02 des OASIS-Ausschusses. [http://docs.oasis-open. org/pkcs11/pkcs11-ug/v2.40/cn02/pkcs11-ug-v2.40-cn02.html](http://docs.oasis-open.org/pkcs11/pkcs11-ug/v2.40/cn02/pkcs11-ug-v2.40-cn02.html). [Letzte Version: http://docs.oasis-open. org/pkcs11/pkcs11-ug/v2.40/pkcs11-ug-v2.40.html](http://docs.oasis-open.org/pkcs11/pkcs11-ug/v2.40/pkcs11-ug-v2.40.html).
+ [RFC 7512](https://tools.ietf.org/html/rfc7512)