本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 使用 CloudHSM CLI 進行金鑰管理
<a name="manage-keys-chsm-cli"></a>

如果使用[最新的 SDK 版本系列](use-hsm.md)，請使用 [CloudHSM CLI](cloudhsm_cli.md) 來管理 AWS CloudHSM 叢集中的金鑰。如需詳細資訊，請參閱下列主題。
+ [使用信任的金鑰](manage-keys-cloudhsm-cli-trusted.md)說明如何使用 CloudHSM CLI 建立信任的金鑰來保護資料。
+ [產生金鑰](manage-keys-cloudhsm-cli-generate.md)包括建立金鑰的說明，包括對稱金鑰、RSA 金鑰和 EC 金鑰。
+ [刪除金鑰](manage-keys-cloudhsm-cli-delete.md)會說明金鑰擁有者如何刪除金鑰。
+ [共用和取消共用金鑰](manage-keys-cloudhsm-cli-share.md)詳細說明金鑰擁有者如何共用和取消共用金鑰。
+ [篩選金鑰](manage-keys-cloudhsm-cli-filtering.md)提供如何使用篩選條件尋找金鑰的準則。
+ [管理金鑰規定人數身分驗證 (M of N) ](key-quorum-auth-chsm-cli.md) 提供如何使用金鑰設定和使用規定人數身分驗證的指導方針。

# 使用 CloudHSM CLI 產生金鑰
<a name="manage-keys-cloudhsm-cli-generate"></a>

您必須先啟動 [CloudHSM CLI](cloudhsm_cli.md) 並以加密使用者 (CU) 身分登入，才能產生金鑰。若要在 HSM 中產生金鑰，請使用與您想產生之金鑰類型對應的命令。

**Topics**
+ [產生對稱金鑰](cloudhsm-cli-generate-symmetric-keys.md)
+ [產生非對稱金鑰](cloudhsm-cli-generate-asymmetric-keys.md)
+ [相關主題](cloudhsm-cli-generate-keys-seealso.md)

# 使用 CloudHSM CLI 產生對稱金鑰
<a name="cloudhsm-cli-generate-symmetric-keys"></a>

使用 中列出的命令**[CloudHSM CLI 中的產生對稱類別](cloudhsm_cli-key-generate-symmetric.md)**來產生 的對稱金鑰 AWS CloudHSM。若要查看所有可用的選項，請使用 **help key generate-symmetric** 命令。

## 產生 AES 金鑰
<a name="cloudhsm-cli-generate-symmetric-aes"></a>

使用 **key generate-symmetric aes** 命令產生 AES 金鑰。若要查看所有可用的選項，請使用 **help key generate-symmetric aes** 命令。

**Example**  
下列範例會產生 32 位元組 AES 金鑰。  

```
aws-cloudhsm > key generate-symmetric aes \
    --label aes-example \
    --key-length-bytes 32
```

### 引數
<a name="cloudhsm-cli-generate-symmetric-aes-args"></a>

***<LABEL>***  
指使用者定義的 AES 金鑰標籤。  
必要：是

***<KEY-LENGTH-BYTES>***  
指金鑰長度 (以位元組為單位)。  

有效值：
+ 16、24 和 32
必要：是

***<KEY\$1ATTRIBUTES>***  
指定一個空格分隔的金鑰屬性清單，對產生的 AES 金鑰進行設定，格式為 `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (例如，`sign=true`)   
如需支援的 AWS CloudHSM 金鑰屬性清單，請參閱 [CloudHSM CLI 的金鑰屬性](cloudhsm_cli-key-attributes.md)。  
必要：否

***<SESSION>***  
建立只在目前工作階段中存在的金鑰。工作階段結束後，金鑰無法復原。當您僅短暫需要金鑰 (例如，加密後快速解密另一個金鑰的包裝金鑰) 時，請使用此參數。請勿使用工作階段金鑰來加密工作階段結束後可能需要解密的資料。  
如要將工作階段金鑰更改為永久 (權杖) 金鑰，請使用[金鑰設定屬性](cloudhsm_cli-key-set-attribute.md)。  
根據預設，產生的金鑰是持久性/權杖金鑰。使用 <SESSION> 會變更此項，確保使用此引數產生的金鑰是工作階段/暫時性的  
必要：否

### 產生一般私密金鑰
<a name="cloudhsm-cli-generate-symmetric-secret"></a>

使用 **key generate-symmetric generic-secret** 命令產生一般私密金鑰。若要查看所有可用的選項，請使用 **help key generate-symmetric generic-secret** 命令。

**Example**  
下列範例會產生 32 位元組的一般私密金鑰。  

```
aws-cloudhsm > key generate-symmetric generic-secret \
    --label generic-secret-example \
    --key-length-bytes 32
```

#### 引數
<a name="cloudhsm-cli-generate-symmetric-secret-args"></a>

***<LABEL>***  
為一般私密金鑰指定使用者定義的標籤。  
必要：是

***<KEY-LENGTH-BYTES>***  
指金鑰長度 (以位元組為單位)。  

有效值：
+ 1 到 800
必要：是

***<KEY\$1ATTRIBUTES>***  
指一個空格分隔的金鑰屬性清單，以 `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (例如，`sign=true`) 的形式為產生的一般私密金鑰設定  
如需支援的 AWS CloudHSM 金鑰屬性清單，請參閱 [CloudHSM CLI 的金鑰屬性](cloudhsm_cli-key-attributes.md)。  
必要：否

***<SESSION>***  
建立只在目前工作階段中存在的金鑰。工作階段結束後，金鑰無法復原。當您僅短暫需要金鑰 (例如，加密後快速解密另一個金鑰的包裝金鑰) 時，請使用此參數。請勿使用工作階段金鑰來加密工作階段結束後可能需要解密的資料。  
如要將工作階段金鑰更改為永久 (權杖) 金鑰，請使用[金鑰設定屬性](cloudhsm_cli-key-set-attribute.md)。  
根據預設，產生的金鑰是持久性/權杖金鑰。使用 <SESSION> 會變更此項，確保使用此引數產生的金鑰是工作階段/暫時性的  
必要：否

# 使用 CloudHSM CLI 產生非對稱金鑰
<a name="cloudhsm-cli-generate-asymmetric-keys"></a>

使用 中列出的命令**[CloudHSM CLI 中的 generate-asymmetric-pair 類別](cloudhsm_cli-key-generate-asymmetric-pair.md)**來產生 AWS CloudHSM 叢集的非對稱金鑰對。

## 產生 RSA 金鑰
<a name="cloudhsm-cli-generate-asymmetric-rsa"></a>

使用 **key generate-asymmetric-pair rsa** 命令來產生 RSA 金鑰對。若要查看所有可用的選項，請使用 **help key generate-asymmetric-pair rsa** 命令。

**Example**  
以下範例會產生 RSA 2048 位元金鑰對。  

```
aws-cloudhsm > key generate-asymmetric-pair rsa \
    --public-exponent 65537 \
    --modulus-size-bits 2048 \
    --public-label rsa-public-example \
    --private-label rsa-private-example
```

### 引數
<a name="cloudhsm-cli-generate-asymmetric-rsa-args"></a>

***<PUBLIC\$1LABEL>***  
指使用者定義的公有金鑰標籤。  
必要：是

***<PRIVATE\$1LABEL>***  
指使用者定義的私有金鑰標籤。  
必要：是

***<MODULUS\$1SIZE\$1BITS>***  
指模數的長度 (以位元為單位)。最小值為 2048。  
必要：是

***<PUBLIC\$1EXPONENT>***  
指公有指數。值必須為大於或等於 65537 的奇數。  
必要：是

***<PUBLIC\$1KEY\$1ATTRIBUTES>***  
指以空格分隔的金鑰屬性清單，以 `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (例如，`sign=true`) 的形式為產生的 RSA 公有金鑰設定。  
如需支援的 AWS CloudHSM 金鑰屬性清單，請參閱 [CloudHSM CLI 的金鑰屬性](cloudhsm_cli-key-attributes.md)。  
必要：否

***<SESSION>***  
建立只在目前工作階段中存在的金鑰。工作階段結束後，金鑰無法復原。當您僅短暫需要金鑰 (例如，加密後快速解密另一個金鑰的包裝金鑰) 時，請使用此參數。請勿使用工作階段金鑰來加密工作階段結束後可能需要解密的資料。  
如要將工作階段金鑰更改為永久 (權杖) 金鑰，請使用[金鑰設定屬性](cloudhsm_cli-key-set-attribute.md)。  
根據預設，產生的金鑰是持久性/權杖金鑰。使用 <SESSION> 會變更此項，確保使用此引數產生的金鑰是工作階段/暫時性的  
必要：否

### 產生 EC (橢圓曲線密碼編譯) 金鑰對
<a name="cloudhsm-cli-generate-asymmetric-ec"></a>

使用 **key generate-asymmetric-pair ec** 命令來產生金鑰對。若要查看所有可用的選項，包括支援的橢圓曲線清單，請使用 **help key generate-asymmetric-pair ec** 命令。

**Example**  
下列範例會使用 Secp384r1 橢圓曲線產生 EC 金鑰對。  

```
aws-cloudhsm > key generate-asymmetric-pair ec \
    --curve secp384r1 \
    --public-label ec-public-example \
    --private-label ec-private-example
```

#### 引數
<a name="cloudhsm-cli-generate-asymmetric-ec-args"></a>

***<PUBLIC\$1LABEL>***  
指使用者定義的公有金鑰標籤。用戶端 SDK `label` 5.11 和更新版本允許的大小上限為 127 個字元。用戶端 SDK 5.10 和以前的 限制為 126 個字元。  
必要：是

***<PRIVATE\$1LABEL>***  
指使用者定義的私有金鑰標籤。用戶端 SDK `label` 5.11 和更新版本允許的大小上限為 127 個字元。用戶端 SDK 5.10 和以前的 限制為 126 個字元。  
必要：是

***<CURVE>***  
指橢圓曲線的識別符。  

有效值：
+ prime256v1
+ secp256r1
+ secp224r1
+ secp384r1
+ secp256k1
+ secp521r1
+ ed25519 （僅在非 FIPS 模式下的 hsm2m.medium 執行個體上支援）
必要：是

***<PUBLIC\$1KEY\$1ATTRIBUTES>***  
指以空格分隔的金鑰屬性清單，以 `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (例如，`verify=true`) 的形式為產生的 EC 公開金鑰設定。  
如需支援的 AWS CloudHSM 金鑰屬性清單，請參閱 [CloudHSM CLI 的金鑰屬性](cloudhsm_cli-key-attributes.md)。  
必要：否

***<PRIVATE\$1KEY\$1ATTRIBUTES>***  
指以空格分隔的金鑰屬性清單，以 `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (例如，`sign=true`) 的形式為產生的 EC 私有金鑰設定。  
如需支援的 AWS CloudHSM 金鑰屬性清單，請參閱 [CloudHSM CLI 的金鑰屬性](cloudhsm_cli-key-attributes.md)。  
必要：否

***<SESSION>***  
建立只在目前工作階段中存在的金鑰。工作階段結束後，金鑰無法復原。當您僅短暫需要金鑰 (例如，加密後快速解密另一個金鑰的包裝金鑰) 時，請使用此參數。請勿使用工作階段金鑰來加密工作階段結束後可能需要解密的資料。  
如要將工作階段金鑰更改為永久 (權杖) 金鑰，請使用[金鑰設定屬性](cloudhsm_cli-key-set-attribute.md)。  
根據預設，產生的金鑰是持久性 (權杖) 金鑰。在 <SESSION> 傳遞會變更此情況，確保使用此參數生成的金鑰是工作階段 (臨時) 金鑰。  
必要：否

# AWS CloudHSM 金鑰相關主題
<a name="cloudhsm-cli-generate-keys-seealso"></a>

如需 中金鑰的其他資訊，請參閱下列各節 AWS CloudHSM。
+ [CloudHSM CLI 的金鑰屬性](cloudhsm_cli-key-attributes.md)
+ [CloudHSM CLI 中的 generate-asymmetric-pair 類別](cloudhsm_cli-key-generate-asymmetric-pair.md)
+ [CloudHSM CLI 中的產生對稱類別](cloudhsm_cli-key-generate-symmetric.md)

# 使用 CloudHSM CLI 刪除金鑰
<a name="manage-keys-cloudhsm-cli-delete"></a>

使用本主題中的範例，透過 [CloudHSM CLI](cloudhsm_cli.md) 刪除金鑰。只有金鑰擁有者可以刪除金鑰。

**Topics**
+ [範例：刪除金鑰](#cloudhsm-cli-delete-keys-example)
+ [相關主題](#cloudhsm-cli-delete-keys-seealso)

## 範例：刪除金鑰
<a name="cloudhsm-cli-delete-keys-example"></a>

1. 執行 **key list** 命令以識別您要刪除的金鑰：

   ```
   aws-cloudhsm > key list --filter attr.label="my_key_to_delete" --verbose
   {
     "error_code": 0,
     "data": {
       "matched_keys": [
         {
           "key-reference": "0x0000000000540011",
           "key-info": {
             "key-owners": [
               {
                 "username": "my_crypto_user",
                 "key-coverage": "full"
               }
             ],
             "shared-users": [],
           "key-quorum-values": {
             "manage-key-quorum-value": 0,
             "use-key-quorum-value": 0
           },
             "cluster-coverage": "full"
           },
           "attributes": {
             "key-type": "rsa",
             "label": "my_key_to_delete",
             "id": "",
             "check-value": "0x29bbd1",
             "class": "private-key",
             "encrypt": false,
             "decrypt": true,
             "token": true,
             "always-sensitive": true,
             "derive": false,
             "destroyable": true,
             "extractable": true,
             "local": true,
             "modifiable": true,
             "never-extractable": false,
             "private": true,
             "sensitive": true,
             "sign": true,
             "trusted": false,
             "unwrap": true,
             "verify": false,
             "wrap": false,
             "wrap-with-trusted": false,
             "key-length-bytes": 1217,
             "public-exponent": "0x010001",
             "modulus": "0x8b3a7c20618e8be08220ed8ab2c8550b65fc1aad8d4cf04fbf2be685f97eeb78fcbbad9b02cd91a3b15e990c2a7c7cdeff0b730576c6c5630a8509a778a96acbc7c36931e9a86e8956fbd07f0863404ce06c8bd68256784be9f5b258a35e229ce7f630228b9323b4e1f14a0384ead90bdf07dc762f710fc5663887d0787ad98d64bbe303134f545acb2ab194fee6edaecd4dd5cf31ff7f7491e37d7a850ab23247414b42d9abdd5de89b78fd464560df29a90607e9d462f21b22365da419021fb9f28ea7e6fdb1f40bf83aaf1636fba5e475ad19889cfe3f28186a969b4826c39466c0855c974d1fb723d111e4a32ab6e32b3129bc95c9206fced160015d8b2f",
             "modulus-size-bits": 2048
           }
         }
       ],
       "total_key_count": 1,
       "returned_key_count": 1
     }
   ```

1. 識別金鑰後，執行具有金鑰的唯一 `label` 屬性的 **key delete** 以刪除金鑰：

   ```
   aws-cloudhsm > key delete --filter attr.label="my_key_to_delete"
   {
     "error_code": 0,
     "data": {
       "message": "Key deleted successfully"
     }
   }
   ```

1. 執行具有金鑰的唯一 `label` 屬性的 **key list** 命令並確認金鑰已被刪除。如下列範例所示，HSM 叢集中沒有含標籤 `my_key_to_delete` 的金鑰：

   ```
   aws-cloudhsm > key list --filter attr.label="my_key_to_delete"
   {
     "error_code": 0,
     "data": {
       "matched_keys": [],
       "total_key_count": 0,
       "returned_key_count": 0
     }
   }
   ```

## 相關主題
<a name="cloudhsm-cli-delete-keys-seealso"></a>
+ [CloudHSM CLI 的金鑰屬性](cloudhsm_cli-key-attributes.md)
+ [使用 CloudHSM CLI 刪除金鑰](cloudhsm_cli-key-delete.md)

# 使用 CloudHSM CLI 共用和取消共用金鑰
<a name="manage-keys-cloudhsm-cli-share"></a>

使用本主題中的命令在 [CloudHSM CLI](cloudhsm_cli.md) 中共用和取消共用金鑰。在 中 AWS CloudHSM，建立金鑰的加密使用者 (CU) 擁有金鑰。擁有者可以使用 **key share** 和 **key unshare** 命令來與其他 CU 共用和取消共用金鑰。共用金鑰的使用者可以在密碼編譯操作中使用此金鑰，但無法匯出金鑰、刪除金鑰，或再與其他使用者共用。

共用金鑰前，請以擁有金鑰的加密使用者 (CU) 身分登入 HSM。

**Topics**
+ [範例：共用和停止共用金鑰](#w2aac15c21c11b9)
+ [相關主題](#cloudhsm-cli-share-keys-seealso)

## 範例：共用和停止共用金鑰
<a name="w2aac15c21c11b9"></a>

**Example**  
以下示例顯示如何與加密使用者 (CU) `alice` 共用和取消共用金鑰。除 **key share** 和 **key unshare** 命令外，共用和取消共用命令還需要使用 [CloudHSM CLI 金鑰篩選條件](manage-keys-cloudhsm-cli-filtering.md)的特定金鑰以及要與之共用或取消共用金鑰的使用者的特定使用者名稱。  

1. 先用篩選條件執行 **key list** 命令以傳回特定金鑰並查看已與誰共用金鑰。

   ```
   aws-cloudhsm > key list --filter attr.label="rsa_key_to_share" --verbose
   {
     "error_code": 0,
     "data": {
       "matched_keys": [
         {
           "key-reference": "0x00000000001c0686",
           "key-info": {
             "key-owners": [
               {
                 "username": "cu3",
                 "key-coverage": "full"
               }
             ],
             "shared-users": [
               {
                 "username": "cu2",
                 "key-coverage": "full"
               },
               {
                 "username": "cu1",
                 "key-coverage": "full"
               },
               {
                 "username": "cu4",
                 "key-coverage": "full"
               },
               {
                 "username": "cu5",
                 "key-coverage": "full"
               },
               {
                 "username": "cu6",
                 "key-coverage": "full"
               },
               {
                 "username": "cu7",
                 "key-coverage": "full"
               },
             ],
             "key-quorum-values": {
               "manage-key-quorum-value": 0,
               "use-key-quorum-value": 0
             },
             "cluster-coverage": "full"
           },
           "attributes": {
             "key-type": "rsa",
             "label": "rsa_key_to_share",
             "id": "",
             "check-value": "0xae8ff0",
             "class": "private-key",
             "encrypt": false,
             "decrypt": true,
             "token": true,
             "always-sensitive": true,
             "derive": false,
             "destroyable": true,
             "extractable": true,
             "local": true,
             "modifiable": true,
             "never-extractable": false,
             "private": true,
             "sensitive": true,
             "sign": true,
             "trusted": false,
             "unwrap": true,
             "verify": false,
             "wrap": false,
             "wrap-with-trusted": false,
             "key-length-bytes": 1219,
             "public-exponent": "0x010001",
             "modulus": "0xa8855cba933cec0c21a4df0450ec31675c024f3e65b2b215a53d2bda6dcd191f75729150b59b4d86df58254c8f518f7d000cc04d8e958e7502c7c33098e28da4d94378ef34fb57d1cc7e042d9119bd79be0df728421a980a397095157da24cf3cc2b6dab12225d33fdca11f0c6ed1a5127f12488cda9a556814b39b06cd8373ff5d371db2212887853621b8510faa7b0779fbdec447e1f1d19f343acb02b22526487a31f6c704f8f003cb4f7013136f90cc17c2c20e414dc1fc7bcfb392d59c767900319679fc3307388633485657ce2e1a3deab0f985b0747ef4ed339de78147d1985d14fdd8634219321e49e3f5715e79c298f18658504bab04086bfbdcd3b",
             "modulus-size-bits": 2048
           }
         }
       ],
       "total_key_count": 1,
       "returned_key_count": 1
     }
   }
   ```

1. 檢視 `shared-users` 輸出以識別金鑰目前與誰共用。

1. 如要與加密使用者 (CU) `alice` 共享此金鑰，請輸入以下命令：

   ```
   aws-cloudhsm > key share --filter attr.label="rsa_key_to_share" attr.class=private-key --username alice --role crypto-user
   {
     "error_code": 0,
     "data": {
       "message": "Key shared successfully"
     }
   }
   ```

   請注意，除 **key share** 命令外，此命令還使用金鑰的唯一標籤以及與其共用金鑰的使用者名稱。

1. 執行 **key list** 命令以確認金鑰已與 `alice` 共用：

   ```
   aws-cloudhsm > key list --filter attr.label="rsa_key_to_share" --verbose
   {
     "error_code": 0,
     "data": {
       "matched_keys": [
         {
           "key-reference": "0x00000000001c0686",
           "key-info": {
             "key-owners": [
               {
                 "username": "cu3",
                 "key-coverage": "full"
               }
             ],
             "shared-users": [
               {
                 "username": "cu2",
                 "key-coverage": "full"
               },
               {
                 "username": "cu1",
                 "key-coverage": "full"
               },
               {
                 "username": "cu4",
                 "key-coverage": "full"
               },
               {
                 "username": "cu5",
                 "key-coverage": "full"
               },
               {
                 "username": "cu6",
                 "key-coverage": "full"
               },
               {
                 "username": "cu7",
                 "key-coverage": "full"
               },
               {
                 "username": "alice",
                 "key-coverage": "full"
               }
             ],
             "key-quorum-values": {
               "manage-key-quorum-value": 0,
               "use-key-quorum-value": 0
             },
             "cluster-coverage": "full"
           },
           "attributes": {
             "key-type": "rsa",
             "label": "rsa_key_to_share",
             "id": "",
             "check-value": "0xae8ff0",
             "class": "private-key",
             "encrypt": false,
             "decrypt": true,
             "token": true,
             "always-sensitive": true,
             "derive": false,
             "destroyable": true,
             "extractable": true,
             "local": true,
             "modifiable": true,
             "never-extractable": false,
             "private": true,
             "sensitive": true,
             "sign": true,
             "trusted": false,
             "unwrap": true,
             "verify": false,
             "wrap": false,
             "wrap-with-trusted": false,
             "key-length-bytes": 1219,
             "public-exponent": "0x010001",
             "modulus": "0xa8855cba933cec0c21a4df0450ec31675c024f3e65b2b215a53d2bda6dcd191f75729150b59b4d86df58254c8f518f7d000cc04d8e958e7502c7c33098e28da4d94378ef34fb57d1cc7e042d9119bd79be0df728421a980a397095157da24cf3cc2b6dab12225d33fdca11f0c6ed1a5127f12488cda9a556814b39b06cd8373ff5d371db2212887853621b8510faa7b0779fbdec447e1f1d19f343acb02b22526487a31f6c704f8f003cb4f7013136f90cc17c2c20e414dc1fc7bcfb392d59c767900319679fc3307388633485657ce2e1a3deab0f985b0747ef4ed339de78147d1985d14fdd8634219321e49e3f5715e79c298f18658504bab04086bfbdcd3b",
             "modulus-size-bits": 2048
           }
         }
       ],
       "total_key_count": 1,
       "returned_key_count": 1
     }
   }
   ```

1. 若要與 `alice` 取消共用相同的金鑰，請執行下列 **unshare** 命令：

   ```
   aws-cloudhsm > key unshare --filter attr.label="rsa_key_to_share" attr.class=private-key --username alice --role crypto-user
   {
     "error_code": 0,
     "data": {
       "message": "Key unshared successfully"
     }
   }
   ```

   請注意，除 **key unshare** 命令外，此命令還使用金鑰的唯一標籤以及與其共用金鑰的使用者名稱。

1. 再次執行 **key list** 命令並確認是否未與加密使用者 `alice` 共用金鑰：

   ```
   aws-cloudhsm > key list --filter attr.label="rsa_key_to_share" --verbose
   {
     "error_code": 0,
     "data": {
       "matched_keys": [
         {
           "key-reference": "0x00000000001c0686",
           "key-info": {
             "key-owners": [
               {
                 "username": "cu3",
                 "key-coverage": "full"
               }
             ],
             "shared-users": [
               {
                 "username": "cu2",
                 "key-coverage": "full"
               },
               {
                 "username": "cu1",
                 "key-coverage": "full"
               },
               {
                 "username": "cu4",
                 "key-coverage": "full"
               },
               {
                 "username": "cu5",
                 "key-coverage": "full"
               },
               {
                 "username": "cu6",
                 "key-coverage": "full"
               },
               {
                 "username": "cu7",
                 "key-coverage": "full"
               },
             ],
             "key-quorum-values": {
               "manage-key-quorum-value": 0,
               "use-key-quorum-value": 0
             },
             "cluster-coverage": "full"
           },
           "attributes": {
             "key-type": "rsa",
             "label": "rsa_key_to_share",
             "id": "",
             "check-value": "0xae8ff0",
             "class": "private-key",
             "encrypt": false,
             "decrypt": true,
             "token": true,
             "always-sensitive": true,
             "derive": false,
             "destroyable": true,
             "extractable": true,
             "local": true,
             "modifiable": true,
             "never-extractable": false,
             "private": true,
             "sensitive": true,
             "sign": true,
             "trusted": false,
             "unwrap": true,
             "verify": false,
             "wrap": false,
             "wrap-with-trusted": false,
             "key-length-bytes": 1219,
             "public-exponent": "0x010001",
             "modulus": "0xa8855cba933cec0c21a4df0450ec31675c024f3e65b2b215a53d2bda6dcd191f75729150b59b4d86df58254c8f518f7d000cc04d8e958e7502c7c33098e28da4d94378ef34fb57d1cc7e042d9119bd79be0df728421a980a397095157da24cf3cc2b6dab12225d33fdca11f0c6ed1a5127f12488cda9a556814b39b06cd8373ff5d371db2212887853621b8510faa7b0779fbdec447e1f1d19f343acb02b22526487a31f6c704f8f003cb4f7013136f90cc17c2c20e414dc1fc7bcfb392d59c767900319679fc3307388633485657ce2e1a3deab0f985b0747ef4ed339de78147d1985d14fdd8634219321e49e3f5715e79c298f18658504bab04086bfbdcd3b",
             "modulus-size-bits": 2048
           }
         }
       ],
       "total_key_count": 1,
       "returned_key_count": 1
     }
   }
   ```

## 相關主題
<a name="cloudhsm-cli-share-keys-seealso"></a>
+ [CloudHSM CLI 的金鑰屬性](cloudhsm_cli-key-attributes.md)
+ [使用 CloudHSM CLI 共用金鑰](cloudhsm_cli-key-share.md)
+ [使用 CloudHSM CLI 取消共用金鑰](cloudhsm_cli-key-unshare.md)
+ [使用 CloudHSM CLI 篩選金鑰](manage-keys-cloudhsm-cli-filtering.md)

# 使用 CloudHSM CLI 篩選金鑰
<a name="manage-keys-cloudhsm-cli-filtering"></a>

使用下列主要命令，將標準化金鑰篩選機制用於 [CloudHSM CLI](cloudhsm_cli.md)。
+ **key list**
+ **key delete**
+ **key share**
+ **key unshare**
+ **key set-attribute**

若要使用 CloudHSM CLI 選取和/或篩選金鑰，主要命令會根據 [CloudHSM CLI 的金鑰屬性](cloudhsm_cli-key-attributes.md) 使用標準化篩選機制。您可以使用可以識別單一金鑰或多個金鑰的一或多個 AWS CloudHSM 屬性，在金鑰命令中指定金鑰或一組金鑰。金鑰篩選機制只會在目前登入使用者擁有和共用的金鑰，以及 AWS CloudHSM 叢集中的所有公有金鑰上運作。

**Topics**
+ [要求](#chsm-cli-filtering-requirements)
+ [篩選以尋找單一金鑰](#chsm-cli-filtering-examples)
+ [篩選錯誤](#manage-keys-chsm-cli-filter-error)
+ [相關主題](#manage-keys-chsm-cli-filtering-seealso)

## 要求
<a name="chsm-cli-filtering-requirements"></a>

若要篩選金鑰，您必須以加密使用者 (CU) 的身分登入。

## 篩選以尋找單一金鑰
<a name="chsm-cli-filtering-examples"></a>

請注意，在下面的範例中，用作篩選條件的每個屬性都必須以 `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` 的形式寫入。例如，如果您想透過標籤屬性進行篩選，您會寫入 `attr.label=my_label`。

**Example 使用單個屬性來尋找單一金鑰**  
此範例示範如何篩選為僅使用單一識別屬性的單一唯一金鑰。  

```
aws-cloudhsm > key list --filter attr.label="my_unique_key_label" --verbose
{
  "error_code": 0,
  "data": {
    "matched_keys": [
      {
        "key-reference": "0x00000000001c0686",
        "key-info": {
          "key-owners": [
            {
              "username": "cu1",
              "key-coverage": "full"
            }
          ],
          "shared-users": [
            {
              "username": "alice",
              "key-coverage": "full"
            }
          ],
          "key-quorum-values": {
            "manage-key-quorum-value": 0,
            "use-key-quorum-value": 0
          },
          "cluster-coverage": "full"
        },
        "attributes": {
          "key-type": "rsa",
          "label": "my_unique_key_label",
          "id": "",
          "check-value": "0xae8ff0",
          "class": "private-key",
          "encrypt": false,
          "decrypt": true,
          "token": true,
          "always-sensitive": true,
          "derive": false,
          "destroyable": true,
          "extractable": true,
          "local": true,
          "modifiable": true,
          "never-extractable": false,
          "private": true,
          "sensitive": true,
          "sign": true,
          "trusted": false,
          "unwrap": true,
          "verify": false,
          "wrap": false,
          "wrap-with-trusted": false,
          "key-length-bytes": 1219,
          "public-exponent": "0x010001",
          "modulus": "0xa8855cba933cec0c21a4df0450ec31675c024f3e65b2b215a53d2bda6dcd191f75729150b59b4d86df58254c8f518f7d000cc04d8e958e7502c7c33098e28da4d94378ef34fb57d1cc7e042d9119bd79be0df728421a980a397095157da24cf3cc2b6dab12225d33fdca11f0c6ed1a5127f12488cda9a556814b39b06cd8373ff5d371db2212887853621b8510faa7b0779fbdec447e1f1d19f343acb02b22526487a31f6c704f8f003cb4f7013136f90cc17c2c20e414dc1fc7bcfb392d59c767900319679fc3307388633485657ce2e1a3deab0f985b0747ef4ed339de78147d1985d14fdd8634219321e49e3f5715e79c298f18658504bab04086bfbdcd3b",
          "modulus-size-bits": 2048
        }
      }
    ],
    "total_key_count": 1,
    "returned_key_count": 1
  }
}
```

**Example 使用多個屬性尋找單一金鑰**  
以下範例示範如何使用多個金鑰屬性尋找單一金鑰。  

```
aws-cloudhsm > key list --filter attr.key-type=rsa attr.class=private-key attr.check-value=0x29bbd1 --verbose
{
  "error_code": 0,
  "data": {
    "matched_keys": [
      {
        "key-reference": "0x0000000000540011",
        "key-info": {
          "key-owners": [
            {
              "username": "cu3",
              "key-coverage": "full"
            }
          ],
          "shared-users": [
            {
              "username": "cu2",
              "key-coverage": "full"
            }
          ],
          "key-quorum-values": {
            "manage-key-quorum-value": 0,
            "use-key-quorum-value": 0
          },
          "cluster-coverage": "full"
        },
        "attributes": {
          "key-type": "rsa",
          "label": "my_crypto_user",
          "id": "",
          "check-value": "0x29bbd1",
          "class": "my_test_key",
          "encrypt": false,
          "decrypt": true,
          "token": true,
          "always-sensitive": true,
          "derive": false,
          "destroyable": true,
          "extractable": true,
          "local": true,
          "modifiable": true,
          "never-extractable": false,
          "private": true,
          "sensitive": true,
          "sign": true,
          "trusted": false,
          "unwrap": true,
          "verify": false,
          "wrap": false,
          "wrap-with-trusted": false,
          "key-length-bytes": 1217,
          "public-exponent": "0x010001",
          "modulus": "0x8b3a7c20618e8be08220ed8ab2c8550b65fc1aad8d4cf04fbf2be685f97eeb78fcbbad9b02cd91a3b15e990c2a7c7cdeff0b730576c6c5630a8509a778a96acbc7c36931e9a86e8956fbd07f0863404ce06c8bd68256784be9f5b258a35e229ce7f630228b9323b4e1f14a0384ead90bdf07dc762f710fc5663887d0787ad98d64bbe303134f545acb2ab194fee6edaecd4dd5cf31ff7f7491e37d7a850ab23247414b42d9abdd5de89b78fd464560df29a90607e9d462f21b22365da419021fb9f28ea7e6fdb1f40bf83aaf1636fba5e475ad19889cfe3f28186a969b4826c39466c0855c974d1fb723d111e4a32ab6e32b3129bc95c9206fced160015d8b2f",
          "modulus-size-bits": 2048
        }
      }
    ],
    "total_key_count": 1,
    "returned_key_count": 1
  }
}
```

**Example 篩選以尋找一組金鑰**  
以下範例示範如何篩選以尋找一組私有 rsa 金鑰。  

```
aws-cloudhsm > key list --filter attr.key-type=rsa attr.class=private-key --verbose
{
  "error_code": 0,
  "data": {
    "matched_keys": [
      {
        "key-reference": "0x00000000001c0686",
        "key-info": {
          "key-owners": [
            {
              "username": "my_crypto_user",
              "key-coverage": "full"
            }
          ],
          "shared-users": [
            {
              "username": "cu2",
              "key-coverage": "full"
            },
            {
              "username": "cu1",
              "key-coverage": "full"
            },
          ],
          "key-quorum-values": {
            "manage-key-quorum-value": 0,
            "use-key-quorum-value": 0
          },
          "cluster-coverage": "full"
        },
        "attributes": {
          "key-type": "rsa",
          "label": "rsa_key_to_share",
          "id": "",
          "check-value": "0xae8ff0",
          "class": "private-key",
          "encrypt": false,
          "decrypt": true,
          "token": true,
          "always-sensitive": true,
          "derive": false,
          "destroyable": true,
          "extractable": true,
          "local": true,
          "modifiable": true,
          "never-extractable": false,
          "private": true,
          "sensitive": true,
          "sign": true,
          "trusted": false,
          "unwrap": true,
          "verify": false,
          "wrap": false,
          "wrap-with-trusted": false,
          "key-length-bytes": 1219,
          "public-exponent": "0x010001",
          "modulus": "0xa8855cba933cec0c21a4df0450ec31675c024f3e65b2b215a53d2bda6dcd191f75729150b59b4d86df58254c8f518f7d000cc04d8e958e7502c7c33098e28da4d94378ef34fb57d1cc7e042d9119bd79be0df728421a980a397095157da24cf3cc2b6dab12225d33fdca11f0c6ed1a5127f12488cda9a556814b39b06cd8373ff5d371db2212887853621b8510faa7b0779fbdec447e1f1d19f343acb02b22526487a31f6c704f8f003cb4f7013136f90cc17c2c20e414dc1fc7bcfb392d59c767900319679fc3307388633485657ce2e1a3deab0f985b0747ef4ed339de78147d1985d14fdd8634219321e49e3f5715e79c298f18658504bab04086bfbdcd3b",
          "modulus-size-bits": 2048
        }
      },
      {
        "key-reference": "0x0000000000540011",
        "key-info": {
          "key-owners": [
            {
              "username": "my_crypto_user",
              "key-coverage": "full"
            }
          ],
          "shared-users": [
            {
              "username": "cu2",
              "key-coverage": "full"
            }
          ],
          "key-quorum-values": {
            "manage-key-quorum-value": 0,
            "use-key-quorum-value": 0
          },
          "cluster-coverage": "full"
        },
        "attributes": {
          "key-type": "rsa",
          "label": "my_test_key",
          "id": "",
          "check-value": "0x29bbd1",
          "class": "private-key",
          "encrypt": false,
          "decrypt": true,
          "token": true,
          "always-sensitive": true,
          "derive": false,
          "destroyable": true,
          "extractable": true,
          "local": true,
          "modifiable": true,
          "never-extractable": false,
          "private": true,
          "sensitive": true,
          "sign": true,
          "trusted": false,
          "unwrap": true,
          "verify": false,
          "wrap": false,
          "wrap-with-trusted": false,
          "key-length-bytes": 1217,
          "public-exponent": "0x010001",
          "modulus": "0x8b3a7c20618e8be08220ed8ab2c8550b65fc1aad8d4cf04fbf2be685f97eeb78fcbbad9b02cd91a3b15e990c2a7c7cdeff0b730576c6c5630a8509a778a96acbc7c36931e9a86e8956fbd07f0863404ce06c8bd68256784be9f5b258a35e229ce7f630228b9323b4e1f14a0384ead90bdf07dc762f710fc5663887d0787ad98d64bbe303134f545acb2ab194fee6edaecd4dd5cf31ff7f7491e37d7a850ab23247414b42d9abdd5de89b78fd464560df29a90607e9d462f21b22365da419021fb9f28ea7e6fdb1f40bf83aaf1636fba5e475ad19889cfe3f28186a969b4826c39466c0855c974d1fb723d111e4a32ab6e32b3129bc95c9206fced160015d8b2f",
          "modulus-size-bits": 2048
        }
      }
    ],
    "total_key_count": 2,
    "returned_key_count": 2
  }
}
```

## 篩選錯誤
<a name="manage-keys-chsm-cli-filter-error"></a>

某些金鑰作業一次只能在單一金鑰上執行。對於這些操作，CloudHSM CLI 會在篩選條件未充分細化且多個金鑰符合準則時報錯。一個此類範例與金鑰刪除如下所示。

**Example 匹配太多金鑰時篩選錯誤**  

```
aws-cloudhsm > key delete --filter attr.key-type=rsa
{
  "error_code": 1,
  "data": "Key selection criteria matched 48 keys. Refine selection criteria to select a single key."
}
```

## 相關主題
<a name="manage-keys-chsm-cli-filtering-seealso"></a>
+ [CloudHSM CLI 的金鑰屬性](cloudhsm_cli-key-attributes.md)

# 使用 CloudHSM CLI 將金鑰標記為信任
<a name="manage-keys-cloudhsm-cli-trusted"></a>

本節中的內容提供如何使用 CloudHSM CLI 將金鑰標記為可信任的說明。

1. 使用 [CloudHSM CLI **login** 命令](cloudhsm_cli-login.md)，以加密使用者 (CU) 身分登入。

1. 使用 **key list** 命令來識別您要標記為可信任的金鑰的金鑰參照。下列範例會列出含有標籤 `test_aes_trusted` 的金鑰。

   ```
   aws-cloudhsm > key list --filter attr.label=test_aes_trusted
           {
     "error_code": 0,
     "data": {
       "matched_keys": [
         {
           "key-reference": "0x0000000000200333",
           "attributes": {
             "label": "test_aes_trusted"
           }
         }
       ],
       "total_key_count": 1,
       "returned_key_count": 1
     }
   }
   ```

1. 使用 [使用 CloudHSM CLI 登出 HSM](cloudhsm_cli-logout.md) 命令，以加密使用者 (CU) 的身分登出。

1. 使用 [使用 CloudHSM CLI 登入 HSM](cloudhsm_cli-login.md) 命令，以管理員身分登入。

1. 使用 [key set-attribute](cloudhsm_cli-key-set-attribute.md) 命令搭配您在步驟 2 中識別的金鑰參照，將金鑰的信任值設定為 true：

   ```
   aws-cloudhsm > key set-attribute --filter key-reference=<Key Reference> --name trusted --value true
   {
     "error_code": 0,
     "data": {
       "message": "Attribute set successfully"
     }
   }
   ```

# 使用 CloudHSM CLI 管理規定人數身分驗證 (M of N 存取控制）
<a name="key-quorum-auth-chsm-cli"></a>

 AWS CloudHSM 叢集中的硬體安全模組 (HSMs) 支援規定人數身分驗證，也稱為 M of N 存取控制。使用規定人數身分驗證時，HSM 上沒有任何單一使用者可以執行規定人數控制的操作。相對地，必須有最低數量的 HSM 使用者 (至少 2 個) 合作來執行這些操作。配額身分驗證需要多個 HSM 使用者的核准，以新增額外的保護層。

規定人數身分驗證可以控制以下操作：
+ [加密使用者的](understanding-users.md#crypto-user-chsm-cli) HSM 金鑰使用和管理 – 使用金鑰建立簽章，或包裝、取消包裝、共用、取消共用和設定金鑰的屬性。

**重要考量**
+ HSM 使用者可以簽署自己的規定人數權杖，即：要求的使用者可以針對規定人數身分驗證提供其中一個需要的核准。
+ 您可以針對由規定人數控制的操作選擇最低數量的規定人數核准者。您可以選擇的最小數字是二 (2)，您可以選擇的最大數字是八 (8)。
+ HSM 最多可存放 1，024 個規定人數字符。如果 HSM 在您嘗試建立新的字符時已有 1，024 個字符，HSM 會清除其中一個過期的字符。在預設情況下，字符會在建立後的十分鐘後過期。
+ 如果啟用多重要素驗證 (MFA)，叢集會使用相同的金鑰進行規定人數身分驗證和 MFA。如需使用規定人數身分驗證和 MFA 的詳細資訊，請參閱[使用 CloudHSM CLI 管理 MFA](login-mfa-token-sign.md)。
+ 每個 HSM 一次只能包含一個字符，但每個加密使用者服務只能包含多個字符。

下列主題提供 AWS CloudHSM中的規定人數身分驗證的詳細資訊。

**Topics**
+ [CloudHSM CLI 的配額身分驗證程序](key-quorum-auth-chsm-cli-overview.md)
+ [支援使用 CloudHSM CLI 進行規定人數身分驗證 AWS CloudHSM 的服務名稱和類型](key-quorum-auth-chsm-cli-service-names.md)
+ [使用 CloudHSM CLI 為 AWS CloudHSM 加密使用者設定規定人數身分驗證](key-quorum-auth-chsm-cli-first-time.md)
+ [啟用規定人數身分驗證以 AWS CloudHSM 使用 CloudHSM CLI 的金鑰管理和用量](key-quorum-auth-chsm-cli-crypto-user.md)

# CloudHSM CLI 的配額身分驗證程序
<a name="key-quorum-auth-chsm-cli-overview"></a>

下列步驟摘要說明 CloudHSM CLI 的規定人數身分驗證程序。如需特定步驟和工具，請參閱 [啟用規定人數身分驗證以 AWS CloudHSM 使用 CloudHSM CLI 的金鑰管理和用量](key-quorum-auth-chsm-cli-crypto-user.md)。

1. 每個硬體安全模組 (HSM) 使用者都會建立非對稱金鑰以進行簽署。使用者會在 HSM 外部執行此動作，以適當方式保護金鑰。

1. 每個 HSM 使用者會登入 HSM，並向 HSM 註冊使用者的簽署金鑰 (公有金錀) 的公有部分。

1. HSM 使用者想要執行由規定人數控制的操作時，使用者會登入 HSM，並取得*規定人數權杖*。

1. HSM 使用者會將規定人數字符提供給一或多個其他 HSM 使用者，並要求其核准。

1. 其他 HSM 使用者透過使用自己的金鑰以密碼編譯方式簽署規定人數字符來進行核准。這是在 HSM 外部進行。

1. 當 HSM 使用者具有所需的核准數目時，相同的使用者會登入 HSM 並使用 **--approval** 引數執行規定人數控制的操作，並提供已簽署的規定人數權杖檔案，其中包含所有必要的核准 (簽章)。

1. HSM 會使用每個簽署者註冊的公有金鑰來驗證簽章。如果簽章有效，HSM 會核准權杖，並執行規定人數控制的操作。

# 支援使用 CloudHSM CLI 進行規定人數身分驗證 AWS CloudHSM 的服務名稱和類型
<a name="key-quorum-auth-chsm-cli-service-names"></a>

**管理員服務**：規定人數身分驗證用於管理員特殊權限服務，例如建立使用者、刪除使用者、變更使用者密碼、設定規定人數值，以及停用規定人數和 MFA 功能。

**加密使用者服務**：配額身分驗證用於與特定金鑰相關聯的加密使用者權限服務，例如使用金鑰簽署、共用/取消共用金鑰、包裝/取消包裝金鑰，以及設定金鑰的屬性。產生、匯入或取消包裝金鑰時，會設定關聯金鑰的仲裁值。規定人數值必須等於或小於與金鑰相關聯的使用者數量，其中包括與金鑰共用的使用者和金鑰擁有者。

每種服務類型都會進一步細分為合格的服務名稱，這包含一組特定的可執行法定人數支援的服務操作。


****  

| 服務名稱 | 服務類型 | 服務操作 | 
| --- | --- | --- | 
| user | 管理員 |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/cloudhsm/latest/userguide/key-quorum-auth-chsm-cli-service-names.html)  | 
| 規定人數 | 管理員 |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/cloudhsm/latest/userguide/key-quorum-auth-chsm-cli-service-names.html)  | 
| cluster1 | 管理員 |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/cloudhsm/latest/userguide/key-quorum-auth-chsm-cli-service-names.html)  | 
| 金鑰管理 | 加密使用者 |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/cloudhsm/latest/userguide/key-quorum-auth-chsm-cli-service-names.html)  | 
| key-usage | 加密使用者 |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/cloudhsm/latest/userguide/key-quorum-auth-chsm-cli-service-names.html)  | 

【1】 叢集服務僅在 hsm2m.medium 上提供

# 使用 CloudHSM CLI 為 AWS CloudHSM 加密使用者設定規定人數身分驗證
<a name="key-quorum-auth-chsm-cli-first-time"></a>

這些主題說明如何將 CloudHSM 設定為由[加密使用者](understanding-users.md#crypto-user-chsm-cli)進行規定人數身分驗證。在初始設定期間執行這些步驟一次。如需後續金鑰管理和使用方式，請參閱 [啟用規定人數身分驗證以 AWS CloudHSM 使用 CloudHSM CLI 的金鑰管理和用量](key-quorum-auth-chsm-cli-crypto-user.md)。

**Topics**
+ [先決條件](#key-quorum-crypto-user-prerequisites)
+ [步驟 1. 建立和註冊用於簽署的金鑰](#key-quorum-crypto-user-create-and-register-key)
+ [步驟 2. 在金鑰產生期間設定金鑰規定人數值](#key-quorum-admin-set-quorum-minimum-value-chsm-cli)

## 先決條件
<a name="key-quorum-crypto-user-prerequisites"></a>
+ 熟悉 [CloudHSM CLI](cloudhsm_cli.md)

## 步驟 1. 建立和註冊用於簽署的金鑰
<a name="key-quorum-crypto-user-create-and-register-key"></a>

若要使用規定人數身分驗證，每個加密使用者都必須完成下列*所有*步驟：

**Topics**
+ [建立 RSA 金鑰對](#key-mofn-key-pair-create-chsm-cli)
+ [建立註冊字符](#key-mofn-registration-token-chsm-cli)
+ [簽署未簽署的註冊字符](#key-mofn-sign-registration-token-chsm-cli)
+ [用 HSM 註冊公有金鑰](#key-mofn-register-key-chsm-cli)

### 建立 RSA 金鑰對
<a name="key-mofn-key-pair-create-chsm-cli"></a>

建立和保護金鑰對有許多不同的方式。下列範例示範使用 [OpenSSL](https://www.openssl.org/) 的做法。

**Example – 使用 OpenSSL 建立私有金鑰**  
下列範例示範如何使用 OpenSSL 建立 2048 位元 RSA 金鑰。若要使用此範例，請將 *<crypto\$1user1.key>* 取代為您要存放金鑰的檔案名稱。  

```
$ openssl genrsa -out <crypto_user1.key>
Generating RSA private key, 2048 bit long modulus
.....................................+++
.+++
e is 65537 (0x10001)
```

接下來，使用您剛建立的私有金鑰來產生公有金鑰。

**Example – 使用 OpenSSL 建立一個公有金鑰**  
下列範例會示範如何使用 OpenSSL 根據您剛建立的私有金鑰建立公有金鑰。  

```
$ openssl rsa -in crypto_user1.key -outform PEM -pubout -out crypto_user1.pub
writing RSA key
```

### 建立註冊字符
<a name="key-mofn-registration-token-chsm-cli"></a>

您可以建立一個權杖並使用在上一步中剛產生的私有金鑰簽署該權杖。

**建立註冊字符**

1. 使用以下命令來啟動 CloudHSM CLI：

------
#### [ Linux ]

   ```
   $ /opt/cloudhsm/bin/cloudhsm-cli interactive
   ```

------
#### [ Windows ]

   ```
   PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
   ```

------

1. 透過執行[產生規定人數權杖簽署](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. [產生規定人數權杖簽署](cloudhsm_cli-qm-token-gen.md)命令在指定的檔案路徑產生註冊權杖。檢查權杖檔案：

   ```
   $ cat /path/tokenfile
   {
     "version": "2.0",
     "tokens": [
       {
         "approval_data": <approval data in base64 encoding>,
         "unsigned": <unsigned token in base64 encoding>,
         "signed": ""
       }
     ]
   }
   ```

   權杖檔案由以下項目組成：
   + **approval\$1data**：一個 base64 編碼的隨機資料權杖，其原始資料不超過 245 個位元組的最大值。
   + **unsigned**：核准資料的 base64 編碼和 SHA256 雜湊權杖。
   + **signed**：未簽署的權杖的 base64 編碼簽名權杖 (簽名)，使用先前使用 OpenSSL 產生的 RSA 2048 位元私有金鑰。

   您可以使用私有金鑰簽署未簽署的權杖，以證明您可以訪問私有金鑰。您需要完整填入簽章和公有金鑰的註冊字符檔案，才能向 AWS CloudHSM 叢集將加密使用者註冊為規定人數使用者。

### 簽署未簽署的註冊字符
<a name="key-mofn-sign-registration-token-chsm-cli"></a>

1. 解碼 base64 編碼的未簽署權杖並將其放入二進位檔案中：

   ```
   $ echo -n '6BMUj6mUjjko6ZLCEdzGlWpR5sILhFJfqhW1ej3Oq1g=' | base64 -d > crypto_user.bin
   ```

1. 使用 OpenSSL 和私有金鑰來簽署現在的二進位未簽署註冊權杖，並建立一個二進位簽署檔案：

   ```
   $ openssl pkeyutl -sign \
   -inkey crypto_user1.key \
   -pkeyopt digest:sha256 \
   -keyform PEM \
   -in crypto_user.bin \
   -out crypto_user.sig.bin
   ```

1. 將二進位簽章編碼為 base64：

   ```
   $ base64 -w0 crypto_user.sig.bin > crypto_user.sig.b64
   ```

1. 將 base64 編碼的簽名複製並粘貼到權杖檔案中：

   ```
   {
     "version": "2.0",
     "tokens": [
       {
         "approval_data": <approval data in base64 encoding>,
         "unsigned": <unsigned token in base64 encoding>,
         "signed": <signed token in base64 encoding>
       }
     ]
   }
   ```

### 用 HSM 註冊公有金鑰
<a name="key-mofn-register-key-chsm-cli"></a>

建立金鑰後，加密使用者必須向 AWS CloudHSM 叢集註冊公有金鑰。

1. 啟動 CloudHSM CLI：

------
#### [ Linux ]

   ```
   $ /opt/cloudhsm/bin/cloudhsm-cli interactive
   ```

------
#### [ Windows ]

   ```
   PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
   ```

------

1. 以您要註冊其公有金鑰的加密使用者身分登入。

   ```
   aws-cloudhsm > login --username crypto_user1 --role crypto-user
   Enter password:
   {
     "error_code": 0,
     "data": {
       "username": "crypto_user1",
       "role": "crypto-user"
     }
   }
   ```

1. 向 註冊公有金鑰**[使用 CloudHSM CLI 註冊使用者的字符簽署規定人數策略](cloudhsm_cli-user-chqm-token-reg.md)**。如需詳細資訊，請參閱下列範例或使用 **help user change-quorum token-sign register** 命令。  
**Example – 向 AWS CloudHSM 叢集註冊公有金鑰**  

   下列範例示範如何在 CloudHSM CLI 中使用 **user change-quorum token-sign register**命令向 HSM 註冊加密使用者公有金鑰。若要使用此命令，加密使用者必須登入 HSM。以您自己的值取代這些值：

   ```
   aws-cloudhsm > user change-quorum token-sign register --public-key </path/crypto_user.pub> --signed-token </path/tokenfile>
   {
     "error_code": 0,
     "data": {
       "username": "crypto_user1",
       "role": "crypto-user"
     }
   }
   ```
**注意**  
**/path/crypto\$1user.pub**：公有金鑰 PEM 檔案的檔案路徑  
**必要**：是  
**/path/token\$1file**：具有使用者私有金鑰簽署字符的檔案路徑  
**必要**：是

1. 在所有加密使用者註冊其公有金鑰後，來自 **user list**命令的輸出會在規定人數欄位中顯示，指出使用中已啟用的規定人數策略。

    在此範例中， AWS CloudHSM 叢集有兩個 HSMs，每個 HSM 都有相同的加密使用者，如 **user list**命令的下列輸出所示。如需有關建立使用者的詳細資訊，請參閱[使用 CloudHSM CLI 進行使用者管理](manage-hsm-users-chsm-cli.md)。

   ```
   aws-cloudhsm > user list
   {
     "error_code": 0,
     "data": {
       "users": [
         {
           "username": "admin",
           "role": "admin",
           "locked": "false",
           "mfa": [],
           "quorum": [],
           "cluster-coverage": "full"
         },
         {
           "username": "crypto_user1",
           "role": "crypto-user",
           "locked": "false",
           "mfa": [],
           "quorum": [
             {
               "strategy": "token-sign",
               "status": "enabled"
             }
           ],
           "cluster-coverage": "full"
         },
         {
           "username": "crypto_user2",
           "role": "crypto-user",
           "locked": "false",
           "mfa": [],
           "quorum": [
             {
               "strategy": "token-sign",
               "status": "enabled"
             }
           ],
           "cluster-coverage": "full"
         },
         {
           "username": "crypto_user3",
           "role": "crypto-user",
           "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"
         }
       ]
     }
   }
   ```

## 步驟 2. 在金鑰產生期間設定金鑰規定人數值
<a name="key-quorum-admin-set-quorum-minimum-value-chsm-cli"></a>

若要使用規定人數身分驗證，加密使用者必須登入 HSM，然後設定相關聯的*金鑰規定人數值*。這是執行 HSM 金鑰管理/使用操作所需的加密使用者核准數目下限。如需與金鑰管理或金鑰用量相關聯之金鑰命令的詳細資訊，請參閱 [支援的服務和類型](key-quorum-auth-chsm-cli-service-names.md)。

**產生已設定金鑰規定人數值的金鑰對**

1. 使用下列命令來啟動 CloudHSM CLI：

------
#### [ Linux ]

   ```
   $ /opt/cloudhsm/bin/cloudhsm-cli interactive
   ```

------
#### [ Windows ]

   ```
   PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
   ```

------

1. 使用 CloudHSM CLI，以加密使用者身分登入。

   ```
   aws-cloudhsm > login --username crypto_user1 --role crypto-user
   Enter password:
   {
     "error_code": 0,
     "data": {
       "username": "crypto_user1",
       "role": "crypto-user"
     }
   }
   ```

此範例會產生 RSA 金鑰對，其金鑰規定人數值為兩 (2)，同時針對金鑰管理和金鑰使用操作進行設定。您可以選擇從零 (0) 到八 (8) 的任何值，直到 HSM 上的加密使用者總數為止。在此範例中，HSM 有三 (3) 個加密使用者，因此可能的值上限為三 (3) 個。請注意，在此範例中，我們會在金鑰產生期間與 *<crypto\$1user2>* 共用金鑰。另請注意，公有金鑰沒有規定人數值。

```
aws-cloudhsm > key generate-asymmetric-pair rsa \
--public-exponent 65537 \
--modulus-size-bits 2048 \
--public-label rsa-public-key-example \
--private-label rsa-private-key-example \
--public-attributes verify=true \
--private-attributes sign=true
--share-crypto-users crypto_user2 \
--manage-private-key-quorum-value 2 \
--use-private-key-quorum-value 2
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x0000000000640006",
      "key-info": {
        "key-owners": [
          {
            "username": "crypto_user",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "rsa",
        "label": "rsa-public-key-example",
        "id": "0x",
        "check-value": "0x218f50",
        "class": "public-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": false,
        "sign": false,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 512,
        "public-exponent": "0x010001",
        "modulus": "0xbdf471a3d2a869492f51c767bece8780730ae6479a9a75efffe7cea3594fb28ca518630e7b1d988b45d2fedc830b7ab848448c24c476cacb73d1523278aed289551e07af0fbfabe4811cc4601678bd097b5c0a578249ed1eb0e4878a80ba1ed85ac46eb1fee60d2a8bdd322075196dec4b57fa2cd82af44ad068115ac219bc073ec65c19c97bd883cf26931408d7bc51e237626b8b9b8f2485425907a0eb42f2f4c40018c8dac7ceeb1b646305a2e537ab904346883e41d568264abee0137048e4657d2cf72801810f3212f662b7a7ae134848b922771f6a30aa76718008d9cc74ff8ddcd8d867b05c3d40020d1514999af96889911467191b9f390d8de07f83",
        "modulus-size-bits": 2048
      }
    },
    "private_key": {
      "key-reference": "0x0000000000640007",
      "key-info": {
        "key-owners": [
          {
            "username": "crypto_user",
            "key-coverage": "full"
          }
        ],
        "shared-users": [
          {
            "username": "crypto_user2",
            "key-coverage": "full"
          }
        ],
        "key-quorum-values": {
          "manage-key-quorum-value": 2,
          "use-key-quorum-value": 2
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "rsa",
        "label": "rsa-private-key-example",
        "id": "0x",
        "check-value": "0x218f50",
        "class": "private-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": true,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 1216,
        "public-exponent": "0x010001",
        "modulus": "0xbdf471a3d2a869492f51c767bece8780730ae6479a9a75efffe7cea3594fb28ca518630e7b1d988b45d2fedc830b7ab848448c24c476cacb73d1523278aed289551e07af0fbfabe4811cc4601678bd097b5c0a578249ed1eb0e4878a80ba1ed85ac46eb1fee60d2a8bdd322075196dec4b57fa2cd82af44ad068115ac219bc073ec65c19c97bd883cf26931408d7bc51e237626b8b9b8f2485425907a0eb42f2f4c40018c8dac7ceeb1b646305a2e537ab904346883e41d568264abee0137048e4657d2cf72801810f3212f662b7a7ae134848b922771f6a30aa76718008d9cc74ff8ddcd8d867b05c3d40020d1514999af96889911467191b9f390d8de07f83",
        "modulus-size-bits": 2048
      }
    }
  }
}
```

使用規定人數控制產生金鑰時，該金鑰必須與等於最大金鑰規定人數值的最小使用者數目相關聯。關聯的使用者包括金鑰擁有者和與金鑰共用的加密使用者。若要判斷要共用金鑰的最小使用者數量，請取得金鑰使用量值與金鑰管理量值之間的最大規定人數值，並減去 1 以考慮金鑰擁有者，該擁有者預設與金鑰相關聯。若要與更多使用者共用金鑰，請使用 **[使用 CloudHSM CLI 共用金鑰](cloudhsm_cli-key-share.md)**命令。

如果無法在金鑰產生時與足夠的使用者共用金鑰，將導致失敗，如下所示。

```
aws-cloudhsm > key generate-asymmetric-pair rsa \
--public-exponent 65537 \
--modulus-size-bits 2048 \
--public-label rsa-public-key-example \
--private-label rsa-private-key-example \
--public-attributes verify=true \
--private-attributes sign=true
--share-crypto-users crypto_user2 crypto_user3 \
--manage-private-key-quorum-value 3 \
--use-private-key-quorum-value 4
{
  "error_code": 1,
  "data": "Invalid quorum value provided."
}
```

# 啟用規定人數身分驗證以 AWS CloudHSM 使用 CloudHSM CLI 的金鑰管理和用量
<a name="key-quorum-auth-chsm-cli-crypto-user"></a>

在您為 AWS CloudHSM 叢集設定規定人數身分驗證之後，如果加密使用者的金鑰具有相關聯的規定人數值，則無法自行執行 HSM 金鑰管理或使用操作。本主題說明加密使用者如何取得臨時字符來執行 HSM 金鑰管理或金鑰使用操作。

**注意**  
每個規定人數字符對一個操作有效。當操作成功時，字符不再有效，且加密使用者必須取得新的字符。規定人數字符僅在您目前的登入工作階段期間有效。如果您登出 CloudHSM CLI 或網路中斷連線，字符將不再有效，您需要取得新的字符。您只能在 CloudHSM CLI 中使用 CloudHSM 字符。您無法用它在不同的應用程式中進行身分驗證。

下列範例顯示設定規定人數身分驗證後，加密使用者嘗試在 HSM 上建立具有規定人數相關金鑰的簽章時的輸出。命令失敗並顯示`Quorum Failed`錯誤，這表示規定人數身分驗證失敗：

```
aws-cloudhsm > crypto sign rsa-pkcs --key-filter attr.label=rsa-private-key-example --hash-function sha256 --data YWJjMTIz
{
  "error_code": 1,
  "data": "Quorum Failed"
}
```

加密使用者必須完成下列任務，才能取得在 HSM 上執行金鑰管理或金鑰使用操作的臨時權杖：

**Topics**
+ [步驟 1. 取得規定人數字符](#key-quorum-admin-gen-token-chsm-cli)
+ [步驟 2. 從核准加密使用者取得簽章](#key-quorum-crypto-user-get-approval-signatures-chsm-cli)
+ [步驟 3。在 CloudHSM； 叢集上核准權杖並執行 操作](#key-quorum-crypto-user-approve-token-chsm-cli)

## 步驟 1. 取得規定人數字符
<a name="key-quorum-admin-gen-token-chsm-cli"></a>

1. 啟動 CloudHSM CLI。

------
#### [ Linux ]

   ```
   $ /opt/cloudhsm/bin/cloudhsm-cli interactive
   ```

------
#### [ Windows ]

   ```
   PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" interactive
   ```

------

1. 以加密使用者身分登入叢集。

   ```
   aws-cloudhsm > login --username <crypto_user1> --role crypto-user --password password123
   ```

   此範例使用 `crypto-user`角色`crypto_user1`登入 CloudHSM CLI。將這些值取代為您自己的值。

   ```
   {
     "error_code": 0,
     "data": {
       "username": "crypto_user1",
       "role": "crypto-user"
     }
   }
   ```

1. 使用 **quorum token-sign generate**命令產生規定人數字符。

   在下列命令中，`key-usage`識別您要用來產生字符*的服務名稱*。在此情況下，字符適用於金鑰使用操作 (`key-usage` 服務） 此範例使用 `--filter`旗標將字符與特定金鑰建立關聯。

   ```
   aws-cloudhsm > quorum token-sign generate --service key-usage --token </path/crypto_user1.token> --filter attr.label=rsa-private-key-example
   {
     "error_code": 0,
     "data": {
       "path": "/home/crypto_user1.token"
     }
   }
   ```

   此範例會使用使用者名稱取得加密使用者的規定人數字符，`crypto_user1`並將字符儲存到名為 的檔案`crypto_user1.token`。若要使用範例命令，請將這些值取代為您自己的值：

   **quorum token-sign generate** 命令會在指定的檔案路徑產生金鑰使用量服務規定人數字符。您可以檢查權杖檔案：

   ```
   $ cat </path/crypto_user1.token>
   {
     "version": "2.0",
     "service": "key-usage",
     "key_reference": "0x0000000000680006",
     "approval_data": "AAIABQAAABkAAAAAAGgABi5CDa9x9VyyRIaFbkSrHgJjcnlwdG9fdXNlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnPQBLAAAAAAAAAAAAAgAFAAAAGgAAAAAAaAAGQvd2qKY+GJj8gXo9lKuANGNyeXB0b191c2VyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGc9AEsAAAAAAAAAAA==",
     "token": "5GlgoWOlQU4fw4QIlbxkPGZVOVoDugFGuSKE/k67ncM=",
     "signatures": []
   }
   ```

   權杖檔案由以下項目組成：
   + **服務**：權杖相關聯的規定人數服務識別符。
   + **key\$1reference**：與此規定人數字符相關聯的金鑰識別符。
   + **approval\$1data**：由 HSM 產生的 base64 編碼原始資料權杖。
   + **token**：approval\$1data 的 base64 編碼和 SHA-256 雜湊權杖
   + **signatures**：未簽署字符的 base64 編碼簽署字符 （簽章） 陣列。每個核准者簽章的格式都是 JSON 物件常值：

     ```
     {
           "username": "<APPROVER_USERNAME>",
           "role": "<APPROVER_ROLE>",
           "signature": "<APPROVER_RSA2048_BIT_SIGNATURE>"
     }
     ```

     每個簽章都是從核准者的結果使用其對應的 RSA 2048 位元私有金鑰建立，其公有金鑰已向 HSM 註冊。

1. 驗證新的使用者服務規定人數字符。**quorum token-sign list** 命令會確認字符存在於 CloudHSM 上。

   ```
   aws-cloudhsm > quorum token-sign list
   {
     "error_code": 0,
     "data": {
       "tokens": [
         {
           "username": "crypto_user",
           "service": "key-usage",
           "key-reference": "0x0000000000680006",
           "minimum-token-count": 2
         }
       ]
     }
   }
   ```

   `minimum-token-count` 會顯示從叢集中的單一 HSM 擷取的對應使用者名稱、服務和金鑰參考的最小可用金鑰字符數量的彙總叢集檢視。

   例如，假設有一個 2-HSM 叢集，如果我們從叢集中`0x0000000000680006`的第一個 HSM 參考收到使用者`crypto_user1`為金鑰產生的兩 (2) 個金鑰用量權杖，並且收到使用者`crypto_user1`為金鑰產生的一 (1) 個金鑰用量權杖，`0x0000000000680006`並參考叢集中的另一個 HSM，則會顯示 `"minimum-token-count": 1`。

## 步驟 2. 從核准加密使用者取得簽章
<a name="key-quorum-crypto-user-get-approval-signatures-chsm-cli"></a>

具有規定人數字符的加密使用者必須取得其他加密使用者核准的字符。為了提供核准，其他加密 =-users 會使用其簽署金鑰，在 HSM 外部以密碼編譯方式簽署字符。

簽署權杖的方式有很多。下列範例示範如何使用 [OpenSSL](https://www.openssl.org/) 簽署權杖。若要使用不同的簽署工具，請確定工具使用 crypto-user 的私有金鑰 （簽署金鑰） 來簽署字符的 SHA-256 摘要。

在此範例中，具有字符 (`crypto-user`) 的加密使用者需要至少兩 (2) 個核准。下列範例命令顯示兩 (2) 個加密使用者如何使用 OpenSSL 以密碼編譯方式簽署字符。

1. 解碼 base64 編碼的未簽署權杖並將其放入二進位檔案中：

   ```
   $echo -n '5GlgoWOlQU4fw4QIlbxkPGZVOVoDugFGuSKE/k67ncM=' | base64 -d > crypto_user1.bin
   ```

1. 使用 OpenSSL 和核准者的私有金鑰來簽署使用者服務的二進位規定人數未簽署權杖，並建立二進位簽章檔案：

   ```
   $openssl pkeyutl -sign \
   -inkey crypto_user1.key \
   -pkeyopt digest:sha256 \
   -keyform PEM \
   -in crypto_user1.bin \
   -out crypto_user1.sig.bin
   ```

1. 將二進位簽章編碼為 base64：

   ```
   $ base64 -w0 crypto_user1.sig.bin > crypto_user1.sig.b64
   ```

1. 使用先前為核准者簽章指定的 JSON 物件常值格式，將 base64 編碼的簽章複製並貼到權杖檔案中：

   ```
   {
     "version": "2.0",
     "service": "key-usage",
     "key_reference": "0x0000000000680006",
     "approval_data": "AAIABQAAABkAAAAAAGgABi5CDa9x9VyyRIaFbkSrHgJjcnlwdG9fdXNlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABnPQBLAAAAAAAAAAAAAgAFAAAAGgAAAAAAaAAGQvd2qKY+GJj8gXo9lKuANGNyeXB0b191c2VyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGc9AEsAAAAAAAAAAA==",
     "token": "5GlgoWOlQU4fw4QIlbxkPGZVOVoDugFGuSKE/k67ncM=",
     "signatures": [
       {
         "username": "crypto_user1",
         "role": "crypto-user",
         "signature": "wa7aPzmGwBjcEoZ6jAzYASp841AfgOvcI27Y/tGlCj1E9DawnFw5Uf0IJT2Ca7T5XD2ThVkUi0B+dhAomdqYNl6aUUFrJyH9GBJ+E0PmA5jNVm25tzeRWBJzneTg4/zTeE2reNqrHFHicWnttQLe9jS09J1znuDGWDe0HaBKWUaz2gUInJRqmeXDsZYdSvZksrqUH5dci/RsaDE2+tGiS9g0RcIkFbsPW4HpGe2e5HVzGsqrV8O3PKlYQv6+fymfcNTTuoxKcHAkOjpl43QSuSIu2gVq7KI8mSmmWaPJL47NPjmcBVB5vdEQU+oiukaNfLJr+MoDKzAvCGDg4cDArg=="
       },
       {
         "username": "crypto_user2",
         "role": "crypto-user",
         "signature": "wa7aPzmGwBjcEoZ6jAzYASp841AfgOvcI27Y/tGlCj1E9DawnFw5Uf0IJT2Ca7T5XD2ThVkUi0B+dhAomdqYNl6aUUFrJyH9GBJ+E0PmA5jNVm25tzeRWBJzneTg4/zTeE2reNqrHFHicWnttQLe9jS09J1znuDGWDe0HaBKWUaz2gUInJRqmeXDsZYdSvZksrqUH5dci/RsaDE2+tGiS9g0RcIkFbsPW4HpGe2e5HVzGsqrV8O3PKlYQv6+fymfcNTTuoxKcHAkOjpl43QSuSIu2gVq7KI8mSmmWaPJL47NPjmcBVB5vdEQU+oiukaNfLJr+MoDKzAvCGDg4cDArg=="
       }
     ]
   }
   ```

## 步驟 3。在 CloudHSM； 叢集上核准權杖並執行 操作
<a name="key-quorum-crypto-user-approve-token-chsm-cli"></a>

在加密使用者擁有必要的核准和簽章之後，他們可以將該字符連同金鑰管理或金鑰使用操作一起提供給 CloudHSM 叢集。

請確定金鑰操作對應至與規定人數字符相關聯的適當規定人數服務。如需詳細資訊，請參閱 [支援的服務和類型](key-quorum-auth-chsm-cli-service-names.md)。

在交易期間，字符將在 AWS CloudHSM 叢集內核准，並執行請求的金鑰操作。金鑰操作的成功取決於有效的核准規定人數字符和有效的金鑰操作。

**Example 使用 RSA-PKCS 機制產生簽章**  
在下列範例中，登入的 crypto-user 會在 HSM 上建立具有金鑰的簽章：  

```
aws-cloudhsm > crypto sign rsa-pkcs --key-filter attr.label=rsa-private-key-example --hash-function sha256 --data YWJjMTIz --approval /path/crypto_user1.token
      
{
  "error_code": 0,
  "data": {
    "key-reference": "0x0000000000640007",
    "signature": "h6hMqXacBrT3x3MXV13RXHdQno0+IQ6iy0kVrGzo23+eoWT0ZZgrSpBCu5KcuP6IYYHw9goQ5CfPf4jI1nO5m/IUJtF1A1lmcz0HjEy1CJ7ICXNReDRyeOU8m43dkJzt0OUdkbtkDJGAcxkbKHLZ02uWsGXaQ8bOKhoGwsRAHHF6nldTXquICfOHgSd4nimObKTqzUkghhJW5Ot5oUyLMYP+pZmUS38ythybney94Wj6fzYOER8v7VIY5ijQGa3LfxrjSG4aw6QijEEbno5LSf18ahEaVKmVEnDBL54tylCJBGvGsYSY9HNhuJoHPgiDL/TDd2wfvP4PaxbFRyyHaw=="
  }
}
```
如果加密使用者嘗試使用相同的字符執行另一個 HSM 金鑰使用操作，它會失敗：  

```
aws-cloudhsm > crypto sign rsa-pkcs --key-filter attr.label=rsa-private-key-example --hash-function sha256 --data YWJjMTIz --approval /home/crypto_user1.token
{
  "error_code": 1,
  "data": "Quorum approval is required for this operation"
}
```
若要執行另一個 HSM 金鑰操作，加密使用者必須產生新的規定人數字符、從核准者取得新的簽章，並使用 -- 核准引數執行所需的金鑰操作，以提供規定人數字符。  
使用 **quorum token-sign list**來檢查可用的字符。此範例顯示 crypto-user 沒有核准的字符。  

```
aws-cloudhsm > quorum token-sign list
{
  "error_code": 0,
  "data": {
    "tokens": []
  }
}
```