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.
# 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=="
}
]
}
```