Avis de fin de support : le 7 octobre 2026, AWS le support de. AWS IoT Greengrass Version 1 Après le 7 octobre 2026, vous ne pourrez plus accéder aux AWS IoT Greengrass V1 ressources. Pour plus d'informations, rendez-vous sur [Migrer depuis AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Module 7 : Simulation de l'intégration de la sécurité matérielle
Cette fonctionnalité est disponible pour AWS IoT Greengrass Core v1.7 et versions ultérieures.
Ce module avancé montre comment configurer un module de sécurité matérielle (HSM) simulé à utiliser avec un noyau Greengrass. La configuration utilise SoftHSM, qui est une implémentation logicielle pure utilisant l'API [PKCS\$111](#console-mod7-see-also). L'objectif de ce module est de vous permettre de configurer un environnement où vous pouvez apprendre et effectuer des tests initiaux sur une implémentation uniquement logicielle de l'API PKCS\$111. Il est fourni uniquement à des fins d'apprentissage et de tests initiaux, et non à des fins de production de quelque nature que ce soit.
Vous pouvez utiliser cette configuration pour tester l'utilisation d'un service compatible avec PKCS \$1 11 pour stocker vos clés privées. Pour plus d'informations sur l'implémentation uniquement logicielle, consultez [SoftHSM](https://www.opendnssec.org/softhsm/). Pour plus d'informations sur l'intégration de la sécurité matérielle sur un AWS IoT Greengrass cœur, y compris les exigences générales, consultez[Intégration de sécurité matérielle](hardware-security.md).
**Important**
Ce module est destiné à des fins de test uniquement. Nous déconseillons vivement l'utilisation de SoftHSM dans un environnement de production, car elle peut donner un faux sentiment de sécurité supplémentaire. La configuration résultante ne fournit pas tous les avantages de sécurité réels. Les clés stockées dans SoftHSM ne sont pas stockées de façon plus sécurisée que dans n'importe quel autre moyen de stockage de secrets dans l'environnement Greengrass.
L'objectif de ce module est de vous permettre de découvrir la spécification PKCS\$111 et d'effectuer des tests initiaux sur votre logiciel si vous prévoyez d'utiliser un HSM matériel à l'avenir.
Vous devez tester séparément et complètement votre implémentation matérielle future avant toute utilisation en production, car il peut y avoir des différences entre l'implémentation PKCS\$111 fournie dans SoftHSM par rapport à une implémentation basée sur le matériel.
Si vous avez besoin d'aide pour l'intégration d'un [module de sécurité matériel pris en charge](hardware-security.md#hardware-security-reqs), contactez votre représentant du support aux AWS entreprises.
Avant de commencer, exécutez le script de [configuration de périphérique Greengrass](quick-start.md) ou assurez-vous d'avoir effectué le [module 1](module1.md) et le [module 2](module2.md) du didacticiel de mise en route. Dans ce module, nous partons du principe que votre cœur est déjà approvisionné et qu'il communique avec AWS lui. Ce module dure environ 30 minutes.
## Installer le logiciel SoftHSM
Dans cette étape, vous installez SoftHSM et les outils pkcs11, qui sont utilisés pour gérer votre instance SoftHSM.
+ Dans un terminal de votre appareil AWS IoT Greengrass principal, exécutez la commande suivante :
```
sudo apt-get install softhsm2 libsofthsm2-dev pkcs11-dump
```
Pour plus d'informations sur ces packages, consultez [Install softhsm2](https://www.howtoinstall.co/en/ubuntu/xenial/softhsm2), [Install libsofthsm2-dev](https://www.howtoinstall.co/en/ubuntu/xenial/libsofthsm2-dev) et [Install pkcs11-dump](https://www.howtoinstall.co/en/ubuntu/xenial/pkcs11-dump).
**Note**
Si vous rencontrez des problèmes lors de l'utilisation de cette commande sur votre système, consultez [SofthSM version 2 activé](https://github.com/opendnssec/SoftHSMv2). GitHub Ce site fournit plus d'informations d'installation, notamment sur la façon de générer depuis la source.
## Configurer SoftHSM
Au cours de cette étape, vous [configurez SoftHSM](https://github.com/opendnssec/SoftHSMv2#configure-1).
1. Basculez vers l'utilisateur racine.
```
sudo su
```
1. Utilisez la page du manuel pour trouver l'emplacement `softhsm2.conf` dans le système. `/etc/softhsm/softhsm2.conf` est un emplacement courant. Mais l'emplacement peut être différent sur certains systèmes.
```
man softhsm2.conf
```
1. Créez le répertoire pour le fichier de configuration softhsm2 dans l'emplacement sur le système. Dans cet exemple, nous supposons que l'emplacement est `/etc/softhsm/softhsm2.conf`.
```
mkdir -p /etc/softhsm
```
1. Créez le répertoire du jeton dans le répertoire `/greengrass`.
**Note**
Si vous ignorez cette étape, softhsm2-util indique `ERROR: Could not initialize the library`.
```
mkdir -p /greengrass/softhsm2/tokens
```
1. Configurez le répertoire du jeton.
```
echo "directories.tokendir = /greengrass/softhsm2/tokens" > /etc/softhsm/softhsm2.conf
```
1. Configurez un backend basé sur des fichiers.
```
echo "objectstore.backend = file" >> /etc/softhsm/softhsm2.conf
```
**Note**
Ces paramètres de configuration sont proposés à des fins d'expérimentation uniquement. Pour connaître toutes les options de configuration, consultez la page de manuel du fichier de configuration.
```
man softhsm2.conf
```
## Importer la clé privée dans SoftHSM
Au cours de cette étape, vous allez initialiser le jeton SoftHSM, convertir le format de clé privée, puis importer la clé privée.
1. Initialiser le jeton SoftHSM.
```
softhsm2-util --init-token --slot 0 --label greengrass --so-pin 12345 --pin 1234
```
**Note**
Si vous y êtes invité, saisissez le PIN superviseur `12345` et le PIN utilisateur `1234`. AWS IoT Greengrass n'utilise pas le PIN superviseur. Vous pouvez donc utiliser n'importe quelle valeur.
Si vous recevez l'erreur `CKR_SLOT_ID_INVALID: Slot 0 does not exist`, essayez plutôt la commande suivante :
```
softhsm2-util --init-token --free --label greengrass --so-pin 12345 --pin 1234
```
1. Convertir la clé privée dans un format qui peut être utilisé par l'outil d'importation SoftHSM. Dans le cadre de ce didacticiel, vous devez convertir la clé privée que vous avez obtenue à partir de l'option **Création de groupes par défaut** dans le [Module 2](module2.md) du didacticiel Démarrez.
```
openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in hash.private.key -out hash.private.pem
```
1. Importer la clé privée dans SoftHSM. Parmi les commandes suivantes, exécutez celle qui correspond à votre version de softhsm2-util.
Syntaxe **Raspbian softhsm2-util v2.2.0**
```
softhsm2-util --import hash.private.pem --token greengrass --label iotkey --id 0000 --pin 12340
```
Syntaxe **Ubuntu softhsm2-util v2.0.0**
```
softhsm2-util --import hash.private.pem --slot 0 --label iotkey --id 0000 --pin 1234
```
Cette commande identifie l'emplacement comme `0` et définit l'étiquette de clé comme `iotkey`. Vous utiliserez ces valeurs dans la section suivante.
Une fois la clé privée importée, vous pouvez la supprimer (optionnel) du répertoire `/greengrass/certs`. Assurez-vous de conserver la CA racine et les certificats de l'appareil dans le répertoire.
## Configurer le noyau Greengrass pour utiliser SoftHSM
Au cours de cette étape, vous allez modifier le fichier de configuration du noyau Greengrass pour utiliser SoftHSM.
1. Trouvez le chemin d'accès à la bibliothèque du fournisseur SoftHSM (`libsofthsm2.so`) sur votre système :
1. Obtenez la liste des packages installés de la bibliothèque.
```
sudo dpkg -L libsofthsm2
```
Le fichier `libsofthsm2.so` est situé dans le répertoire `softhsm`.
1. Copiez le chemin complet dans le fichier, par exemple, `/usr/lib/x86_64-linux-gnu/softhsm/libsofthsm2.so`. Vous utiliserez cette valeur plus tard.
1. Arrêtez le démon Greengrass.
```
cd /greengrass/ggc/core/
sudo ./greengrassd stop
```
1. Ouvrez le fichier de configuration Greengrass. Il s'agit du fichier [`config.json`](gg-core.md#config-json) dans le répertoire `/greengrass/config`.
**Note**
Les exemples de cette procédure sont rédigées en supposant que le fichier `config.json` utilise le format qui est généré à partir de l'option **Création de groupes par défaut** dans le [Module 2](module2.md) du didacticiel Démarrez.
1. Dans l'objet `crypto.principals`, insérez l'objet de certificat de serveur MQTT suivant. Ajoutez une virgule si nécessaire pour créer un fichier JSON.
```
"MQTTServerCertificate": {
"privateKeyPath": "path-to-private-key"
}
```
1. Dans l'objet `crypto`, insérez l'objet `PKCS11` suivant. Ajoutez une virgule si nécessaire pour créer un fichier JSON.
```
"PKCS11": {
"P11Provider": "/path-to-pkcs11-provider-so",
"slotLabel": "crypto-token-name",
"slotUserPin": "crypto-token-user-pin"
}
```
Votre fichier doit se présenter comme suit :
```
{
"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"
}
}
```
**Note**
Pour utiliser les mises à jour over-the-air (OTA) avec une sécurité matérielle, l'`PKCS11`objet doit également contenir la `OpenSSLEngine` propriété. Pour de plus amples informations, veuillez consulter [Configurer le support pour les over-the-air mises à jour](hardware-security.md#hardware-security-ota-updates).
1. Modifiez l'objet `crypto` :
1. Configurez l'objet `PKCS11`.
+ Pour `P11Provider`, entrez le chemin d'accès complet à `libsofthsm2.so`.
+ Pour `slotLabel`, saisissez `greengrass`.
+ Pour `slotUserPin`, saisissez `1234`.
1. Configurez les chemins de la clé privée dans l'objet `principals`. Ne modifiez pas la propriété `certificatePath`.
+ Pour les propriétés `privateKeyPath`, saisissez le chemin RFC 7512 PKCS \$1 11 suivant (qui spécifie l'étiquette de clé). Faites de même pour le `IoTCertificate`, le `SecretsManager` et les mandataires `MQTTServerCertificate`.
```
pkcs11:object=iotkey;type=private
```
1. Vérifiez l'objet `crypto`. Il doit ressembler à l’exemple ci-dessous.
```
"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. Supprimez les valeurs `caPath`, `certPath` et `keyPath` de l'objet `coreThing`. Il doit ressembler à l’exemple ci-dessous.
```
"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
}
```
**Note**
Dans le cadre de ce didacticiel, vous spécifiez la même clé privée pour tous les mandataires. Pour plus d'informations sur le choix de la clé privée du serveur MQTT local, consultez [Performance](hardware-security.md#hsm-performance). Pour plus d'informations sur le secrets manager local, consultez [Déployez les secrets jusqu'au AWS IoT Greengrass cœur](secrets.md).
## Tester la configuration
+ Démarrez le démon Greengrass.
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
Si le démon démarre correctement, cela indique que votre noyau est configuré correctement.
Vous êtes maintenant prêt à en savoir plus sur la spécification PKCS\$111 et à effectuer les tests initiaux avec l'API PKCS\$111 qui est fournie par l'implémentation SoftHSM.
**Important**
Là encore, il est extrêmement important d'avoir conscience que ce module est conçu pour l'apprentissage et le test uniquement. Il ne renforce pas réellement le niveau de sécurité de votre environnement Greengrass.
Au lieu de cela, le module a pour objectif de vous permettre de commencer à apprendre et à tester en vue d'une utilisation future d'un véritable HSM basé sur le matériel. À ce moment-là, vous devrez tester séparément et complètement votre logiciel sur le module HSM basé sur le matériel avant toute utilisation en production, car il peut y avoir des différences entre l'implémentation PKCS \$1 11 fournie dans SoftHSM et une implémentation basée sur le matériel.
## Consultez aussi
+ *PKCS \$111 Cryptographic Token Interface Usage Guide Version 2.40*. Révisé par John Leiseboer et Robert Griffin. 16 novembre 2014. Note 02 du comité OASIS. [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). Dernière 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)