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.
# Gestion des utilisateurs HSM avec la CLI CloudHSM
[Pour gérer les utilisateurs du module de sécurité matérielle (HSM) AWS CloudHSM, vous devez vous connecter au HSM avec le nom d'utilisateur et le mot de passe d'un administrateur.](understanding-users.md#admin) Seuls les administrateurs peuvent gérer les utilisateurs. Le HSM contient un administrateur par défaut appelé admin. Vous définissez le mot de passe pour admin lorsque vous avez [activé le cluster](activate-cluster.md).
Cette rubrique fournit des step-by-step instructions et des détails sur la gestion des utilisateurs HSM à l'aide de la CLI CloudHSM.
**Topics**
+ [Conditions préalables](manage-hsm-users-chsm-cli-prereq.md)
+ [Types d’utilisateur](understanding-users.md)
+ [Tableau des autorisations](user-permissions-table-chsm-cli.md)
+ [Créer un administrateur](create-admin-cloudhsm-cli.md)
+ [Créez CUs](create-user-cloudhsm-cli.md)
+ [Répertorier tous les utilisateurs](list-users-cloudhsm-cli.md)
+ [Modifier les mots de passe](change-user-password-cloudhsm-cli.md)
+ [Suppression d'utilisateurs](delete-user-cloudhsm-cli.md)
+ [Gérer le MFA des utilisateurs](login-mfa-token-sign.md)
+ [Gérer l'authentification par quorum (M of N)](quorum-auth-chsm-cli.md)
# Conditions préalables à la gestion des utilisateurs dans la CLI CloudHSM
Avant d'utiliser la CLI CloudHSM pour gérer les AWS CloudHSM utilisateurs des modules de sécurité matériels (HSM), vous devez remplir ces conditions préalables. Les rubriques suivantes décrivent la prise en main de la CLI CloudHSM.
**Topics**
+ [Obtenez l'adresse IP du HSM](#manage-chsm-cli-users-ip)
+ [Télécharger la CLI CloudHSM](#get-cli-users-cloudhsm-cli)
## Obtenez l'adresse IP d'un HSM dans AWS CloudHSM
Pour utiliser la CLI CloudHSM, vous devez utiliser l'outil de configuration pour mettre à jour la configuration locale. Pour obtenir des instructions sur l'exécution de l'outil de configuration avec la CLI CloudHSM, consultez [Commencer à utiliser l'interface de ligne de AWS CloudHSM commande (CLI)](cloudhsm_cli-getting-started.md). Le paramètre `-a` vous oblige à ajouter l'adresse IP d'un HSM dans votre cluster. Si vous en avez plusieurs HSMs, vous pouvez utiliser n'importe quelle adresse IP. Cela garantit que la CLI CloudHSM peut propager toutes les modifications que vous apportez sur l'ensemble du cluster. N'oubliez pas que la CLI CloudHSM utilise son fichier local pour suivre les informations du cluster. Si le cluster a changé depuis la dernière fois que vous avez utilisé la CLI CloudHSM depuis un hôte particulier, vous devez ajouter ces modifications au fichier de configuration local stocké sur cet hôte. Ne supprimez jamais un HSM lorsque vous utilisez la CLI CloudHSM.
**Pour obtenir une adresse IP pour un HSM (console)**
1. Ouvrez la AWS CloudHSM console à la [https://console.aws.amazon.com/cloudhsm/maison](https://console.aws.amazon.com/cloudhsm/home).
1. Pour changer de région AWS, utilisez le Sélecteur de région dans l’angle supérieur droit de la page.
1. Pour ouvrir la page détaillée du cluster, choisissez l'ID du cluster dans le tableau des clusters.
1. Pour obtenir l'adresse IP, allez dans l' HSMs onglet. Pour les IPv4 clusters, choisissez une adresse répertoriée sous ** IPv4 adresse ENI**. Pour les clusters à double pile, utilisez l'adresse ENI IPv4 ou l'** IPv6 adresse ENI**.
**Pour obtenir une adresse IP pour un HSM ()AWS CLI**
+ Obtenez l'adresse IP d'un HSM à l'aide de la commande **[describe-clusters](https://docs.aws.amazon.com/cli/latest/reference/cloudhsmv2/describe-clusters.html)** d’ AWS CLI. Dans le résultat de la commande, l'adresse IP de HSMs sont les valeurs de `EniIp` et `EniIpV6` (s'il s'agit d'un cluster à double pile).
```
$ aws cloudhsmv2 describe-clusters
{
"Clusters": [
{ ... }
"Hsms": [
{
...
"EniIp": "10.0.0.9",
...
},
{
...
"EniIp": "10.0.1.6",
"EniIpV6": "2600:113f:404:be09:310e:ed34:3412:f733",
...
```
## Télécharger la CLI CloudHSM
La dernière version de la CLI CloudHSM est disponible pour les tâches de gestion des utilisateurs HSM pour le SDK client 5. Pour télécharger et installer la CLI CloudHSM, suivez les instructions de la section [Installation et configuration de la CLI CloudHSM](gs_cloudhsm_cli-install.md).
# Types d'utilisateurs HSM pour la CLI CloudHSM
La plupart des opérations que vous effectuez sur le module de sécurité matériel (HSM) nécessitent les informations d'identification d'un utilisateur AWS CloudHSM *HSM*. Le HSM authentifie chaque utilisateur HSM et chaque utilisateur HSM possède un *type* qui détermine les opérations que vous pouvez effectuer sur le HSM en tant qu'utilisateur.
**Note**
Les utilisateurs HSM sont distincts des utilisateurs IAM. Les utilisateurs IAM qui disposent des informations d'identification correctes peuvent créer HSMs en interagissant avec les ressources via l'API AWS. Une fois le HSM créé, vous devez utiliser les informations d'identification de l'utilisateur HSM pour authentifier les opérations sur le HSM.
**Topics**
+ [Administrateur non activé](#unactivated-admin)
+ [Admin](#admin)
+ [Utilisateur de chiffrement (CU)](#crypto-user-chsm-cli)
+ [utilisateur de l'appareil (AU)](#appliance-user-chsm-cli)
## Administrateur non activé
Dans la CLI CloudHSM, l'administrateur non activé est un utilisateur temporaire qui n'existe que sur le premier HSM d'un cluster AWS CloudHSM qui n’a jamais été activé. Pour [activer un cluster](activate-cluster.md), exécutez la commande **cluster activate** dans la CLI CloudHSM. Après avoir exécuté cette commande, les administrateurs non activés sont invités à modifier le mot de passe. Après avoir modifié le mot de passe, l'administrateur non activé devient administrateur.
## Admin
Dans la CLI CloudHSM, l'administrateur peut effectuer des opérations de gestion des utilisateurs. Par exemple, il peut créer et supprimer des utilisateurs, et modifier les mots de passe des utilisateurs. Pour plus d'informations sur les administrateurs, veuillez consulter le [Tableau des autorisations utilisateur HSM pour la CLI CloudHSM](user-permissions-table-chsm-cli.md).
## Utilisateur de chiffrement (CU)
Un utilisateur de chiffrement (CU) peut effectuer les opérations de chiffrement et de gestion des clés suivantes.
+ **Gestion des clés** - Créer, supprimer, partager, importer et exporter des clés de chiffrement.
+ **Opérations de chiffrement** - Utiliser les clés de chiffrement pour le chiffrement, le déchiffrement, la signature, la vérification, et plus encore.
Pour de plus amples informations, veuillez consulter [Tableau des autorisations utilisateur HSM pour la CLI CloudHSM](user-permissions-table-chsm-cli.md).
## utilisateur de l'appareil (AU)
L'utilisateur de l'appliance (AU) peut effectuer des opérations de clonage et de synchronisation sur le cluster. HSMs AWS CloudHSM utilise l'AU pour synchroniser le HSMs dans un AWS CloudHSM cluster. L'UA existe sur tous les HSMs sites fournis par AWS CloudHSM et dispose d'autorisations limitées. Pour de plus amples informations, veuillez consulter [Tableau des autorisations utilisateur HSM pour la CLI CloudHSM](user-permissions-table-chsm-cli.md).
AWS ne peut effectuer aucune opération sur votre HSMs . AWS ne peut pas afficher ou modifier vos utilisateurs ou vos clés et ne peut effectuer aucune opération cryptographique à l'aide de ces clés.
# Tableau des autorisations utilisateur HSM pour la CLI CloudHSM
Le tableau suivant répertorie les opérations du module de sécurité matérielle (HSM) triées par type d'utilisateur ou de session HSM dans lequel elles peuvent être effectuées. AWS CloudHSM
| | Admin | Utilisateur de chiffrement (CU) | utilisateur de l'appareil (AU) | Session non authentifiée |
| --- | --- | --- | --- | --- |
| Obtention d'informations de base sur le cluster¹ | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui |
| Changement de son mot de passe | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | Non applicable |
| Changement du mot de passe d'un utilisateur | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non |
| Ajout et suppression d'utilisateurs | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non |
| Obtention du statut de la synchronisation² | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non |
| Extraction et insertion d'objets masqués³ | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non |
| Fonctions de gestion des clés⁴ | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non |
| Chiffrement et déchiffrement | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non |
| Connexion et vérification | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non |
| Générez des résumés et HMACs | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non | ![\[Yes\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-yes.png) Oui | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non | ![\[No\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/images/icon-no.png) Non |
+ [1] Les informations de base du cluster incluent le nombre de membres du HSMs cluster et l'adresse IP, le modèle, le numéro de série, l'identifiant de l'appareil, l'identifiant du microprogramme, etc. de chaque HSM.
+ [2] L'utilisateur peut obtenir un ensemble de résumés (hachages) qui correspondent aux clés du HSM. Une application peut comparer ces ensembles de résumés pour comprendre l'état de synchronisation HSMs d'un cluster.
+ [3] Les objets masqués sont des clés qui sont chiffrées avant de quitter le HSM. Elles ne peuvent pas être déchiffrées en dehors du HSM. Elles ne sont déchiffrées que lorsqu'elles sont insérées dans un HSM qui se trouve dans le même cluster que le HSM duquel elles ont été extraites. Une application peut extraire et insérer des objets masqués pour les synchroniser HSMs dans un cluster.
+ [4] Les fonctions de gestion des clés incluent la création, la suppression, l'encapsulage, le désencapsulage et la modification des attributs de clés.
# Création d'un administrateur utilisateur HSM à l'aide de la CLI CloudHSM
Suivez ces étapes pour créer un utilisateur administrateur du module de sécurité matérielle (HSM) à l'aide de la CLI CloudHSM.
1. Utilisez la commande suivante pour démarrer le mode interactif de la CLI CloudHSM.
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
```
------
1. Utilisez la commande **login** et connectez-vous au cluster en tant qu'administrateur.
```
aws-cloudhsm > login --username --role admin
```
1. Le système vous invite à saisir votre mot de passe. Entrez le mot de passe, et le résultat indique que la commande a été exécutée avec succès.
```
Enter password:
{
"error_code": 0,
"data": {
"username": "",
"role": "admin"
}
}
```
1. Entrez la commande suivante pour créer un administrateur.
```
aws-cloudhsm > user create --username --role admin
```
1. Saisissez le mot de passe du nouvel utilisateur.
1. Entrez à nouveau le mot de passe pour confirmer que le mot de passe que vous avez saisi est correct.
# Création d'un utilisateur de chiffrement HSM à l'aide de la CLI CloudHSM
Procédez comme suit pour créer un utilisateur cryptographique (CU) du module de sécurité matériel (HSM) à l'aide de la CLI CloudHSM.
1. Utilisez la commande suivante pour démarrer le mode interactif de la CLI CloudHSM.
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
```
------
1. Utilisez la commande **login** et connectez-vous au cluster en tant qu'administrateur.
```
aws-cloudhsm > login --username --role admin
```
1. Le système vous invite à saisir votre mot de passe. Entrez le mot de passe, et le résultat indique que la commande a été exécutée avec succès.
```
Enter password:
{
"error_code": 0,
"data": {
"username": "",
"role": "admin"
}
}
```
1. Saisissez la commande suivante pour créer un utilisateur de chiffrement :
```
aws-cloudhsm > user create --username --role crypto-user
```
1. Saisissez le mot de passe du nouvel utilisateur de chiffrement.
1. Entrez à nouveau le mot de passe pour confirmer que le mot de passe que vous avez saisi est correct.
# Répertorier tous les utilisateurs HSM du cluster à l'aide de la CLI CloudHSM
Utilisez la **user list** commande dans la CLI CloudHSM pour répertorier tous les utilisateurs AWS CloudHSM du cluster. Vous n'avez pas besoin de vous connecter pour exécuter **user list**. Tous les types d'utilisateurs peuvent répertorier des utilisateurs.
**Procédez comme suit pour répertorier tous les utilisateurs du cluster**
1. Utilisez la commande suivante pour démarrer le mode interactif de la CLI CloudHSM.
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
```
------
1. Saisissez la commande suivante pour répertorier tous les utilisateurs du cluster :
```
aws-cloudhsm > user list
```
Pour plus d'informations sur **user list**, veuillez consulter la rubrique [Répertorier les utilisateurs](cloudhsm_cli-user-list.md).
# Modifier les mots de passe des utilisateurs HSM à l'aide de la CLI CloudHSM
Utilisez la **user change-password** commande de la CLI CloudHSM pour modifier le mot de passe d'un utilisateur du module de sécurité matérielle (HSM).
Les types d'utilisateurs et les mots de passe sont sensibles à la casse, les noms d'utilisateurs, non.
Les utilisateurs de chiffrement (CU) et les utilisateurs d'appliance (AU) peuvent modifier uniquement leur propre mot de passe. Pour modifier le mot de passe d'un autre utilisateur, vous devez vous connecter en tant qu'administrateur. Vous ne pouvez pas modifier le mot de passe d'un utilisateur qui est actuellement connecté..
**Pour modifier votre propre mot de passe**
1. Utilisez la commande suivante pour démarrer le mode interactif de la CLI CloudHSM.
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
```
------
1. Utilisez la commande **login** et connectez-vous en tant qu'utilisateur avec le mot de passe que vous souhaitez modifier.
```
aws-cloudhsm > login --username --role
```
1. Entrer le mot de passe de l'utilisateur.
```
Enter password:
{
"error_code": 0,
"data": {
"username": "",
"role": ""
}
}
```
1. Entrez la commande **user change-password**.
```
aws-cloudhsm > user change-password --username --role
```
1. Saisissez le nouveau mot de passe.
1. Saisissez à nouveau le nouveau mot de passe.
**Pour modifier le mot de passe d'un autre utilisateur**
1. Utilisez la commande suivante pour démarrer le mode interactif de la CLI CloudHSM.
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
```
------
1. À l'aide de la CLI CloudHSM, connectez-vous en tant qu'administrateur.
```
aws-cloudhsm > login --username --role admin
Enter password:
{
"error_code": 0,
"data": {
"username": "",
"role": "admin"
}
}
```
1. Saisissez la commande **user change-password** ainsi que le nom d'utilisateur de l'utilisateur dont vous souhaitez changer le mot de passe.
```
aws-cloudhsm > user change-password --username --role
```
1. Saisissez le nouveau mot de passe.
1. Saisissez à nouveau le nouveau mot de passe.
Pour plus d'informations sur **user change-password**, veuillez consulter [changer le mot de passe d’un utilisateur](cloudhsm_cli-user-change-password.md).
# Supprimer des utilisateurs HSM à l'aide de la CLI CloudHSM
Utilisez-le **user delete** dans la CLI CloudHSM pour supprimer un utilisateur du module de sécurité matériel (HSM). Vous devez vous connecter en tant qu'administrateur pour supprimer un autre utilisateur.
**Astuce**
Vous ne pouvez pas supprimer les utilisateurs de chiffrement (CU) qui possèdent des clés.
**Pour supprimer un utilisateur**
1. Utilisez la commande suivante pour démarrer le mode interactif de la CLI CloudHSM.
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
```
------
1. Utilisez la commande **login** et connectez-vous au cluster en tant qu'administrateur.
```
aws-cloudhsm > login --username --role admin
```
1. Le système vous invite à saisir votre mot de passe. Entrez le mot de passe, et le résultat indique que la commande a été exécutée avec succès.
```
Enter password:
{
"error_code": 0,
"data": {
"username": "",
"role": "admin"
}
}
```
1. Utilisez la commande **user delete** pour supprimer l’utilisateur.
```
aws-cloudhsm > user delete --username --role
```
Pour plus d'informations sur **user delete**, veuillez consulter [Supprimer un utilisateur](cloudhsm_cli-user-delete.md).
# Gérez le MFA pour les utilisateurs HSM à l'aide de la CLI CloudHSM
Pour renforcer la sécurité, vous pouvez configurer l'authentification multifactorielle (MFA) pour les utilisateurs afin de protéger AWS CloudHSM le cluster.
Lorsque vous vous connectez à un cluster avec un compte utilisateur du module de sécurité matérielle (HSM) compatible MFA, vous fournissez votre mot de passe à la CLI CloudHSM (premier facteur, ce que vous savez) et la CLI CloudHSM vous fournit un jeton et vous invite à le faire signer.
Pour fournir le deuxième facteur, c'est-à-dire ce que vous avez, vous signez le jeton avec une clé privée provenant d'une paire de clés que vous avez déjà créée et associée à l'utilisateur HSM. Pour accéder au cluster, vous devez fournir le jeton signé à la CLI CloudHSM.
Pour plus d'informations sur la configuration de la MFA pour un utilisateur, voir [Configuration de la MFA pour la CLI CloudHSM](set-up-mfa-for-cloudhsm-cli.md)
Les rubriques suivantes fournissent des informations supplémentaires sur l'utilisation de l'authentification par quorum dans AWS CloudHSM.
**Topics**
+ [Authentification par quorum](quorum-mfa-cloudhsm-cli.md)
+ [Exigences relatives aux paires de clés](mfa-key-pair-cloudhsm-cli.md)
+ [Configuration de l'authentification MFA](set-up-mfa-for-cloudhsm-cli.md)
+ [Créer des utilisateurs](create-mfa-users-cloudhsm-cli.md)
+ [Connectez-vous aux utilisateurs](login-mfa-cloudhsm-cli.md)
+ [Rotation des clés](rotate-mfa-cloudhsm-cli.md)
+ [Désenregistrer une clé publique MFA](deregister-mfa-cloudhsm-cli.md)
+ [Référence du fichier de jetons](reference-mfa-cloudhsm-cli.md)
# Authentification par quorum et MFA dans les AWS CloudHSM clusters à l'aide de la CLI CloudHSM
Le AWS CloudHSM cluster utilise la même clé pour l'authentification par quorum et pour l'authentification multifactorielle (MFA). Cela signifie qu'un utilisateur dont le MFA est activé est effectivement enregistré pour le contrôle d'accès au MoFN ou au quorum. Pour utiliser correctement l'authentification MFA et le quorum pour le même utilisateur HSM, tenez compte des points suivants :
+ Si vous utilisez l'authentification par quorum pour un utilisateur aujourd'hui, vous devez utiliser la même paire de clés que celle que vous avez créée pour l'utilisateur du quorum afin d'activer le MFA pour cet utilisateur.
+ Si vous ajoutez l'exigence MFA pour un utilisateur non MFA qui n'est pas un utilisateur d'authentification par quorum, vous enregistrez cet utilisateur en tant qu'utilisateur enregistré par quorum (MoFN) avec authentification MFA.
+ Si vous supprimez l'exigence MFA ou modifiez le mot de passe d'un utilisateur MFA qui est également un utilisateur enregistré avec authentification par quorum, vous supprimerez également l'enregistrement de l'utilisateur en tant qu'utilisateur du quorum (MofN).
+ Si vous supprimez l'exigence MFA ou modifiez le mot de passe d'un utilisateur MFA qui est également un utilisateur utilisant l'authentification par quorum, *mais que vous souhaitez toujours que cet utilisateur participe à l'authentification par quorum*, vous devez l'enregistrer à nouveau en tant qu'utilisateur du quorum (MofN).
Pour de plus amples informations sur l'authentification par quorum, veuillez consulter [Gérer l'authentification par quorum (M of N)](quorum-auth-chsm-cli.md).
# Exigences relatives aux paires de clés MFA pour l'utilisation de la AWS CloudHSM CLI CloudHSM
Pour activer l'authentification multifactorielle (MFA) pour un utilisateur du module de sécurité matériel (HSM) AWS CloudHSM dans, vous pouvez créer une nouvelle paire de clés ou utiliser une clé existante répondant aux exigences suivantes :
+ **Type de clé :** asymétrique
+ **Utilisation de clé :** signature et vérification
+ **Spécification de clé : RSA\$12048**
+ **L'algorithme de signature inclut : SHA256with** RSAEncryption
**Note**
Si vous utilisez l'authentification par quorum ou si vous envisagez d'utiliser l'authentification par quorum, veuillez consulter [Authentification par quorum et MFA dans les AWS CloudHSM clusters à l'aide de la CLI CloudHSM](quorum-mfa-cloudhsm-cli.md)
Vous pouvez utiliser la CLI CloudHSM et la paire de clés pour créer un nouvel utilisateur administrateur avec la MFA activée.
# Configuration de la MFA pour la CLI CloudHSM
Suivez ces étapes pour configurer l'authentification multifactorielle (MFA) pour la CLI CloudHSM.
1. Pour configurer la MFA à l'aide de la stratégie de signature de jeton, vous devez d'abord générer une clé privée RSA de 2 048 bits et la clé publique associée.
```
$ openssl genrsa -out officer1.key 2048
Generating RSA private key, 2048 bit long modulus (2 primes)
...........................................................+++++
....................................................................+++++
e is 65537 (0x010001)
$ openssl rsa -in officer1.key -outform PEM -pubout -out officer1.pub
writing RSA key
```
1. Entrez la commande suivante pour démarrer la CLI en mode interactif.
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
```
------
1. À l'aide de la CLI CloudHSM, connectez-vous à votre compte utilisateur.
```
aws-cloudhsm > login --username --role --cluster-id
Enter password:
{
"error_code": 0,
"data": {
"username": "",
"role": ""
}
}
```
1. Ensuite, exécutez la commande pour modifier votre stratégie MFA. Vous devez fournir le paramètre `--token`. Ce paramètre indique un fichier dans lequel seront écrits des jetons non signés.
```
aws-cloudhsm > user change-mfa token-sign --token unsigned-tokens.json --username --role crypto-user --change-quorum
Enter password:
Confirm password:
```
1. Vous avez maintenant un fichier contenant des jetons non signés qui doivent être signés : `unsigned-tokens.json`. Le nombre de jetons dans ce fichier dépend du nombre de jetons HSMs dans votre cluster. Chaque jeton représente un HSM. Ce fichier est au format JSON et contient des jetons qui doivent être signés pour prouver que vous disposez d'une clé privée.
```
$ cat unsigned-tokens.json
{
"version": "2.0",
"tokens": [
{
{
"unsigned": "Vtf/9QOFY45v/E1osvpEMr59JsnP/hLDm4ItOO2vqL8=",
"signed": ""
},
{
"unsigned": "wVbC0/5IKwjyZK2NBpdFLyI7BiayZ24YcdUdlcxLwZ4=",
"signed": ""
},
{
"unsigned": "z6aW9RzErJBL5KqFG5h8lhTVt9oLbxppjod0Ebysydw=",
"signed": ""
}
]
}
```
1. L'étape suivante consiste à signer ces jetons avec la clé privée créée à l'étape 1. Replacez les signatures dans le fichier. Tout d'abord, vous devez extraire et décoder les jetons codés en base64.
```
$ echo "Vtf/9QOFY45v/E1osvpEMr59JsnP/hLDm4ItOO2vqL8=" > token1.b64
$ echo "wVbC0/5IKwjyZK2NBpdFLyI7BiayZ24YcdUdlcxLwZ4=" > token2.b64
$ echo "z6aW9RzErJBL5KqFG5h8lhTVt9oLbxppjod0Ebysydw=" > token3.b64
$ base64 -d token1.b64 > token1.bin
$ base64 -d token2.b64 > token2.bin
$ base64 -d token3.b64 > token3.bin
```
1. Vous disposez désormais de jetons binaires que vous pouvez signer à l'aide de la clé privée RSA créée à l'étape 1.
```
$ openssl pkeyutl -sign \
-inkey officer1.key \
-pkeyopt digest:sha256 \
-keyform PEM \
-in token1.bin \
-out token1.sig.bin
$ openssl pkeyutl -sign \
-inkey officer1.key \
-pkeyopt digest:sha256 \
-keyform PEM \
-in token2.bin \
-out token2.sig.bin
$ openssl pkeyutl -sign \
-inkey officer1.key \
-pkeyopt digest:sha256 \
-keyform PEM \
-in token3.bin \
-out token3.sig.bin
```
1. Vous avez maintenant les signatures binaires des jetons. Vous devez les encoder en base64, puis les replacer dans votre fichier de jetons.
```
$ base64 -w0 token1.sig.bin > token1.sig.b64
$ base64 -w0 token2.sig.bin > token2.sig.b64
$ base64 -w0 token3.sig.bin > token3.sig.b64
```
1. Enfin, vous pouvez copier-coller les valeurs base64 dans votre fichier de jetons :
```
{
"version": "2.0",
"tokens": [
{
"unsigned": "1jqwxb9bJOUUQLiNb7mxXS1uBJsEXh0B9nj05BqnPsE=",
"signed": "eiw3fZeCKIY50C4zPeg9Rt90M1Qlq3WlJh6Yw7xXm4nF6e9ETLE39+9M+rUqDWMRZjaBfaMbg5d9yDkz5p13U7ch2tlF9LoYabsWutkT014KRq/rcYMvFsU9n/Ey/TK0PVaxLN42X+pebV4juwMhN4mK4CzdFAJgM+UGBOj4yB9recpOBB9K8QFSpJZALSEdDgUc/mS1eDq3rU0int6+4NKuLQjpR+LSEIWRZ6g6+MND2vXGskxHjadCQ09L7Tz8VcWjKDbxJcBiGKvkqyozl9zrGo8fA3WHBmwiAgS61Merx77ZGY4PFR37+j/YMSC14prCN15DtMRv2xA1SGSb4w=="
},
{
"unsigned": "LMMFc34ASPnvNPFzBbMbr9FProS/Zu2P8zF/xzk5hVQ=",
"signed": "HBImKnHmw+6R2TpFEpfiAg4+hu2pFNwn43ClhKPkn2higbEhUD0JVi+4MerSyvU/NN79iWVxDvJ9Ito+jpiRQjTfTGEoIteyuAr1v/Bzh+HjmrO53OQpZaJ/VXGIgApD0myuu/ZGNKQTCSkkL7+V81FG7yR1Nm22jUeGa735zvm/E+cenvZdy0VVx6A7WeWrl3JEKKBweHbi+7BwbaW+PTdCuIRd4Ug76Sy+cFhsvcG1k7cMwDh8MgXzIZ2m1f/hdy2j8qAxORTLlmwyUOYvPYOvUhc+s83hx36QpGwGcD7RA0bPT5OrTx7PHd0N1CL+Wwy91We8yIOFBS6nxo1R7w=="
},
{
"unsigned": "dzeHbwhiVXQqcUGj563z51/7sLUdxjL93SbOUyZRjH8=",
"signed": "VgQPvrTsvGljVBFxHnswduq16x8ZrnxfcYVYGf/N7gEzI4At3GDs2EVZWTRdvS0uGHdkFYp1apHgJZ7PDVmGcTkIXVD2lFYppcgNlSzkYlftr5EOjqS9ZjYEqgGuB4g//MxaBaRbJai/6BlcE92NIdBusTtreIm3yTpjIXNAVoeRSnkfuw7wZcL96QoklNb1WUuSHw+psUyeIVtIwFMHEfFoRC0t+VhmnlnFnkjGPb9W3Aprw2dRRvFM3R2ZTDvMCiOYDzUCd43GftGq2LfxH3qSD51oFHglHQVOY0jyVzzlAvub5HQdtOQdErIeO0/9dGx5yot07o3xaGl5yQRhwA=="
}
]
}
```
1. Maintenant que votre fichier de jetons contient toutes les signatures requises, vous pouvez continuer. Entrez le nom du fichier contenant les jetons signés et appuyez sur la touche Entrée. Enfin, entrez le chemin de votre clé publique.
```
Enter signed token file path (press enter if same as the unsigned token file):
Enter public key PEM file path:officer1.pub
{
"error_code": 0,
"data": {
"username": "",
"role": "crypto-user"
}
}
```
Vous avez maintenant configuré votre utilisateur avec la MFA.
```
{
"username": "",
"role": "crypto-user",
"locked": "false",
"mfa": [
{
"strategy": "token-sign",
"status": "enabled"
}
],
"cluster-coverage": "full"
},
```
# Création d'utilisateurs avec la MFA activée pour la CLI CloudHSM
Suivez ces étapes pour créer des AWS CloudHSM utilisateurs avec l'authentification multifactorielle (MFA) activée.
1. Utilisez la CLI CloudHSM pour vous connecter au HSM en tant qu'administrateur.
1. Utilisez la commande [**user create**](cloudhsm_cli-user-create.md) pour créer l'utilisateur de votre choix. Suivez ensuite les étapes décrites dans [Configuration de la MFA pour la CLI CloudHSM](set-up-mfa-for-cloudhsm-cli.md) pour configurer la MFA pour l'utilisateur.
# Connectez-vous aux utilisateurs dont la MFA est activée pour la CLI CloudHSM
Suivez ces étapes pour connecter les AWS CloudHSM utilisateurs avec l'authentification multifactorielle (MFA) activée.
1. Utilisez la commande [**login mfa-token-sign**](cloudhsm_cli-login-mfa-token-sign.md) de la CLI CloudHSM pour démarrer le processus de connexion avec MFA pour un utilisateur dont la MFA est activée.
```
aws-cloudhsm > login --username --role mfa-token-sign --token
Enter password:
```
1. Entrez votre mot de passe. Vous serez ensuite invité à saisir le chemin d'accès au fichier de jetons qui contient des paires de unsigned/signed jetons, où les jetons signés sont ceux générés à l'aide de votre clé privée.
```
aws-cloudhsm > login --username --role mfa-token-sign --token
Enter password:
Enter signed token file path (press enter if same as the unsigned token file):
```
1. Lorsque vous êtes invité à saisir le chemin du fichier de jeton signé, vous pouvez inspecter le fichier de jeton non signé dans un terminal séparé. Identifiez le fichier contenant des jetons non signés qui doivent être signés : ``. Le nombre de jetons dans ce fichier dépend du nombre de jetons HSMs dans votre cluster. Chaque jeton représente un HSM. Ce fichier est au format JSON et contient des jetons qui doivent être signés pour prouver que vous disposez d'une clé privée.
```
$ cat
{
"version": "2.0",
"tokens": [
{
"unsigned": "Vtf/9QOFY45v/E1osvpEMr59JsnP/hLDm4ItOO2vqL8=",
"signed": ""
},
{
"unsigned": "wVbC0/5IKwjyZK2NBpdFLyI7BiayZ24YcdUdlcxLwZ4=",
"signed": ""
},
{
"unsigned": "z6aW9RzErJBL5KqFG5h8lhTVt9oLbxppjod0Ebysydw=",
"signed": ""
}
]
}
```
1. Signez les jetons non signés avec la clé privée créée à l'étape 2. Vous devez d'abord extraire et décoder les jetons codés en base64.
```
$ echo "Vtf/9QOFY45v/E1osvpEMr59JsnP/hLDm4ItOO2vqL8=" > token1.b64
$ echo "wVbC0/5IKwjyZK2NBpdFLyI7BiayZ24YcdUdlcxLwZ4=" > token2.b64
$ echo "z6aW9RzErJBL5KqFG5h8lhTVt9oLbxppjod0Ebysydw=" > token3.b64
$ base64 -d token1.b64 > token1.bin
$ base64 -d token2.b64 > token2.bin
$ base64 -d token3.b64 > token3.bin
```
1. Vous avez maintenant des jetons binaires. Signez-les à l'aide de la clé privée RSA que vous avez créée précédemment à l'[étape 1 de la configuration de la MFA](set-up-mfa-for-cloudhsm-cli.md).
```
$ openssl pkeyutl -sign \
-inkey officer1.key \
-pkeyopt digest:sha256 \
-keyform PEM \
-in token1.bin \
-out token1.sig.bin
$ openssl pkeyutl -sign \
-inkey officer1.key \
-pkeyopt digest:sha256 \
-keyform PEM \
-in token2.bin \
-out token2.sig.bin
$ openssl pkeyutl -sign \
-inkey officer1.key \
-pkeyopt digest:sha256 \
-keyform PEM \
-in token3.bin \
-out token3.sig.bin
```
1. Vous avez maintenant les signatures binaires des jetons. Codez-les en base64 et replacez-les dans votre fichier de jetons.
```
$ base64 -w0 token1.sig.bin > token1.sig.b64
$ base64 -w0 token2.sig.bin > token2.sig.b64
$ base64 -w0 token3.sig.bin > token3.sig.b64
```
1. Enfin, copiez et collez les valeurs base64 dans votre fichier de jetons :
```
{
"version": "2.0",
"tokens": [
{
"unsigned": "1jqwxb9bJOUUQLiNb7mxXS1uBJsEXh0B9nj05BqnPsE=",
"signed": "eiw3fZeCKIY50C4zPeg9Rt90M1Qlq3WlJh6Yw7xXm4nF6e9ETLE39+9M+rUqDWMRZjaBfaMbg5d9yDkz5p13U7ch2tlF9LoYabsWutkT014KRq/rcYMvFsU9n/Ey/TK0PVaxLN42X+pebV4juwMhN4mK4CzdFAJgM+UGBOj4yB9recpOBB9K8QFSpJZALSEdDgUc/mS1eDq3rU0int6+4NKuLQjpR+LSEIWRZ6g6+MND2vXGskxHjadCQ09L7Tz8VcWjKDbxJcBiGKvkqyozl9zrGo8fA3WHBmwiAgS61Merx77ZGY4PFR37+j/YMSC14prCN15DtMRv2xA1SGSb4w=="
},
{
"unsigned": "LMMFc34ASPnvNPFzBbMbr9FProS/Zu2P8zF/xzk5hVQ=",
"signed": "HBImKnHmw+6R2TpFEpfiAg4+hu2pFNwn43ClhKPkn2higbEhUD0JVi+4MerSyvU/NN79iWVxDvJ9Ito+jpiRQjTfTGEoIteyuAr1v/Bzh+HjmrO53OQpZaJ/VXGIgApD0myuu/ZGNKQTCSkkL7+V81FG7yR1Nm22jUeGa735zvm/E+cenvZdy0VVx6A7WeWrl3JEKKBweHbi+7BwbaW+PTdCuIRd4Ug76Sy+cFhsvcG1k7cMwDh8MgXzIZ2m1f/hdy2j8qAxORTLlmwyUOYvPYOvUhc+s83hx36QpGwGcD7RA0bPT5OrTx7PHd0N1CL+Wwy91We8yIOFBS6nxo1R7w=="
},
{
"unsigned": "dzeHbwhiVXQqcUGj563z51/7sLUdxjL93SbOUyZRjH8=",
"signed": "VgQPvrTsvGljVBFxHnswduq16x8ZrnxfcYVYGf/N7gEzI4At3GDs2EVZWTRdvS0uGHdkFYp1apHgJZ7PDVmGcTkIXVD2lFYppcgNlSzkYlftr5EOjqS9ZjYEqgGuB4g//MxaBaRbJai/6BlcE92NIdBusTtreIm3yTpjIXNAVoeRSnkfuw7wZcL96QoklNb1WUuSHw+psUyeIVtIwFMHEfFoRC0t+VhmnlnFnkjGPb9W3Aprw2dRRvFM3R2ZTDvMCiOYDzUCd43GftGq2LfxH3qSD51oFHglHQVOY0jyVzzlAvub5HQdtOQdErIeO0/9dGx5yot07o3xaGl5yQRhwA=="
}
]
}
```
1. Maintenant que votre fichier de jetons contient toutes les signatures requises, vous pouvez continuer. Entrez le nom du fichier contenant les jetons signés et appuyez sur la touche Entrée. Vous devriez maintenant vous connecter avec succès.
```
aws-cloudhsm > login --username --role mfa-token-sign --token
Enter password:
Enter signed token file path (press enter if same as the unsigned token file):
{
"error_code": 0,
"data": {
"username": "",
"role": ""
}
}
```
# Rotation des clés pour les utilisateurs dont la MFA est activée pour la CLI CloudHSM
Procédez comme suit pour faire pivoter les clés pour AWS CloudHSM les utilisateurs dont l'authentification multifactorielle (MFA) est activée.
1. Utilisez la CLI CloudHSM pour vous connecter au HSM en tant qu'administrateur ou en tant qu'utilisateur spécifique pour lequel la MFA est activée (voir [Connexion des utilisateurs avec MFA activée]() pour plus de détails).
1. Ensuite, exécutez la commande pour modifier votre stratégie MFA. Vous devez fournir le paramètre **--token**. Ce paramètre indique un fichier dans lequel seront écrits des jetons non signés.
```
aws-cloudhsm > user change-mfa token-sign --token unsigned-tokens.json --username --role crypto-user --change-quorum
Enter password:
Confirm password:
```
1. Identifiez le fichier contenant des jetons non signés qui doivent être signés : `unsigned-tokens.json`. Le nombre de jetons dans ce fichier dépend du nombre de jetons HSMs dans votre cluster. Chaque jeton représente un HSM. Ce fichier est au format JSON et contient des jetons qui doivent être signés pour prouver que vous disposez d'une clé privée. Il s'agira de la nouvelle clé privée de la nouvelle paire de public/private clés RSA que vous souhaitez utiliser pour faire pivoter la clé publique actuellement enregistrée.
```
$ cat unsigned-tokens.json
{
"version": "2.0",
"tokens": [
{
"unsigned": "Vtf/9QOFY45v/E1osvpEMr59JsnP/hLDm4ItOO2vqL8=",
"signed": ""
},
{
"unsigned": "wVbC0/5IKwjyZK2NBpdFLyI7BiayZ24YcdUdlcxLwZ4=",
"signed": ""
},
{
"unsigned": "z6aW9RzErJBL5KqFG5h8lhTVt9oLbxppjod0Ebysydw=",
"signed": ""
}
]
}
```
1. Signez ces jetons avec la clé privée que vous avez créée précédemment lors de l'installation. Nous devons d'abord extraire et décoder les jetons codés en base64.
```
$ echo "Vtf/9QOFY45v/E1osvpEMr59JsnP/hLDm4ItOO2vqL8=" > token1.b64
$ echo "wVbC0/5IKwjyZK2NBpdFLyI7BiayZ24YcdUdlcxLwZ4=" > token2.b64
$ echo "z6aW9RzErJBL5KqFG5h8lhTVt9oLbxppjod0Ebysydw=" > token3.b64
$ base64 -d token1.b64 > token1.bin
$ base64 -d token2.b64 > token2.bin
$ base64 -d token3.b64 > token3.bin
```
1. Vous avez maintenant des jetons binaires. Signez-les à l'aide de la clé privée RSA que vous avez créée précédemment lors de l'installation.
```
$ openssl pkeyutl -sign \
-inkey officer1.key \
-pkeyopt digest:sha256 \
-keyform PEM \
-in token1.bin \
-out token1.sig.bin
$ openssl pkeyutl -sign \
-inkey officer1.key \
-pkeyopt digest:sha256 \
-keyform PEM \
-in token2.bin \
-out token2.sig.bin
$ openssl pkeyutl -sign \
-inkey officer1.key \
-pkeyopt digest:sha256 \
-keyform PEM \
-in token3.bin \
-out token3.sig.bin
```
1. Vous avez maintenant les signatures binaires des jetons. Codez-les en base64 et replacez-les dans votre fichier de jetons.
```
$ base64 -w0 token1.sig.bin > token1.sig.b64
$ base64 -w0 token2.sig.bin > token2.sig.b64
$ base64 -w0 token3.sig.bin > token3.sig.b64
```
1. Enfin, copiez et collez les valeurs base64 dans votre fichier de jetons :
```
{
"version": "2.0",
"tokens": [
{
"unsigned": "1jqwxb9bJOUUQLiNb7mxXS1uBJsEXh0B9nj05BqnPsE=",
"signed": "eiw3fZeCKIY50C4zPeg9Rt90M1Qlq3WlJh6Yw7xXm4nF6e9ETLE39+9M+rUqDWMRZjaBfaMbg5d9yDkz5p13U7ch2tlF9LoYabsWutkT014KRq/rcYMvFsU9n/Ey/TK0PVaxLN42X+pebV4juwMhN4mK4CzdFAJgM+UGBOj4yB9recpOBB9K8QFSpJZALSEdDgUc/mS1eDq3rU0int6+4NKuLQjpR+LSEIWRZ6g6+MND2vXGskxHjadCQ09L7Tz8VcWjKDbxJcBiGKvkqyozl9zrGo8fA3WHBmwiAgS61Merx77ZGY4PFR37+j/YMSC14prCN15DtMRv2xA1SGSb4w=="
},
{
"unsigned": "LMMFc34ASPnvNPFzBbMbr9FProS/Zu2P8zF/xzk5hVQ=",
"signed": "HBImKnHmw+6R2TpFEpfiAg4+hu2pFNwn43ClhKPkn2higbEhUD0JVi+4MerSyvU/NN79iWVxDvJ9Ito+jpiRQjTfTGEoIteyuAr1v/Bzh+HjmrO53OQpZaJ/VXGIgApD0myuu/ZGNKQTCSkkL7+V81FG7yR1Nm22jUeGa735zvm/E+cenvZdy0VVx6A7WeWrl3JEKKBweHbi+7BwbaW+PTdCuIRd4Ug76Sy+cFhsvcG1k7cMwDh8MgXzIZ2m1f/hdy2j8qAxORTLlmwyUOYvPYOvUhc+s83hx36QpGwGcD7RA0bPT5OrTx7PHd0N1CL+Wwy91We8yIOFBS6nxo1R7w=="
},
{
"unsigned": "dzeHbwhiVXQqcUGj563z51/7sLUdxjL93SbOUyZRjH8=",
"signed": "VgQPvrTsvGljVBFxHnswduq16x8ZrnxfcYVYGf/N7gEzI4At3GDs2EVZWTRdvS0uGHdkFYp1apHgJZ7PDVmGcTkIXVD2lFYppcgNlSzkYlftr5EOjqS9ZjYEqgGuB4g//MxaBaRbJai/6BlcE92NIdBusTtreIm3yTpjIXNAVoeRSnkfuw7wZcL96QoklNb1WUuSHw+psUyeIVtIwFMHEfFoRC0t+VhmnlnFnkjGPb9W3Aprw2dRRvFM3R2ZTDvMCiOYDzUCd43GftGq2LfxH3qSD51oFHglHQVOY0jyVzzlAvub5HQdtOQdErIeO0/9dGx5yot07o3xaGl5yQRhwA=="
}
]
}
```
1. Maintenant que votre fichier de jetons contient toutes les signatures requises, vous pouvez continuer. Entrez le nom du fichier contenant les jetons signés et appuyez sur la touche Entrée. Enfin, saisissez le chemin de votre nouvelle clé publique. Vous verrez maintenant ce qui suit dans le cadre de la sortie de [user list]().
```
Enter signed token file path (press enter if same as the unsigned token file):
Enter public key PEM file path:officer1.pub
{
"error_code": 0,
"data": {
"username": "",
"role": "crypto-user"
}
}
```
Nous avons maintenant configuré notre utilisateur avec la MFA.
```
{
"username": "",
"role": "crypto-user",
"locked": "false",
"mfa": [
{
"strategy": "token-sign",
"status": "enabled"
}
],
"cluster-coverage": "full"
},
```
Vous avez signé le fichier de jeton au format JSON généré avec votre clé privée et enregistré une nouvelle clé publique MFA.
# Désenregistrer une clé publique MFA à l'aide de la CLI CloudHSM
Procédez comme suit pour annuler l'enregistrement d'une clé publique d'authentification multifactorielle (MFA) pour les AWS CloudHSM utilisateurs administrateurs lorsque la clé publique MFA est enregistrée.
1. Utilisez la CLI CloudHSM pour vous connecter au HSM en tant qu'administrateur avec la MFA activée.
1. Utilisez la commande **user change-mfa token-sign** pour supprimer la MFA pour un utilisateur.
```
aws-cloudhsm > user change-mfa token-sign --username --role admin --deregister --change-quorum
Enter password:
Confirm password:
{
"error_code": 0,
"data": {
"username": "",
"role": "admin"
}
}
```
# Référence de fichier de jetons pour MFA avec CLI CloudHSM
Le fichier de jetons généré lors de l'enregistrement d'une clé publique d'authentification multifactorielle (MFA) ou lors de la tentative de connexion à la CLI CloudHSM à l'aide de la MFA se compose des éléments suivants :
+ **Jetons :** un tableau de paires de unsigned/signed jetons codées en base64 sous la forme de littéraux d'objets JSON.
+ **Non signé : jeton** codé et SHA256 haché en base64.
+ **Signé :** jeton signé codé en base64 (signature) du jeton non signé, à l'aide de la clé privée RSA 2 048 bits.
```
{
"version": "2.0",
"tokens": [
{
"unsigned": "1jqwxb9bJOUUQLiNb7mxXS1uBJsEXh0B9nj05BqnPsE=",
"signed": "eiw3fZeCKIY50C4zPeg9Rt90M1Qlq3WlJh6Yw7xXm4nF6e9ETLE39+9M+rUqDWMRZjaBfaMbg5d9yDkz5p13U7ch2tlF9LoYabsWutkT014KRq/rcYMvFsU9n/Ey/TK0PVaxLN42X+pebV4juwMhN4mK4CzdFAJgM+UGBOj4yB9recpOBB9K8QFSpJZALSEdDgUc/mS1eDq3rU0int6+4NKuLQjpR+LSEIWRZ6g6+MND2vXGskxHjadCQ09L7Tz8VcWjKDbxJcBiGKvkqyozl9zrGo8fA3WHBmwiAgS61Merx77ZGY4PFR37+j/YMSC14prCN15DtMRv2xA1SGSb4w=="
},
{
"unsigned": "LMMFc34ASPnvNPFzBbMbr9FProS/Zu2P8zF/xzk5hVQ=",
"signed": "HBImKnHmw+6R2TpFEpfiAg4+hu2pFNwn43ClhKPkn2higbEhUD0JVi+4MerSyvU/NN79iWVxDvJ9Ito+jpiRQjTfTGEoIteyuAr1v/Bzh+HjmrO53OQpZaJ/VXGIgApD0myuu/ZGNKQTCSkkL7+V81FG7yR1Nm22jUeGa735zvm/E+cenvZdy0VVx6A7WeWrl3JEKKBweHbi+7BwbaW+PTdCuIRd4Ug76Sy+cFhsvcG1k7cMwDh8MgXzIZ2m1f/hdy2j8qAxORTLlmwyUOYvPYOvUhc+s83hx36QpGwGcD7RA0bPT5OrTx7PHd0N1CL+Wwy91We8yIOFBS6nxo1R7w=="
},
{
"unsigned": "dzeHbwhiVXQqcUGj563z51/7sLUdxjL93SbOUyZRjH8=",
"signed": "VgQPvrTsvGljVBFxHnswduq16x8ZrnxfcYVYGf/N7gEzI4At3GDs2EVZWTRdvS0uGHdkFYp1apHgJZ7PDVmGcTkIXVD2lFYppcgNlSzkYlftr5EOjqS9ZjYEqgGuB4g//MxaBaRbJai/6BlcE92NIdBusTtreIm3yTpjIXNAVoeRSnkfuw7wZcL96QoklNb1WUuSHw+psUyeIVtIwFMHEfFoRC0t+VhmnlnFnkjGPb9W3Aprw2dRRvFM3R2ZTDvMCiOYDzUCd43GftGq2LfxH3qSD51oFHglHQVOY0jyVzzlAvub5HQdtOQdErIeO0/9dGx5yot07o3xaGl5yQRhwA=="
}
]
}
```
# Gestion de l'authentification par quorum (contrôle d'accès M of N) à l'aide de la CLI CloudHSM
AWS CloudHSM les clusters prennent en charge l'authentification par quorum, également connue sous le nom de contrôle d'accès M of N. Cette fonctionnalité oblige les utilisateurs du HSM à coopérer pour certaines opérations, ce qui ajoute un niveau de protection supplémentaire.
Avec l'authentification par quorum, aucun utilisateur du HSM ne peut effectuer des opérations contrôlées par le quorum sur le HSM. À la place, un nombre minimal d'utilisateurs HSM (au moins 2) doivent coopérer pour effectuer ces opérations.
L'authentification par quorum peut contrôler les opérations suivantes :
+ Gestion des utilisateurs HSM par l'[administrateur](understanding-users.md#admin) : création et suppression d'utilisateurs HSM ou modification du mot de passe d'un autre utilisateur HSM. Pour de plus amples informations, veuillez consulter [Gestion des utilisateurs avec authentification par quorum activée pour l' AWS CloudHSM utilisation de la CLI CloudHSM](quorum-auth-chsm-cli-admin.md).
Points clés concernant l'authentification par quorum dans AWS CloudHSM.
+ Un utilisateur HSM peut signer son propre jeton de quorum, c'est-à-dire fournir l'une des approbations requises pour l'authentification du quorum.
+ Vous choisissez le nombre minimum d'approbateurs du quorum, compris entre deux (2) et huit (8).
+ HSMs peut stocker jusqu'à 1024 jetons de quorum. Lorsque cette limite est atteinte, le HSM purge un jeton expiré pour en créer un nouveau.
+ Par défaut, les jetons expirent dix minutes après leur création.
+ Pour les clusters sur lesquels l'authentification MFA est activée, la même clé est utilisée pour l'authentification par quorum et l'authentification multifactorielle (MFA). Consultez la section [Utilisation de la CLI CloudHSM pour gérer le MFA pour](login-mfa-token-sign.md) plus d'informations.
+ Chaque HSM peut contenir un jeton par service d'administration et plusieurs jetons par service Crypto User.
Les rubriques suivantes fournissent plus d'informations sur l'authentification par quorum dans AWS CloudHSM.
**Topics**
+ [Processus d'authentification par quorum pour la CLI CloudHSM](quorum-auth-chsm-cli-overview.md)
+ [Noms et types AWS CloudHSM de service pris en charge pour l'authentification par quorum avec la CLI CloudHSM](quorum-auth-chsm-cli-service-names.md)
+ [Configurer l'authentification par quorum pour les AWS CloudHSM administrateurs à l'aide de la CLI CloudHSM](quorum-auth-chsm-cli-first-time.md)
+ [Gestion des utilisateurs avec authentification par quorum activée pour l' AWS CloudHSM utilisation de la CLI CloudHSM](quorum-auth-chsm-cli-admin.md)
+ [Modifier la valeur minimale du quorum pour AWS CloudHSM utiliser la CLI CloudHSM](quorum-auth-chsm-cli-min-value.md)
# Processus d'authentification par quorum pour la CLI CloudHSM
Les étapes suivantes résument les processus d'authentification par quorum pour la CLI CloudHSM. Pour connaître les étapes et les outils spécifiques, consultez [Gestion des utilisateurs avec authentification par quorum activée pour l' AWS CloudHSM utilisation de la CLI CloudHSM](quorum-auth-chsm-cli-admin.md).
1. Chaque utilisateur du module de sécurité matérielle (HSM) crée une clé asymétrique pour la signature. Les utilisateurs s'en chargent en dehors du HSM, en veillant à protéger la clé de manière appropriée.
1. Chaque utilisateur HSM se connecte au HSM et enregistre la partie publique de sa clé de signature (la clé publique) avec le HSM.
1. Lorsqu'un utilisateur HSM veut effectuer une opération contrôlée par quorum, il se connecte au HSM et obtient un *jeton de quorum*.
1. L'utilisateur HSM donne le jeton de quorum à un ou plusieurs autres utilisateurs HSM et demande leur approbation.
1. Les autres utilisateurs HSM approuvent en utilisant leurs clés pour signer de façon chiffrée le jeton de quorum. Cela se produit en dehors du HSM.
1. Lorsque l'utilisateur du HSM dispose du nombre d'approbations requis, il se connecte au HSM et exécute l'opération de contrôle du quorum avec l'argument **--approval**, en fournissant le fichier de jeton de quorum signé, qui contient toutes les approbations nécessaires (signatures).
1. Le HSM utilise les clés publiques enregistrées de chaque signataire pour vérifier les signatures. Si les signatures sont valides, le HSM approuve le jeton et l'opération contrôlée par le quorum est exécutée.
# Noms et types AWS CloudHSM de service pris en charge pour l'authentification par quorum avec la CLI CloudHSM
**Services d'administrateur** : l'authentification par quorum est utilisée pour les services dotés de privilèges d'administrateur tels que la création d'utilisateurs, la suppression d'utilisateurs, la modification des mots de passe des utilisateurs, la définition des valeurs de quorum et la désactivation des fonctionnalités de quorum et de MFA.
**Services aux utilisateurs cryptographiques** : l'authentification par quorum est utilisée pour les services privilégiés des utilisateurs cryptographiques associés à une clé spécifique, tels que la signature avec une clé, sharing/unsharing une clé, wrapping/unwrapping une clé et la définition de l'attribut d'une clé. La valeur de quorum d'une clé associée est configurée lorsque la clé est générée, importée ou déballée. La valeur du quorum doit être égale ou inférieure au nombre d'utilisateurs auxquels la clé est associée, y compris les utilisateurs avec lesquels la clé est partagée et le propriétaire de la clé.
Chaque type de service est ensuite décomposé en un nom de service éligible, qui contient un ensemble spécifique d'opérations de service prises en charge par le quorum qui peuvent être effectuées.
****
| Nom du service | Type de service | Opérations de service |
| --- | --- | --- |
| user | Admin | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/quorum-auth-chsm-cli-service-names.html) |
| quorum | Admin | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/quorum-auth-chsm-cli-service-names.html) |
| grappe 1 | Admin | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/quorum-auth-chsm-cli-service-names.html) |
| gestion des clés | Utilisateur de Crypto | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/quorum-auth-chsm-cli-service-names.html) |
| utilisation des clés | Utilisateur de Crypto | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/quorum-auth-chsm-cli-service-names.html) |
[1] Le service Cluster est exclusivement disponible sur hsm2m.medium
# Configurer l'authentification par quorum pour les AWS CloudHSM administrateurs à l'aide de la CLI CloudHSM
Les rubriques suivantes décrivent les étapes que vous devez suivre pour configurer votre module de sécurité matériel (HSM) afin que les AWS CloudHSM [administrateurs](understanding-users.md#admin) puissent utiliser l'authentification par quorum. Vous devez suivre ces étapes une seule fois lorsque vous configurez l'authentification par quorum pour les administrateurs. Une fois que vous avez terminé ces étapes, consultez [Gestion des utilisateurs avec authentification par quorum activée pour l' AWS CloudHSM utilisation de la CLI CloudHSM](quorum-auth-chsm-cli-admin.md).
**Topics**
+ [Conditions préalables](#quorum-admin-prerequisites)
+ [Étape 1. Création et enregistrement d'une clé pour la signature](#quorum-admin-create-and-register-key)
+ [Étape 2. Définition de la valeur minimale de quorum sur le HSM](#quorum-admin-set-quorum-minimum-value-chsm-cli)
+ [Valeurs minimales du quorum](#cloudhsm_cli-qm-list-minimum)
## Conditions préalables
Pour comprendre cet exemple, vous devez bien connaître la [CLI CloudHSM](cloudhsm_cli.md).
## Étape 1. Création et enregistrement d'une clé pour la signature
Pour utiliser l'authentification par quorum, chaque administrateur doit effectuer *toutes* les étapes suivantes :
**Topics**
+ [Créer une paire de clés RSA](#mofn-key-pair-create-chsm-cli)
+ [Créez et signez un jeton d'enregistrement](#mofn-registration-token-chsm-cli)
+ [Enregistrez la clé publique avec le HSM](#mofn-register-key-chsm-cli)
### Créer une paire de clés RSA
Il existe de nombreuses manières différentes de créer et de protéger une paire de clés. Les exemples suivants montrent comment procéder avec [OpenSSL](https://www.openssl.org/).
**Example — Créer une clé privée à l'aide d'OpenSSL**
L'exemple suivant montre comment utiliser OpenSSL pour créer une clé RSA 2048 bits. Pour utiliser cet exemple, ** remplacez-le par le nom du fichier dans lequel vous souhaitez stocker la clé.
```
$ openssl genrsa -out
Generating RSA private key, 2048 bit long modulus
.....................................+++
.+++
e is 65537 (0x10001)
```
Générez ensuite la clé publique à l'aide de la clé privée que vous venez de créer.
**Example — Crée une clé publique avec OpenSSL**
L'exemple suivant montre comment utiliser OpenSSL pour créer une clé publique à partir de la clé privée que vous venez de créer.
```
$ openssl rsa -in admin.key -outform PEM -pubout -out admin1.pub
writing RSA key
```
### Créez et signez un jeton d'enregistrement
Vous créez un jeton et vous le signez avec la clé privée que vous venez de générer à l'étape précédente.
**Example — Créez un jeton d'enregistrement**
1. Utilisez la commande suivante pour démarrer la CLI CloudHSM :
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
```
------
1. Créez un jeton d'enregistrement en exécutant la commande [quorum token-sign generate](cloudhsm_cli-qm-token-gen.md) :
```
aws-cloudhsm > quorum token-sign generate --service registration --token /path/tokenfile
{
"error_code": 0,
"data": {
"path": "/path/tokenfile"
}
}
```
1. La commande [quorum token-sign generate](cloudhsm_cli-qm-token-gen.md) génère un jeton d'enregistrement sur le chemin de fichier spécifié. Inspectez le fichier du jeton :
```
$ cat /path/tokenfile
{
"version": "2.0",
"tokens": [
{
"approval_data": ,
"unsigned": ,
"signed": ""
}
]
}
```
Le chemin d'accès au fichier se compose des éléments suivants :
+ **approval\$1data** : jeton de données aléatoire codé en base64 dont les données brutes ne dépassent pas le maximum de 245 octets.
+ **unsigned** : jeton codé et SHA256 haché en base64 du fichier approval\$1data.
+ **signé** : jeton signé codé en base64 (signature) du jeton non signé, utilisant la clé privée RSA 2048 bits précédemment générée avec OpenSSL.
Vous signez le jeton non signé avec la clé privée pour démontrer que vous avez accès à la clé privée. Vous aurez besoin du fichier de jeton d'enregistrement entièrement rempli d'une signature et de la clé publique pour enregistrer l'administrateur en tant qu'utilisateur du quorum auprès du AWS CloudHSM cluster.
**Example — Signez le jeton d'enregistrement non signé**
1. Décodez le jeton non signé codé en base64 et placez-le dans un fichier binaire :
```
$ echo -n '6BMUj6mUjjko6ZLCEdzGlWpR5sILhFJfqhW1ej3Oq1g=' | base64 -d > admin.bin
```
1. Utilisez OpenSSL et la clé privée pour signer le jeton d'enregistrement non signé désormais binaire et créer un fichier de signature binaire :
```
$ openssl pkeyutl -sign \
-inkey admin.key \
-pkeyopt digest:sha256 \
-keyform PEM \
-in admin.bin \
-out admin.sig.bin
```
1. Encodez la signature binaire en base64 :
```
$ base64 -w0 admin.sig.bin > admin.sig.b64
```
1. Copiez et collez la signature codée en base64 dans le fichier de jeton :
```
{
"version": "2.0",
"tokens": [
{
"approval_data": ,
"unsigned": ,
"signed":
}
]
}
```
### Enregistrez la clé publique avec le HSM
Après avoir créé une clé, l'administrateur doit enregistrer la clé publique auprès du AWS CloudHSM cluster.
**Pour enregistrer une clé publique avec le HSM**
1. Utilisez la commande suivante pour démarrer la CLI CloudHSM.
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
```
------
1. À l'aide de la CLI CloudHSM, connectez-vous en tant qu'administrateur.
```
aws-cloudhsm > login --username --role admin
Enter password:
{
"error_code": 0,
"data": {
"username": "",
"role": "admin"
}
}
```
1. Utilisez la commande **[Enregistrez la stratégie de quorum par signature jeton d'un utilisateur à l'aide de la CLI CloudHSM](cloudhsm_cli-user-chqm-token-reg.md)** pour enregistrer la clé publique. Pour plus d'informations, consultez l'exemple suivant ou utilisez la commande **help user change-quorum token-sign register**.
**Example — Enregistrez une clé publique auprès AWS CloudHSM du cluster**
L'exemple suivant montre comment utiliser la commande **user change-quorum token-sign register** de la CLI CloudHSM pour enregistrer la clé publique d'un administrateur avec le HSM. Pour utiliser cette commande, l’administrateur doit être connecté au HSM. Remplacez les valeurs suivantes par les vôtres :
```
aws-cloudhsm > user change-quorum token-sign register --public-key --signed-token
{
"error_code": 0,
"data": {
"username": "admin",
"role": "admin"
}
}
```
**/path/admin.pub** : chemin d'accès au fichier PEM à clé publique
**Obligatoire** : oui
**/path/tokenfile** : le chemin du fichier avec le jeton signé par la clé privée de l'utilisateur
**Obligatoire** : oui
Une fois que tous les administrateurs ont enregistré leurs clés publiques, le résultat de la commande **user list** l'indique dans le champ de quorum, indiquant la stratégie de quorum activée utilisée, comme indiqué ci-dessous :
```
aws-cloudhsm > user list
{
"error_code": 0,
"data": {
"users": [
{
"username": "admin",
"role": "admin",
"locked": "false",
"mfa": [],
"quorum": [
{
"strategy": "token-sign",
"status": "enabled"
}
],
"cluster-coverage": "full"
},
{
"username": "admin2",
"role": "admin",
"locked": "false",
"mfa": [],
"quorum": [
{
"strategy": "token-sign",
"status": "enabled"
}
],
"cluster-coverage": "full"
},
{
"username": "admin3",
"role": "admin",
"locked": "false",
"mfa": [],
"quorum": [
{
"strategy": "token-sign",
"status": "enabled"
}
],
"cluster-coverage": "full"
},
{
"username": "admin4",
"role": "admin",
"locked": "false",
"mfa": [],
"quorum": [
{
"strategy": "token-sign",
"status": "enabled"
}
],
"cluster-coverage": "full"
},
{
"username": "app_user",
"role": "internal(APPLIANCE_USER)",
"locked": "false",
"mfa": [],
"quorum": [],
"cluster-coverage": "full"
}
]
}
}
```
Dans cet exemple, le AWS CloudHSM cluster en compte deux HSMs, chacun ayant les mêmes administrateurs, comme indiqué dans le résultat suivant de la **user list** commande. Pour plus d'informations sur la création d'utilisateurs, voir [Gestion des utilisateurs avec la CLI CloudHSM](manage-hsm-users-chsm-cli.md)
## Étape 2. Définition de la valeur minimale de quorum sur le HSM
Pour utiliser l'authentification par quorum, un administrateur doit se connecter au HSM, puis définir la *valeur minimale de quorum*. Il s'agit du nombre minimal d'approbations d’administrateur qui sont nécessaires pour effectuer des opérations de gestion des utilisateurs HSM. Tout administrateur sur le HSM peut définir la valeur minimale de quorum, y compris les administrateurs qui n'ont pas enregistré de clé pour la signature. Vous pouvez modifier la valeur minimale du quorum à tout moment. Pour de plus amples informations, veuillez consulter [Modifier la valeur minimale.](quorum-auth-chsm-cli-min-value.md).
**Pour définir la valeur minimale de quorum sur le HSM**
1. Utilisez la commande suivante pour démarrer la CLI CloudHSM.
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
```
------
1. À l'aide de la CLI CloudHSM, connectez-vous en tant qu'administrateur.
```
aws-cloudhsm > login --username --role admin
Enter password:
{
"error_code": 0,
"data": {
"username": "",
"role": "admin"
}
}
```
1. Utilisez la commande **[Mettre à jour une valeur de quorum à l'aide de la CLI CloudHSM](cloudhsm_cli-qm-token-set-qm.md)** pour définir la valeur minimale de quorum. L'`--service`indicateur identifie le service HSM pour lequel vous définissez des valeurs. Consultez l'exemple suivant ou utilisez la **help quorum token-sign set-quorum-value** commande pour plus d'informations.
**Example - Définition de la valeur minimale de quorum sur le HSM**
Cet exemple utilise une valeur minimale de quorum de deux (2). Vous pouvez choisir n'importe quelle valeur comprise entre deux (2) et huit (8), jusqu'au nombre total d’administrateurs sur le HSM. Dans cet exemple, le HSM compte quatre (4) administrateurs, la valeur maximale possible est donc de quatre (4).
Pour utiliser l'exemple de commande suivant, remplacez le nombre final (*<2>*) par la valeur minimale de quorum préférée.
```
aws-cloudhsm > quorum token-sign set-quorum-value --service user --value <2>
{
"error_code": 0,
"data": "Set quorum value successful"
}
```
Dans cet exemple, la **[Afficher les valeurs de quorum à l'aide de la CLI CloudHSM](cloudhsm_cli-qm-token-list-qm.md)** commande répertorie les types, les noms et les descriptions des services HSM inclus dans le service.
## Valeurs minimales du quorum
Utilisez la commande **quorum token-sign list-quorum-values** pour obtenir la valeur minimale du quorum pour un service.
```
aws-cloudhsm > quorum token-sign list-quorum-values
{
"error_code": 0,
"data": {
"user": 2,
"quorum": 1
}
}
```
La sortie de la commande **quorum token-sign list-quorum-values** précédente indique que la valeur minimale de quorum pour le service des utilisateurs HSM, responsable des opérations de gestion des utilisateurs, est désormais égale à deux (2). Une fois que vous avez terminé ces étapes, consultez [Gestion des utilisateurs avec quorum (M sur N)](quorum-auth-chsm-cli-admin.md).
**Services d'administrateur** : l'authentification par quorum est utilisée pour les services dotés de privilèges d'administrateur tels que la création d'utilisateurs, la suppression d'utilisateurs, la modification des mots de passe des utilisateurs, la définition des valeurs de quorum et la désactivation des fonctionnalités de quorum et de MFA.
**Services aux utilisateurs cryptographiques** : l'authentification par quorum est utilisée pour les services privilégiés des utilisateurs cryptographiques associés à une clé spécifique, tels que la signature avec une clé, sharing/unsharing une clé, wrapping/unwrapping une clé et la définition de l'attribut d'une clé. La valeur de quorum d'une clé associée est configurée lorsque la clé est générée, importée ou déballée. La valeur du quorum doit être égale ou inférieure au nombre d'utilisateurs auxquels la clé est associée, y compris les utilisateurs avec lesquels la clé est partagée et le propriétaire de la clé.
Chaque type de service est ensuite décomposé en un nom de service éligible, qui contient un ensemble spécifique d'opérations de service prises en charge par le quorum qui peuvent être effectuées.
****
| Nom du service | Type de service | Opérations de service |
| --- | --- | --- |
| user | Admin | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/quorum-auth-chsm-cli-first-time.html) |
| quorum | Admin | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/quorum-auth-chsm-cli-first-time.html) |
| grappe 1 | Admin | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/quorum-auth-chsm-cli-first-time.html) |
| gestion des clés | Utilisateur de Crypto | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/quorum-auth-chsm-cli-first-time.html) |
| utilisation des clés | Utilisateur de Crypto | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/cloudhsm/latest/userguide/quorum-auth-chsm-cli-first-time.html) |
[1] Le service Cluster est exclusivement disponible sur hsm2m.medium
# Gestion des utilisateurs avec authentification par quorum activée pour l' AWS CloudHSM utilisation de la CLI CloudHSM
Un AWS CloudHSM [administrateur](understanding-users.md#admin) du module de sécurité matérielle (HSM) peut configurer l'authentification par quorum pour les opérations suivantes dans le AWS CloudHSM cluster :
+ **[Création d'un AWS CloudHSM utilisateur à l'aide de la CLI CloudHSM](cloudhsm_cli-user-create.md)**
+ **[Supprimer un AWS CloudHSM utilisateur à l'aide de la CLI CloudHSM](cloudhsm_cli-user-delete.md)**
+ **[Modifier le mot de passe d'un utilisateur avec la CLI CloudHSM](cloudhsm_cli-user-change-password.md)**
+ **[La catégorie user change-mfa dans la CLI CloudHSM](cloudhsm_cli-user-change-mfa.md)**
Une fois le AWS CloudHSM cluster configuré pour l'authentification par quorum, les administrateurs ne peuvent pas effectuer eux-mêmes les opérations de gestion des utilisateurs HSM. L'exemple suivant montre la sortie lorsqu'un administrateur tente de créer un nouvel utilisateur sur le HSM. La commande échoue avec une erreur indiquant que l'authentification par quorum est requise.
```
aws-cloudhsm > user create --username user1 --role crypto-user
Enter password:
Confirm password:
{
"error_code": 1,
"data": "Quorum approval is required for this operation"
}
```
Pour effectuer une opération de gestion d'utilisateur HSM, un administrateur doit exécuter les tâches suivantes :
**Topics**
+ [Étape 1. Obtention d'un jeton de quorum](#quorum-admin-gen-token-chsm-cli)
+ [Étape 2. Obtention des signatures des administrateurs en charge de l'approbation](#quorum-admin-get-approval-signatures-chsm-cli)
+ [Étape 3. Approuver le jeton sur le AWS CloudHSM cluster et exécuter une opération de gestion des utilisateurs](#quorum-admin-approve-token-chsm-cli)
## Étape 1. Obtention d'un jeton de quorum
Tout d'abord, l'administrateur doit utiliser la CLI CloudHSM pour demander un *jeton de quorum*.
**Pour obtenir un jeton de quorum**
1. Utilisez la commande suivante pour démarrer la CLI CloudHSM.
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
```
------
1. À l'aide de la CLI CloudHSM, connectez-vous en tant qu'administrateur.
```
aws-cloudhsm > login --username --role admin
Enter password:
{
"error_code": 0,
"data": {
"username": "",
"role": "admin"
}
}
```
1. Utilisez la commande **quorum token-sign generate** pour générer un jeton de quorum. Pour plus d'informations, consultez l'exemple suivant ou utilisez la commande **help quorum token-sign generate**.
**Example — Génère un jeton de quorum**
Cet exemple obtient un jeton de quorum pour l’administrateur avec le nom d'utilisateur `admin` et enregistre le jeton dans un fichier nommé `admin.token`. Pour utiliser l'exemple de commande, remplacez ces valeurs par les vôtres :
+ **— Le nom de l'administrateur qui reçoit le jeton. Il doit s'agir du même administrateur que celui qui est connecté au HSM et qui exécute cette commande.
+ **— Nom du fichier à utiliser pour stocker le jeton de quorum.
Dans la commande suivante, `user` identifie le *nom de service* pour lequel vous pouvez utiliser le jeton que vous générez. Dans ce cas, le jeton concerne les opérations de gestion des utilisateurs HSM (`user` service). .
```
aws-cloudhsm > login --username --role admin --password
{
"error_code": 0,
"data": {
"username": "",
"role": "admin"
}
}
```
```
aws-cloudhsm > quorum token-sign generate --service user --token
{
"error_code": 0,
"data": {
"path": "/home/tfile"
}
}
```
La commande **quorum token-sign generate** génère un jeton de quorum de service utilisateur sur le chemin de fichier spécifié. Le fichier du jeton peut être inspecté :
```
$ cat
{
"version": "2.0",
"service": "user-management",
"approval_data": "AAEAAwAAABgAAAAAAAAAAJ9eFkfcP3mNzJAlfK+OWbNhZG1pbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj5vbeAAAAAAAAAAAAAQADAAAAFQAAAAAAAAAAW/v5Euk83amq1fij0zyvD2FkbWluAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGPm9t4AAAAAAAAAAAABAAMAAAAUAAAAAAAAAABDw2XDwfK4hB8a15Xh1E0nYWRtaW4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY+b23gAAAAAAAAAA",
"token": "0l2LZkmAHZyAc1hPhyckOoVW33aGrgG77qmDHWQ3CJ8=",
"signatures": []
}
```
Le chemin d'accès au fichier se compose des éléments suivants :
+ **service** : identifiant du service de quorum auquel le jeton est associé.
+ **approval\$1data** : jeton de données brutes codé en base64 généré par le HSM.
+ **jeton** : jeton codé en base64 et haché SHA-256 du approval\$1data
+ **signatures** : tableau de jetons signés codés en base64 (signatures) du jeton non signé, où chaque signature d'un approbateur prend la forme d'un objet JSON littéral :
```
{
"username": "",
"role": "",
"signature": ""
}
```
Chaque signature est créée à partir du résultat d'un approbateur à l'aide de la clé privée RSA 2048 bits correspondante dont la clé publique a été enregistrée auprès du HSM.
L'existence du jeton de quorum du service utilisateur généré peut être confirmée sur le cluster CloudHSM en exécutant la commande **quorum token-sign list** :
```
aws-cloudhsm > quorum token-sign list
{
"error_code": 0,
"data": {
"tokens": [
{
"username": "admin",
"service": "user",
"approvals-required": {
"value": 2
},
"number-of-approvals": {
"value": 0
},
"token-timeout-seconds": {
"value": 597
},
"cluster-coverage": "full"
}
]
}
}
```
L’heure `token-timeout-seconds` indique le délai d'expiration en secondes pour qu'un jeton généré soit approuvé avant son expiration.
## Étape 2. Obtention des signatures des administrateurs en charge de l'approbation
Un administrateur qui possède un jeton de quorum doit obtenir le jeton approuvé par d'autres administrateurs. Pour donner leur approbation, les autres administrateurs utilisent leur clé de signature pour signer le jeton de façon cryptographique. Ils le font en dehors du module HSM.
Il existe de nombreuses façons différentes de signer le jeton. L'exemple suivant montre comment procéder avec [OpenSSL](https://www.openssl.org/). Pour utiliser un autre outil de signature, assurez-vous que l'outil utilise la clé privée de l’administrateur (clé de signature) pour signer un hachage SHA-256 du jeton.
**Example - Obtention des signatures des administrateurs en charge de l'approbation**
Dans cet exemple, l’administrateur qui possède le jeton (`admin`) a besoin d'au moins deux (2) approbations. L'exemple de commandes suivant montrent comment deux (2) administrateurs peuvent utiliser OpenSSL pour signer le jeton de manière cryptographique.
1. Décodez le jeton non signé codé en base64 et placez-le dans un fichier binaire :
```
$ echo -n '0l2LZkmAHZyAc1hPhyckOoVW33aGrgG77qmDHWQ3CJ8=' | base64 -d > admin.bin
```
1. Utilisez OpenSSL et la clé privée correspondante de l'approbateur `(admin3)` pour signer le jeton non signé du quorum désormais binaire pour le service utilisateur et créer un fichier de signature binaire :
```
$ openssl pkeyutl -sign \
-inkey admin3.key \
-pkeyopt digest:sha256 \
-keyform PEM \
-in admin.bin \
-out admin.sig.bin
```
1. Encodez la signature binaire en base64 :
```
$ base64 -w0 admin.sig.bin > admin.sig.b64
```
1. Enfin, copiez et collez la signature codée en base64 dans le fichier de jeton, en suivant le format littéral d'objet JSON spécifié précédemment pour la signature de l'approbateur :
```
{
"version": "2.0",
"approval_data": "AAEAAwAAABgAAAAAAAAAAJ9eFkfcP3mNzJAlfK+OWbNhZG1pbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj5vbeAAAAAAAAAAAAAQADAAAAFQAAAAAAAAAAW/v5Euk83amq1fij0zyvD2FkbWluAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGPm9t4AAAAAAAAAAAABAAMAAAAUAAAAAAAAAABDw2XDwfK4hB8a15Xh1E0nYWRtaW4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY+b23gAAAAAAAAAA",
"token": "0l2LZkmAHZyAc1hPhyckOoVW33aGrgG77qmDHWQ3CJ8=",
"signatures": [
{
"username": "admin2",
"role": "admin",
"signature": "O6qx7/mUaVkYYVr1PW7l8JJko+Kh3e8zBIqdk3tAiNy+1rW+OsDtvYujhEU4aOFVLcrUFmyB/CX9OQmgJLgx/pyK+ZPEH+GoJGqk9YZ7X1nOXwZRP9g7hKV+7XCtg9TuDFtHYWDpBfz2jWiu2fXfX4/jTs4f2xIfFPIDKcSP8fhxjQ63xEcCf1jzGha6rDQMu4xUWWdtDgfT7um7EJ9dXNoHqLB7cTzphaubNaEFbFPXQ1siGmYKmvETlqe/ssktwyruGFLpXs1n0tJOEglGhx2qbYTs+omKWZdORl5WIWEXW3IXw/Dg5vVObrNpvG0eZKO8nSMc27+cyPySc+ZbNw=="
},
{
"username": "admin3",
"role": "admin",
"signature": "O6qx7/mUaVkYYVr1PW7l8JJko+Kh3e8zBIqdk3tAiNy+1rW+OsDtvYujhEU4aOFVLcrUFmyB/CX9OQmgJLgx/pyK+ZPEH+GoJGqk9YZ7X1nOXwZRP9g7hKV+7XCtg9TuDFtHYWDpBfz2jWiu2fXfX4/jTs4f2xIfFPIDKcSP8fhxjQ63xEcCf1jzGha6rDQMu4xUWWdtDgfT7um7EJ9dXNoHqLB7cTzphaubNaEFbFPXQ1siGmYKmvETlqe/ssktwyruGFLpXs1n0tJOEglGhx2qbYTs+omKWZdORl5WIWEXW3IXw/Dg5vVObrNpvG0eZKO8nSMc27+cyPySc+ZbNw=="
}
]
}
```
## Étape 3. Approuver le jeton sur le AWS CloudHSM cluster et exécuter une opération de gestion des utilisateurs
Une fois qu'un administrateur a obtenu les approbations/signatures nécessaires, comme indiqué dans la section précédente, il peut fournir ce jeton au cluster AWS CloudHSM avec l'une des opérations de gestion des utilisateurs suivantes :
+ **[créer](cloudhsm_cli-user-create.md)**
+ **[supprimer](cloudhsm_cli-user-delete.md)**
+ **[change-password](cloudhsm_cli-user-change-password.md)**
+ **[user change-mfa](cloudhsm_cli-user-change-mfa.md)**
Pour plus d'informations sur l'utilisation de ces commandes, consultez [Gestion des utilisateurs avec la CLI CloudHSM](manage-hsm-users-chsm-cli.md).
Au cours de la transaction, le jeton sera approuvé au sein du AWS CloudHSM cluster et exécutera l'opération de gestion des utilisateurs demandée. Le succès de l'opération de gestion des utilisateurs dépend à la fois d'un jeton de quorum approuvé valide et d'une opération de gestion des utilisateurs valide.
L’administrateur peut utiliser le jeton pour une seule opération. Lorsque cette opération réussit, le jeton n'est plus valide. Pour effectuer une autre opération de gestion des utilisateurs HSM, l'administrateur doit répéter le processus décrit ci-dessus. C’est-à-dire que l’administrateur doit générer un nouveau jeton de quorum, obtenir de nouvelles signatures des approbateurs et approuver et consommer le nouveau jeton sur le HSM avec l’opération de gestion des utilisateurs demandée.
**Note**
Le jeton de quorum n'est valide que tant que votre session de connexion en cours est ouverte. Si vous vous déconnectez de la CLI CloudHSM ou si le réseau se déconnecte, le jeton n'est plus valide. De même, un jeton autorisé ne peut être utilisé que dans la CLI CloudHSM. Il ne peut pas être utilisé pour s'authentifier dans une autre application.
**Example Création d'un nouvel utilisateur en tant qu'administrateur**
Dans l'exemple suivant, un administrateur connecté crée un utilisateur sur le HSM.
```
aws-cloudhsm > user create --username user1 --role crypto-user --approval /path/admin.token
Enter password:
Confirm password:
{
"error_code": 0,
"data": {
"username": "user1",
"role": "crypto-user"
}
}
```
L'administrateur saisit ensuite la commande **user list** pour confirmer la création du nouvel utilisateur :
```
aws-cloudhsm > user list
{
"error_code": 0,
"data": {
"users": [
{
"username": "admin",
"role": "admin",
"locked": "false",
"mfa": [],
"quorum": [
{
"strategy": "token-sign",
"status": "enabled"
}
],
"cluster-coverage": "full"
},
{
"username": "admin2",
"role": "admin",
"locked": "false",
"mfa": [],
"quorum": [
{
"strategy": "token-sign",
"status": "enabled"
}
],
"cluster-coverage": "full"
},
{
"username": "admin3",
"role": "admin",
"locked": "false",
"mfa": [],
"quorum": [
{
"strategy": "token-sign",
"status": "enabled"
}
],
"cluster-coverage": "full"
},
{
"username": "admin4",
"role": "admin",
"locked": "false",
"mfa": [],
"quorum": [
{
"strategy": "token-sign",
"status": "enabled"
}
],
"cluster-coverage": "full"
},
{
"username": "user1",
"role": "crypto-user",
"locked": "false",
"mfa": [],
"quorum": [],
"cluster-coverage": "full"
},
{
"username": "app_user",
"role": "internal(APPLIANCE_USER)",
"locked": "false",
"mfa": [],
"quorum": [],
"cluster-coverage": "full"
}
]
}
}
```
Si l’administrateur essaie d'effectuer une autre opération de gestion de l'utilisateur HSM, l'opération échoue avec une erreur d'authentification par quorum :
```
aws-cloudhsm > user delete --username user1 --role crypto-user
{
"error_code": 1,
"data": "Quorum approval is required for this operation"
}
```
Comme indiqué ci-dessous, la commande **quorum token-sign list** indique que l'administrateur n'a aucun jeton approuvé. Pour effectuer une autre opération de gestion des utilisateurs HSM, l'administrateur doit générer un nouveau jeton de quorum, obtenir de nouvelles signatures de la part des approbateurs et exécuter l'opération de gestion des utilisateurs souhaitée avec l'argument --approval pour fournir le jeton de quorum à approuver et à utiliser pendant l'exécution de l'opération de gestion des utilisateurs.
```
aws-cloudhsm > quorum token-sign list
{
"error_code": 0,
"data": {
"tokens": []
}
}
```
# Modifier la valeur minimale du quorum pour AWS CloudHSM utiliser la CLI CloudHSM
Après avoir [défini la valeur minimale du quorum](quorum-auth-chsm-cli-first-time.md#quorum-admin-set-quorum-minimum-value-chsm-cli) pour les administrateurs [CloudHSM](understanding-users.md#admin), vous devrez peut-être ajuster la valeur minimale du quorum. Le HSM permet de modifier la valeur minimale du quorum uniquement lorsque le nombre d'approbateurs atteint ou dépasse la valeur actuelle. Par exemple, avec un quorum minimum de deux (2), au moins deux (2) administrateurs doivent approuver les modifications.
**Note**
La valeur de quorum du service utilisateur doit toujours être inférieure ou égale à la valeur de quorum du service de quorum. Pour plus d'informations sur les noms de service, consultez[Noms et types AWS CloudHSM de service pris en charge pour l'authentification par quorum avec la CLI CloudHSM](quorum-auth-chsm-cli-service-names.md).
Pour obtenir l'approbation du quorum en vue de modifier la valeur minimale du quorum, vous avez besoin d'un *jeton de quorum* pour le **quorum service** utilisant la commande **quorum token-sign set-quorum-value**. Pour générer un jeton de quorum pour le **quorum service** utilisant la commande **quorum token-sign set-quorum-value**, le service de quorum doit être supérieur à un (1). Cela signifie que, avant de pouvoir modifier la valeur minimale du quorum pour le *service d’utilisateur*, vous devrez peut-être modifier la valeur minimale du quorum pour *service de quorum*.
**Étapes pour modifier la valeur minimale du quorum pour les administrateurs**
1. Démarrez le mode interactif de la CLI CloudHSM.
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/cloudhsm-cli interactive
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
```
------
1. À l'aide de la CLI CloudHSM, connectez-vous en tant qu'administrateur.
```
aws-cloudhsm > login --username --role admin
Enter password:
{
"error_code": 0,
"data": {
"username": "",
"role": "admin"
}
}
```
1. Vérifiez les valeurs minimales actuelles du quorum :
```
aws-cloudhsm > quorum token-sign list-quorum-values
```
1. Si la valeur minimale du quorum pour le service de quorum est inférieure à celle du service utilisateur, modifiez la valeur du *service de quorum* :
```
aws-cloudhsm > quorum token-sign set-quorum-value --service quorum --value <3>
```
1. [Générez un jeton de quorum](quorum-auth-chsm-cli-admin.md#quorum-admin-gen-token-chsm-cli) pour le service de quorum.
1. [Obtenir des approbations (signatures) de la part d'autres administrateurs](quorum-auth-chsm-cli-admin.md#quorum-admin-get-approval-signatures-chsm-cli).
1. [Approuvez le jeton sur le cluster CloudHSM et exécutez une opération de gestion des utilisateurs.](quorum-auth-chsm-cli-admin.md#quorum-admin-approve-token-chsm-cli) .
1. Modifiez la valeur minimale du quorum pour le *service utilisateur* :
```
aws-cloudhsm > quorum token-sign set-quorum-value
```
**Example Ajustement *des valeurs minimales du service de quorum***
1. **Vérifiez les valeurs actuelles**. L'exemple montre que la valeur minimale du quorum pour le *service utilisateur* est actuellement de deux (2).
```
aws-cloudhsm > quorum token-sign list-quorum-values
{
"error_code": 0,
"data": {
"user": 2,
"quorum": 1
}
}
```
1. **Modifiez la valeur du service de quorum**. Définissez la valeur minimale du *quorum pour le service* de quorum sur une valeur égale ou supérieure à la valeur du *service utilisateur*. Cet exemple définit la valeur minimale du *quorum pour le service* de quorum à deux (2), la même valeur que celle définie pour le *service utilisateur* dans l'exemple précédent.
```
aws-cloudhsm > quorum token-sign set-quorum-value --service quorum --value 2
{
"error_code": 0,
"data": "Set quorum value successful"
}
```
1. **Vérifiez les modifications**. Cet exemple montre que la valeur minimale du quorum est désormais de deux (2) pour le *service utilisateur* et le *service de quorum*.
```
aws-cloudhsm > quorum token-sign list-quorum-values
{
"error_code": 0,
"data": {
"user": 2,
"quorum": 2
}
}
```