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

# 中的金鑰 AWS CloudHSM
<a name="manage-keys"></a>

您必須先在 AWS CloudHSM 叢集中的硬體安全模組 (HSM) 上建立[使用者](manage-hsm-users.md)和金鑰，才能使用叢集進行加密處理。

在 中 AWS CloudHSM，使用下列任何一項來管理叢集中 HSMs上的金鑰：
+ PKCS \$111 程式庫
+ JCE 提供者
+ CNG 和 KSP 提供者
+ CloudHSM CLI

在管理金鑰前，請以加密使用者 (CU) 的使用者名稱和密碼登入 HSM。只有 CU 才可建立金鑰。建立金鑰的 CU 擁有並管理該金鑰。

如需在 中管理金鑰的詳細資訊，請參閱下列主題 AWS CloudHSM。

**Topics**
+ [金鑰同步與耐久性](manage-key-sync.md)
+ [AES 金鑰包裝](manage-aes-key-wrapping.md)
+ [可信任金鑰](manage-keys-using-trusted-keys.md)
+ [使用 CloudHSM CLI 進行金鑰管理](manage-keys-chsm-cli.md)
+ [使用 KMU 進行金鑰管理](manage-keys-kmu-cmu.md)

# 中的金鑰同步和耐久性設定 AWS CloudHSM
<a name="manage-key-sync"></a>

AWS CloudHSM 會同步您建立的每個字符金鑰。金鑰同步主要是自動程序，但您可以在叢集中至少使用兩個硬體安全模組 (HSM)，讓金鑰更耐久。本主題說明金鑰同步處理設定、客戶在叢集上使用金鑰時所面臨的常見問題，以及讓金鑰更耐久的策略。

本主題說明 中的金鑰同步設定 AWS CloudHSM、客戶在叢集上使用金鑰時遇到的常見問題，以及讓金鑰更持久的策略。

**Topics**
+ [概念](concepts-key-sync.md)
+ [了解金鑰同步](understand-key-sync.md)
+ [變更用戶端金鑰耐久性設定](working-client-sync.md)
+ [同步複製的叢集之間的金鑰](cli-sync.md)

# AWS CloudHSM 關鍵概念
<a name="concepts-key-sync"></a>

以下是使用 金鑰時需要注意的概念 AWS CloudHSM。

**權杖金鑰**  
您在金鑰產生、匯入或取消包裝操作期間建立的持久性金鑰。 會 AWS CloudHSM 同步叢集中的字符金鑰。

**工作階段金鑰**  
僅存在於叢集中一個硬體安全模組 (HSM) 上的暫時性金鑰。 AWS CloudHSM *不會*跨叢集同步工作階段金鑰。

**用戶端金鑰同步**  
一種用戶端程序，可複製您在金鑰產生、匯入或解除包裝作業期間建立的權杖金鑰。您可以透過執行至少兩個 HSM 的叢集，使權杖金鑰更耐久。

**伺服器端金鑰同步**  
定期將金鑰複製到叢集中的每個 HSM。不需要管理。

**用戶端金鑰耐久性設定**  
您在用戶端上設定的會影響金鑰耐久性的設定。這些設定在用戶端 SDK 5 和用戶端 SDK 3 中的運作方式不同。  
+ 在用戶端 SDK 5 中，使用此設定來執行單一 HSM 叢集。
+ 在用戶端 SDK 3 中，使用此設定可指定金鑰建立作業成功所需的 HSM 數目。

# 了解 AWS CloudHSM 金鑰同步
<a name="understand-key-sync"></a>

AWS CloudHSM 使用金鑰同步來複製叢集中所有硬體安全模組 (HSM) 的權杖金鑰。您可以在金鑰產生、匯入或解除包裝作業期間，將權杖金鑰建立為持久性金鑰。為了在叢集中分配這些金鑰，CloudHSM 提供用戶端和伺服器端金鑰同步處理。

![\[Key synchronization diagram showing client-side and server-side sync for CloudHSM 叢集.\]](http://docs.aws.amazon.com/zh_tw/cloudhsm/latest/userguide/images/key-synch.png)


金鑰同步處理 (伺服器端和用戶端) 的目標是在建立新金鑰之後，儘快在叢集中散發新金鑰。這很重要，因為您後續使用新金鑰所進行的呼叫可以路由傳送至叢集中任何可用的 HSM。如果您進行的呼叫路由到沒有 金鑰的 HSM，則呼叫會失敗。您可以指定應用程式重試在金鑰建立作業之後進行的後續呼叫，藉此減輕這些類型的失敗。同步處理所需的時間可能會有所不同，具體取決於叢集的工作負載和其他無形資產。使用 CloudWatch 指標來判斷應用程式在這種情況下應採用的時間。如需詳細資訊，請參閱 [CloudWatch 指標](hsm-metrics-cw.md)。

在雲端環境中，金鑰同步處理的挑戰在於金鑰的耐久性。您可以在單一 HSM 上建立金鑰，並且通常會立即開始使用這些金鑰。如果您建立金鑰的 HSM 在將金鑰複製到叢集中的其他 HSM 前失敗，您將遺失金鑰*並*存取金鑰所加密的任何項目。為了減輕此風險，我們提供*用戶端同步處理*。用戶端同步處理是用戶端程序，可複製您在金鑰產生、匯入或解除包裝作業期間建立的金鑰。在建立金鑰時複製金鑰會讓金鑰更耐久。當然，您無法使用單一 HSM 複製叢集中的金鑰。為了讓金鑰更耐久，我們也建議您將叢集設定為至少使用兩個 HSM。透過用戶端同步處理和具有兩個 HSM 的叢集，您可以在雲端環境中應對金鑰耐久性的挑戰。

# 變更 AWS CloudHSM 用戶端金鑰耐久性設定
<a name="working-client-sync"></a>

金鑰同步處理大部分是自動程序，但您可以管理用戶端金鑰耐久性設定。用戶端金鑰耐久性設定在用戶端 SDK 5 和用戶端 SDK 3 中的運作方式不同。
+ 在用戶端 SDK 5 中，我們介紹了*金鑰可用性定額組*的概念。此概念要求您至少使用兩個 HSM 執行叢集。您可以使用用戶端金鑰耐久性設定來選擇退出兩個 HSM 需求。如需定額組的詳細資訊，請參閱 [AWS CloudHSM 關鍵概念](concepts-key-sync.md)。
+ 在用戶端 SDK 3 中，您可以使用用戶端金鑰耐久性設定來指定必須成功建立金鑰的 HSM 數目，整體作業才會視為成功。

## 用戶端 SDK 5 用戶端金鑰耐久性設定
<a name="client-sync-sdk8"></a>

在用戶端 SDK 5 中，金鑰同步處理是完全自動的程序。透過金鑰可用性定額組，新建立的金鑰在您的應用程式使用金鑰前必須存在於叢集中的兩個 HSM 上。若要使用金鑰可用性定額組，您的叢集必須至少要有兩個 HSM。

如果您的叢集組態不符合金鑰耐久性需求，則建立或使用權杖金鑰的任何嘗試都會失敗，並在日誌中顯示下列錯誤訊息：

```
Key <key handle> does not meet the availability requirements - The key must be available on at least 2 HSMs before being used.
```

您可以使用用戶端組態設定來選擇退出金鑰可用性定額組。例如，您可能想要選擇退出以單一 HSM 執行叢集。

### 用戶端 SDK 5 概念
<a name="client-sync-8concept"></a>

**金鑰可用性定額組**  
AWS CloudHSM 指定叢集中的 HSMs 數目，在應用程式可以使用金鑰之前，金鑰必須存在於其中。需要至少有兩個 HSM 的叢集。

### 管理用戶端金鑰耐久性設定
<a name="setting-file-sdk8"></a>

若要管理用戶端金鑰耐久性設定，您必須使用用戶端 SDK 5 的設定工具。

------
#### [ PKCS \$111 library ]

**在 Linux 上停用用戶端 SDK 5 的用戶端金鑰耐久性**
+  使用設定工具來停用用戶端金鑰耐久性設定。

  ```
  $ sudo /opt/cloudhsm/bin/configure-pkcs11 --disable-key-availability-check
  ```

**在 Windows 上停用用戶端 SDK 5 的用戶端金鑰耐久性**
+  使用設定工具來停用用戶端金鑰耐久性設定。

  ```
  PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-pkcs11.exe" --disable-key-availability-check
  ```

------
#### [ OpenSSL Dynamic Engine ]

**在 Linux 上停用用戶端 SDK 5 的用戶端金鑰耐久性**
+  使用設定工具來停用用戶端金鑰耐久性設定。

  ```
  $ sudo /opt/cloudhsm/bin/configure-dyn --disable-key-availability-check
  ```

------
#### [ OpenSSL Dynamic Engine Provider ]

**在 Linux 上停用用戶端 SDK 5 的用戶端金鑰耐久性**
+  使用設定工具來停用用戶端金鑰耐久性設定。

  ```
  $ sudo /opt/cloudhsm/bin/configure-openssl-provider --disable-key-availability-check
  ```

------
#### [ Key Storage Provider (KSP) ]

**在 Windows 上停用用戶端 SDK 5 的用戶端金鑰耐久性**
+  使用設定工具來停用用戶端金鑰耐久性設定。

  ```
  PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-ksp.exe" --disable-key-availability-check
  ```

------
#### [ JCE provider ]

**在 Linux 上停用用戶端 SDK 5 的用戶端金鑰耐久性**
+  使用設定工具來停用用戶端金鑰耐久性設定。

  ```
  $ sudo /opt/cloudhsm/bin/configure-jce --disable-key-availability-check
  ```

**在 Windows 上停用用戶端 SDK 5 的用戶端金鑰耐久性**
+  使用設定工具來停用用戶端金鑰耐久性設定。

  ```
  PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-jce.exe" --disable-key-availability-check
  ```

------
#### [ CloudHSM CLI ]

**在 Linux 上停用用戶端 SDK 5 的用戶端金鑰耐久性**
+  使用設定工具來停用用戶端金鑰耐久性設定。

  ```
  $ sudo /opt/cloudhsm/bin/configure-cli --disable-key-availability-check
  ```

**在 Windows 上停用用戶端 SDK 5 的用戶端金鑰耐久性**
+  使用設定工具來停用用戶端金鑰耐久性設定。

  ```
  PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-cli.exe" --disable-key-availability-check
  ```

------

## 用戶端 SDK 3 用戶端金鑰耐久性設定
<a name="client-sync-sdk3"></a>

在用戶端 SDK 3 中，金鑰同步處理大部分是自動程序，但您可以使用用戶端金鑰耐久性設定，讓金鑰更耐久。您需要指定必須成功建立金鑰的 HSM 數目，整體作業才會視為成功。無論您選擇何種設定，用戶端同步處理始終都會盡最大努力嘗試將金鑰複製到叢集中的每個 HSM。您的設定會對您指定的 HSM 數量強制建立金鑰。如果您指定一個值，但系統無法將金鑰複製到該數目的 HSM，則系統會自動清除任何不需要的金鑰材料，您可以再試一次。

**重要**  
如果您未設定用戶端金鑰耐久性設定 (或使用預設值 1)，您的金鑰容易遺失。如果您目前的 HSM 應該在伺服器端服務將該金鑰複製到另一個 HSM 之前失敗，您就會遺失金鑰材料。

若要最大化金鑰持久性，請考慮為用戶端同步處理指定至少兩個 HSM。請記住，無論您指定了多少 HSM，叢集上的工作負載都保持不變。用戶端同步處理一律會盡最大努力嘗試將金鑰複製到叢集中的每個 HSM。

**建議**
+ **最小值**：每個叢集兩個 HSM
+ **最大值**：少於叢集中 HSM 總數的一個值

如果用戶端同步處理失敗，用戶端服務會清除任何可能已建立且現在不需要的多餘金鑰。這種清理是盡力而為的回應，可能並非不總是有效。如果清理失敗，您可能必須刪除不需要的金鑰材料。如需詳細資訊，請參閱[金鑰同步處理失敗](ts-client-sync-fail.md)。

### 設定用戶端金鑰耐久性的組態檔案
<a name="setting-file"></a>

若要指定用戶端金鑰耐久性設定，您必須編輯 `cloudhsm_client.cfg`。

**編輯用戶端組態檔案**

1. 打開 `cloudhsm_client.cfg`。

   **Linux**︰

   ```
   /opt/cloudhsm/etc/cloudhsm_client.cfg
   ```

   **Windows**：

   ```
   C:\ProgramData\Amazon\CloudHSM\data\cloudhsm_client.cfg
   ```

1. 在 檔案的`client`節點中，新增`create_object_minimum_nodes`並指定 HSMs 數目下限的值，該值 AWS CloudHSM 必須成功建立金鑰，金鑰建立操作才能成功。

   ```
   "create_object_minimum_nodes" : 2
   ```
**注意**  
key\$1mgmt\$1util (KMU) 命令列工具有用戶端金鑰耐久性的額外設定。如需詳細資訊，請參閱[KMU 與用戶端同步](#kmu-sync)

#### 組態參考
<a name="client-side-ref"></a>

以下是用戶端同步處理屬性，如 `cloudhsm_client.cfg` 的摘錄所示：

```
{
    "client": {
        "create_object_minimum_nodes" : 2,
        ...
    },
    
    ...
}
```

**create\$1object\$1minimum\$1nodes**  
指定認為金鑰產生、金鑰匯入或金鑰解除包裝作業成功所需的 HSM 數目下限。如果設定，則預設值為 1。即：對於每個金鑰建立作業，用戶端服務都會嘗試在叢集中的每個 HSM 上建立金鑰，但若要傳回成功，只需要在叢集中的一個 HSM 上建立*單一金鑰*。

### KMU 與用戶端同步
<a name="kmu-sync"></a>

如果您使用 key\$1mgmt\$1util (KMU) 命令列工具建立金鑰，您可以使用選用的命令列參數 (`-min_srv`) 來*限制*需要複製金鑰的 HSM 數目。如果您指定命令列參數*和*組態檔案中的值， 會 AWS CloudHSM 傳回兩個值的 LARGER。

 如需詳細資訊，請參閱下列主題：
+ [genDSAKeyPair](key_mgmt_util-genDSAKeyPair.md)
+ [genECCKeyPair](key_mgmt_util-genECCKeyPair.md)
+ [genRSAKeyPair](key_mgmt_util-genRSAKeyPair.md)
+ [genSymKey](key_mgmt_util-genSymKey.md)
+ [importPrivateKey](key_mgmt_util-importPrivateKey.md)
+ [importPubKey](key_mgmt_util-importPubKey.md)
+ [imSymKey](key_mgmt_util-imSymKey.md)
+ [insertMaskedObject](key_mgmt_util-insertMaskedObject.md)
+ [unWrapKey](key_mgmt_util-unwrapKey.md)

# 在複製的 AWS CloudHSM 叢集之間同步金鑰
<a name="cli-sync"></a>

用戶端和伺服器端同步僅適用於同步*相同* AWS CloudHSM 叢集中的金鑰。如果您將叢集備份複製到另一個區域，請使用[金鑰複](cloudhsm_cli-key-replicate.md)寫命令在兩個叢集之間複寫金鑰。您可以使用複製的叢集進行跨區域備援，或簡化災難復原程序。如果您尚未安裝 CloudHSM CLI，請參閱 中的指示[開始使用 AWS CloudHSM 命令列界面 (CLI)](cloudhsm_cli-getting-started.md)。

# 中的 AES 金鑰包裝 AWS CloudHSM
<a name="manage-aes-key-wrapping"></a>

本主題說明 中的 AES 金鑰包裝選項 AWS CloudHSM。AES 金鑰包裝使用 AES 金鑰 (包裝金鑰) 來包裝任何類型的另一個金鑰 (目標金鑰)。您可以使用金鑰包裝來保護儲存的金鑰，或透過不安全的網路傳輸金鑰。

**Topics**
+ [支援的演算法](#supported-types)
+ [在 中使用 AES 金鑰包裝 AWS CloudHSM](#use-aes-key-wrap)

## 支援的演算法
<a name="supported-types"></a>

AWS CloudHSM 提供三種 AES 金鑰包裝選項，每個選項都根據目標金鑰在包裝前的填充方式而定。當您呼叫金鑰包裝時，會根據您使用的演算法自動完成填補。下表列出支援的演算法和相關詳細資訊，可協助您為應用程式選擇適當的包裝機制。


| AES 金鑰包裝演算法 | 規格 | 支援的目標金鑰類型 | 填補方案 | AWS CloudHSM 用戶端可用性  | 
| --- | --- | --- | --- | --- | 
| AES 金鑰包裝，零填補  | [RFC 5649](https://tools.ietf.org/html/rfc5649) 和 [SP 800–38F](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf) | 全部 | 如果需要，在金鑰位元後增加零，以對齊區塊 | SDK 3.1 及更新版本 | 
| AES 金鑰包裝，無填補 | [RFC 3394](https://tools.ietf.org/html/rfc3394) 和 [SP 800–38F](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf) | 區塊對齊的金鑰，例如 AES 和 3DES  | 無 | SDK 3.1 及更新版本 | 
| AES 金鑰包裝與 PKCS \$15 填補 | 無 | 全部 |  根據 PKCS \$15 填補方案新增至少 8 個位元組以對齊區塊   | 全部 | 

若要了解如何在應用程式中使用上表的 AES 金鑰包裝演算法，請參閱 [AWS CloudHSM中的使用 AES 金鑰包裝](#use-aes-key-wrap)。

### 了解 AES 金鑰包裝中的初始化向量
<a name="understand-padding-iv"></a>

在包裝之前，CloudHSM 會將初始化向量 (IV) 附加到目標金鑰，以確保資料完整性。每個金鑰包裝演算法對於允許什麼類型的 IV 都有特定的限制。若要在 中設定 IV AWS CloudHSM，您有兩個選項：
+ 隱含：將 IV 設定為 NULL，CloudHSM 會使用該演算法的預設值進行包裝和取消包裝操作 (建議)
+ 明確：透過將預設 IV 值傳遞給金鑰包裝函數來設定 IV 

**重要**  
您必須了解在您應用程式中使用什麼 IV。若要取消包裝金鑰，您必須提供您用來包裝金鑰的相同 IV。如果您使用隱含 IV 來包裝，則請使用隱含 IV 來取消包裝。對於隱含 IV，CloudHSM 將使用預設值來取消包裝。

下表說明包裝演算法指定之 IV 的允許值。


****  

| AES 金鑰包裝演算法 | 隱含 IV | 明確 IV | 
| --- | --- | --- | 
| AES 金鑰包裝，零填補  | 必要 預設值：(根據規格在內部計算 IV) | 不允許 | 
| AES 金鑰包裝，無填補 | 允許 (建議使用) 預設值：`0xA6A6A6A6A6A6A6A6` | 允許 只接受此值：`0xA6A6A6A6A6A6A6A6` | 
| AES 金鑰包裝與 PKCS \$15 填補 | 允許 (建議使用) 預設值：`0xA6A6A6A6A6A6A6A6` | 允許 只接受此值：`0xA6A6A6A6A6A6A6A6` | 

## 在 中使用 AES 金鑰包裝 AWS CloudHSM
<a name="use-aes-key-wrap"></a>

 如下所示包裝和取消包裝金鑰：
+ 在 [PKCS \$111 程式庫](pkcs11-library.md)中，為 `C_WrapKey` 和 `C_UnWrapKey` 函數選取適當的機制，如下表所示。
+ 在 [JCE 提供者](java-library.md)中，選取適當的演算法、模式和填補組合，實作加密方法 `Cipher.WRAP_MODE` 和 `Cipher.UNWRAP_MODE`，如下表所示。
+ 在 [CloudHSM CLI](cloudhsm_cli.md) 中，從支援的 [CloudHSM CLI 中的金鑰包裝命令](cloudhsm_cli-key-wrap.md)和 演算法清單中選擇適當的[CloudHSM CLI 中的金鑰取消包裝命令](cloudhsm_cli-key-unwrap.md)演算法，如下表所示。
+ 在 [key\$1mgmt\$1util (KMU)](key_mgmt_util.md) 中，使用 [使用 KMU 取消包裝 AWS CloudHSM 金鑰](key_mgmt_util-unwrapKey.md) 和 [使用 KMU 匯出 AWS CloudHSM 金鑰](key_mgmt_util-wrapKey.md) 命令搭配適當的 m 值，如下表所示。


****  

| AES 金鑰包裝演算法 | PKCS \$111 機制 | Java 方法 | CloudHSM CLI 子命令 | 金鑰管理公用程式 (KMU) 引數 | 
| --- | --- | --- | --- | --- | 
| AES 金鑰包裝，零填補  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/cloudhsm/latest/userguide/manage-aes-key-wrapping.html)  | AESWrap/ECB/ZeroPadding | aes-zero-pad | m = 6 | 
| AES 金鑰包裝，無填補 |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/cloudhsm/latest/userguide/manage-aes-key-wrapping.html)  | AESWrap/ECB/NoPadding | aes-no-pad | m = 5 | 
| AES 金鑰包裝與 PKCS \$15 填補  |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/cloudhsm/latest/userguide/manage-aes-key-wrapping.html)  | AESWrap/ECB/PKCS5Padding | aes-pkcs5-pad | m = 4 | 

# 在 中使用信任的金鑰 AWS CloudHSM
<a name="manage-keys-using-trusted-keys"></a>

AWS CloudHSM 支援受信任的金鑰包裝，以保護資料金鑰免受內部威脅。本主題說明如何建立可信任金鑰來保護資料安全。

**Topics**
+ [了解可信任金鑰](understand-trusted-key-wraps.md)
+ [可信任的金鑰屬性](key_attribute_background.md)
+ [如何使用可信任金鑰來包裝資料金鑰](wrap_keys_using_trusted.md)
+ [如何使用可信任金鑰取包裝消資料金鑰](unwrap_keys_using_trusted.md)

# 了解 中的信任金鑰 AWS CloudHSM
<a name="understand-trusted-key-wraps"></a>

*可信任金鑰*是用來包裝其他金鑰的金鑰，管理員和加密管理員 (COs) 會使用屬性 `CKA_TRUSTED` 明確識別為可信任。此外，管理員和加密管理員 (CO) 會使用 `CKA_UNWRAP_TEMPLATE` 和相關屬性來指定可信任金鑰取消資料金鑰包裝後可執行的動作。由可信任金鑰取消資料金鑰包裝也必須包含這些屬性，取消包裝的操作才能成功，其有助於確保只允許已取消包裝的資料金鑰用於您想要的用途。

使用屬性 `CKA_WRAP_WITH_TRUSTED` 來識別您要使用可信任金鑰包裝的所有資料金鑰。這樣做可讓您限制資料金鑰，讓應用程式只能使用可信任金鑰來取消包裝。一旦您在資料金鑰上設定此屬性，屬性就會變成唯讀，而且無法變更。設定這些屬性後，應用程式只能使用您信任的金鑰來取消資料金鑰包裝，並且取消包裝一律會產生具有會限制這些金鑰使用方式屬性的資料金鑰。

# 中的信任金鑰屬性 AWS CloudHSM
<a name="key_attribute_background"></a>

下列屬性可讓您將 AWS CloudHSM 金鑰標示為受信任、指定資料金鑰只能使用受信任金鑰包裝和取消包裝，以及控制資料金鑰在取消包裝後可執行的操作：
+ `CKA_TRUSTED`：將此屬性 (除 `CKA_UNWRAP_TEMPLATE` 外) 套用於將會包裝資料金鑰的金鑰，以表明管理員或加密管理員 (CO) 已完成必要的盡職調查並信任此金鑰。只有管理員或 CO 可以設定 `CKA_TRUSTED`。加密使用者 (CU) 擁有金鑰，但只有 CO 可以設置其 `CKA_TRUSTED` 屬性。
+ `CKA_WRAP_WITH_TRUSTED`：將此屬性套用於可匯出的資料金鑰，以表明只能使用標記為 `CKA_TRUSTED` 的金鑰包裝此金鑰。一旦設定 `CKA_WRAP_WITH_TRUSTED` 為 true，屬性就會變成唯讀，而且您無法變更或移除屬性。
+ `CKA_UNWRAP_TEMPLATE`：將此屬性套用於包裝金鑰 (除 `CKA_TRUSTED` 外)，以指定服務必須自動套用於服務取消包裝資料金鑰的屬性名稱和值。當應用程式提交金鑰以取消包裝時，還可提供自有的取消包裝範本。如果您指定取消包裝範本，且應用程式提供了自有的取消包裝範本，則 HSM 會使用這兩個範本將屬性名稱和值套用於金鑰。但是，如果用於包裝金鑰的 `CKA_UNWRAP_TEMPLATE` 中的值與應用程式在取消包裝請求期間提供的屬性衝突，取消包裝請求會失敗。

如需關於屬性的詳細資訊，請參閱下列主題：
+ [PKCS \$111 金鑰屬性](pkcs11-attributes.md)
+ [JCE 金鑰屬性](java-lib-attributes_5.md)
+ [CloudHSM CLI 金鑰屬性](cloudhsm_cli-key-attributes.md)

# 如何使用信任的金鑰在 中包裝資料金鑰 AWS CloudHSM
<a name="wrap_keys_using_trusted"></a>

若要使用信任的金鑰來包裝資料金鑰 AWS CloudHSM，您必須完成三個基本步驟：

1. 對於您計劃使用可信任金鑰包裝的資料金鑰，請將其 `CKA_WRAP_WITH_TRUSTED` 屬性設定為 true。

1. 對於您計劃用來包裝資料金鑰的可信任金鑰，請將其 `CKA_TRUSTED` 屬性設定為 true。

1. 使用可受信任金鑰來包裝資料金鑰。

## 步驟 1：將資料金鑰的 `CKA_WRAP_WITH_TRUSTED` 設定為 true
<a name="w2aac15c19c11b7"></a>

對於要包裝的資料金鑰，選擇以下選項之一以將金鑰的 `CKA_WRAP_WITH_TRUSTED` 屬性設定為 true。這樣做會限制資料金鑰，因此應用程式只能使用可信任金鑰來包裝。

### 選項 1：如果產生一個新的金鑰，將 `CKA_WRAP_WITH_TRUSTED` 設定為 true
<a name="w2aac15c19c11b7b5"></a>

使用 [PKCS \$111](pkcs11-library.md)、[JCE](java-library.md) 或 [CloudHSM CLI](cloudhsm_cli.md) 產生金鑰。如需詳細資訊，請參閱下列範例。

------
#### [ PKCS \$111 ]

若要使用 PKCS \$111 產生金鑰，您需要將金鑰的 `CKA_WRAP_WITH_TRUSTED` 屬性設定為 true。為此，請先將此屬性包含在金鑰的 `CK_ATTRIBUTE template` 中，然後將屬性設定為 true，如下列範例所示：

```
CK_BYTE_PTR label = "test_key";
CK_ATTRIBUTE template[] = {
        {CKA_WRAP_WITH_TRUSTED, &true_val,         sizeof(CK_BBOOL)},
        {CKA_LABEL,             label,             strlen(label)},
        ...
};
```

如需詳細資訊，請參閱[使用 PKCS \$111 產生金鑰的公開示範範例](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/generate)。

------
#### [ JCE ]

若要使用 JCE 產生金鑰，您需要將金鑰的 `WRAP_WITH_TRUSTED` 屬性設定為 true。為此，請先將此屬性包含在金鑰的 `KeyAttributesMap` 中，然後將屬性設定為 true，如下列範例所示：

```
final String label = "test_key";
final KeyAttributesMap keySpec = new KeyAttributesMap();
keySpec.put(KeyAttribute.WRAP_WITH_TRUSTED, true);
keySpec.put(KeyAttribute.LABEL, label);
...
```

如需詳細資訊，請參閱[使用 JCE 產生金鑰的公開示範範例](https://docs.aws.amazon.com/cloudhsm/latest/userguide/java-samples.html#java-samples-code_5)。

------
#### [ CloudHSM CLI ]

若要使用 CloudHSM CLI 產生金鑰，您需要將金鑰的 `wrap-with-trusted` 屬性設定為 true。為此，請將 `wrap-with-trusted=true` 包含在適合金鑰產生命令的引數：
+ 對於對稱金鑰，請將 `wrap-with-trusted` 新增至 `attributes` 引數中。
+ 對於公有金鑰，請將 `wrap-with-trusted` 新增至 `public-attributes` 引數中。
+ 對於私有金鑰，請將 `wrap-with-trusted` 新增至 `private-attributes` 引數中。

如需關於產生金鑰對的詳細資訊，請參閱 [CloudHSM CLI 中的 generate-asymmetric-pair 類別](cloudhsm_cli-key-generate-asymmetric-pair.md)。

如需關於產生對稱金鑰的詳細資訊，請參閱 [CloudHSM CLI 中的產生對稱類別](cloudhsm_cli-key-generate-symmetric.md)。

------

### 選項 2：如果使用現有金鑰，請使用 CloudHSM CLI 將其 `CKA_WRAP_WITH_TRUSTED` 設定為 true
<a name="w2aac15c19c11b7b7"></a>

若要將現有金鑰的 `CKA_WRAP_WITH_TRUSTED` 屬性設定為 true，請依照下列步驟執行：

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

1. 使用 [使用 CloudHSM CLI 設定金鑰的屬性](cloudhsm_cli-key-set-attribute.md) 命令將金鑰的 `wrap-with-trusted` 屬性設定為 true。

   ```
   aws-cloudhsm > key set-attribute --filter attr.label=test_key --name wrap-with-trusted --value true
   {
     "error_code": 0,
     "data": {
       "message": "Attribute set successfully"
     }
   }
   ```

## 步驟 2：將可信任金鑰的 `CKA_TRUSTED` 設定為 true
<a name="w2aac15c19c11b9"></a>

若要讓金鑰成為可信任金鑰，其 `CKA_TRUSTED` 屬性必須設定為 true。您可以使用 CloudHSM CLI 或 CloudHSM 管理公用程式 (CMU) 來執行此操作。
+ 如果使用 CloudHSM CLI 設定金鑰的 `CKA_TRUSTED` 屬性，請參閱 [使用 CloudHSM CLI 將金鑰標記為信任](manage-keys-cloudhsm-cli-trusted.md)。
+ 如果使用 CMU 來設定金鑰的 `CKA_TRUSTED` 屬性，請參閱 [如何使用 AWS CloudHSM Management Utility 將金鑰標記為受信任](cloudhsm_using_trusted_keys_control_key_wrap.md)。

## 步驟 3。使用可受信任金鑰來包裝資料金鑰
<a name="w2aac15c19c11c11"></a>

若要使用您在步驟 2 中設定的可信任金鑰來包裝步驟 1 所述的資料金鑰，請參閱下列連結以取得程式碼範例。每個都示範如何包裝金鑰。
+ [AWS CloudHSM PKCS \$111 範例](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/wrapping)
+ [AWS CloudHSM JCE 範例](https://github.com/aws-samples/aws-cloudhsm-jce-examples/tree/sdk5/src/main/java/com/amazonaws/cloudhsm/examples)

# 如何使用 的信任金鑰來取消包裝資料金鑰 AWS CloudHSM
<a name="unwrap_keys_using_trusted"></a>

若要在 中取消包裝資料金鑰 AWS CloudHSM，您需要已`CKA_UNWRAP`設為 true 的信任金鑰。若要成為金鑰，其還必須滿足下列條件：
+ 金鑰的 `CKA_TRUSTED` 屬性必須設定為 true。
+ 金鑰必須使用 `CKA_UNWRAP_TEMPLATE` 和相關屬性來指定資料金鑰在取消包裝後可以執行的動作。例如，如果您希望取消包裝的金鑰不可匯出，您可以將 `CKA_EXPORTABLE = FALSE` 設定為 `CKA_UNWRAP_TEMPLATE` 的一部分。

**注意**  
`CKA_UNWRAP_TEMPLATE` 僅可與 PKCS \$111 一同使用。

當應用程式提交要取消包裝的金鑰時，應用程式也可以提供自有的取消包裝範本。如果您指定取消包裝範本，且應用程式提供了自有的取消包裝範本，則 HSM 會使用這兩個範本將屬性名稱和值套用於金鑰。但是，如果在取消包裝請求期間，可信任金鑰中的值與應用程式提供的屬性 `CKA_UNWRAP_TEMPLATE` 衝突，則取消包裝請求會失敗。

若要查看關於使用可信任金鑰取消包裝金鑰的範例，請參閱[此 PKCS \$111 範例](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/unwrap_with_template.c)。

# 使用 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": []
  }
}
```

# 使用 AWS CloudHSM KMU 進行金鑰管理
<a name="manage-keys-kmu-cmu"></a>

如果使用[最新的 SDK 版本系列](use-hsm.md)，請使用 [CloudHSM CLI](cloudhsm_cli.md) 來管理 AWS CloudHSM 叢集中的金鑰。

如果使用[先前的 SDK 版本系列](choose-client-sdk.md)，您可以使用 key\$1mgmt\$1util (KMU) 命令列工具來管理 AWS CloudHSM 叢集中硬體安全模組 (HSM) 上的金鑰。您必須先啟動 AWS CloudHSM 用戶端、啟動 key\$1mgmt\$1util 並登入 HSMs，才能管理金鑰。如需詳細資訊，請參閱 [key\$1mgmt\$1util 的入門指南](key_mgmt_util-getting-started.md)。
+ [使用可信任金鑰](cloudhsm_using_trusted_keys_control_key_wrap.md)說明如何使用 PKCS \$111 程式庫屬性和 CMU 來建立可信任金鑰以保護資料的安全。
+ [產生金鑰](generate-keys.md)具有產生金鑰的說明，包括對稱金鑰、RSA 金鑰和 EC 金鑰。
+ [匯入金鑰](import-keys.md)提供金鑰擁有者如何匯入金鑰的詳細資訊。
+ [匯出金鑰](export-keys.md)提供金鑰擁有者如何匯出金鑰的詳細資訊。
+ [刪除金鑰](delete-keys.md)提供金鑰擁有者如何刪除金鑰的詳細資訊。
+ [共用和取消共用金鑰](share-keys.md)詳細說明金鑰擁有者如何共用和取消共用金鑰。

# 使用 AWS CloudHSM KMU 產生金鑰
<a name="generate-keys"></a>

若要在硬體安全模組 (HSM) 上產生金鑰，請在 AWS CloudHSM key\$1mgmt\$1util (KMU) 中使用對應至您要產生之金鑰類型的 命令。

**Topics**
+ [產生對稱金鑰](generate-symmetric-keys.md)
+ [產生 RSA 金鑰對](generate-rsa-key-pairs.md)
+ [產生 ECC (橢圓曲線密碼編譯) 金鑰對](generate-ecc-key-pairs.md)

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

使用 AWS CloudHSM key\$1mgmt\$1util (KMU) 中的 [genSymKey](key_mgmt_util-genSymKey.md) 命令來產生 AES 和其他類型的對稱金鑰 AWS CloudHSM。若要查看所有可用的選項，請使用 **genSymKey -h** 命令。

以下範例建立 256 位元 AES 金鑰。

```
Command: genSymKey -t 31 -s 32 -l aes256
Cfm3GenerateSymmetricKey returned: 0x00 : HSM Return: SUCCESS

Symmetric Key Created.  Key Handle: 524295

Cluster Error Status
Node id 0 and err state 0x00000000 : HSM Return: SUCCESS
Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
Node id 2 and err state 0x00000000 : HSM Return: SUCCESS
```

# 使用 AWS CloudHSM KMU 產生 RSA 金鑰對
<a name="generate-rsa-key-pairs"></a>

若要產生 的 RSA 金鑰對 AWS CloudHSM，請在 AWS CloudHSM key\$1mgmt\$1util 中使用 [genRSAKeyPair](key_mgmt_util-genRSAKeyPair.md) 命令。若要查看所有可用的選項，請使用 **genRSAKeyPair -h** 命令。

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

```
Command: genRSAKeyPair -m 2048 -e 65537 -l rsa2048
Cfm3GenerateKeyPair returned: 0x00 : HSM Return: SUCCESS

Cfm3GenerateKeyPair:    public key handle: 524294    private key handle: 524296

Cluster Error Status
Node id 0 and err state 0x00000000 : HSM Return: SUCCESS
Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
Node id 2 and err state 0x00000000 : HSM Return: SUCCESS
```

# 使用 AWS CloudHSM KMU 產生 ECC （橢圓曲線密碼編譯） 金鑰對
<a name="generate-ecc-key-pairs"></a>

若要產生 的 ECC 金鑰對 AWS CloudHSM，請在 AWS CloudHSM key\$1mgmt\$1util 中使用 [genECCKeyPair](key_mgmt_util-genECCKeyPair.md) 命令。若要查看所有可用的選項，包括支援的橢圓曲線清單，請使用 **genECCKeyPair -h** 命令。

以下範例使用 [NIST FIPS 出版物 186-4](http://dx.doi.org/10.6028/NIST.FIPS.186-4) 中定義的 P-384 橢圓曲線來產生 ECC 金鑰對。

```
Command: genECCKeyPair -i 14 -l ecc-p384
Cfm3GenerateKeyPair returned: 0x00 : HSM Return: SUCCESS

Cfm3GenerateKeyPair:    public key handle: 524297    private key handle: 524298

Cluster Error Status
Node id 0 and err state 0x00000000 : HSM Return: SUCCESS
Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
Node id 2 and err state 0x00000000 : HSM Return: SUCCESS
```

# 使用 AWS CloudHSM KMU 匯入金鑰
<a name="import-keys"></a>

若要使用 key\$1mgmt AWS CloudHSM \$1util 將對稱金鑰和非對稱私有金鑰匯入硬體安全模組 (HSM)，您必須先在 HSM 上建立包裝金鑰。您可以直接匯入公有金鑰，而不需包裝金鑰。

**Topics**
+ [匯入私密金鑰](import-secret-keys.md)
+ [匯入公有金鑰](import-public-keys.md)

# 使用 AWS CloudHSM KMU 匯入私密金鑰
<a name="import-secret-keys"></a>

完成下列步驟， AWS CloudHSM 使用 key\$1mgmt\$1util (KMU) 將私密金鑰匯入 。匯入私密金鑰之前，請先儲存為檔案。將對稱金鑰儲存為原始位元組，將非對稱私有金鑰儲存為 PEM 格式。

此範例示範如何將檔案中的純文字私密金鑰匯入 HSM。若要將檔案中的加密金鑰匯入 HSM，請使用 [unWrapKey](key_mgmt_util-unwrapKey.md) 命令。

**匯入私密金鑰**

1. 使用 [genSymKey](key_mgmt_util-genSymKey.md) 命令來建立包裝金鑰。以下命令會建立僅對目前工作階段而言有效的 128 位元 AES 包裝金鑰。您可以使用工作階段金鑰或持久性金鑰做為包裝金鑰。

   ```
   Command: genSymKey -t 31 -s 16 -sess -l import-wrapping-key
   Cfm3GenerateSymmetricKey returned: 0x00 : HSM Return: SUCCESS
   
   Symmetric Key Created.  Key Handle: 524299
   
   Cluster Error Status
   Node id 2 and err state 0x00000000 : HSM Return: SUCCESS
   ```

1. 依據您要匯入的私密金鑰類型而定，使用以下其中一個命令。
   + 若要匯入對稱金鑰，請使用 [imSymKey](key_mgmt_util-imSymKey.md) 命令。以下命令使用上個步驟中建立的包裝金鑰，從名為 `aes256.key` 的檔案匯入 AES 金鑰。若要查看所有可用的選項，請使用 **imSymKey -h** 命令。

     ```
     Command: imSymKey -f aes256.key -t 31 -l aes256-imported -w 524299
     Cfm3WrapHostKey returned: 0x00 : HSM Return: SUCCESS
     
     Cfm3CreateUnwrapTemplate returned: 0x00 : HSM Return: SUCCESS
     
     Cfm3UnWrapKey returned: 0x00 : HSM Return: SUCCESS
     
     Symmetric Key Unwrapped.  Key Handle: 524300
     
     Cluster Error Status
     Node id 0 and err state 0x00000000 : HSM Return: SUCCESS
     Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
     Node id 2 and err state 0x00000000 : HSM Return: SUCCESS
     ```
   + 若要匯入非對稱私有金鑰，請使用 [importPrivateKey](key_mgmt_util-importPrivateKey.md) 命令。以下命令使用上個步驟中建立的包裝金鑰，從名為 `rsa2048.key` 的檔案匯入私有金鑰。若要查看所有可用的選項，請使用 **importPrivateKey -h** 命令。

     ```
     Command: importPrivateKey -f rsa2048.key -l rsa2048-imported -w 524299
     BER encoded key length is 1216
     
     Cfm3WrapHostKey returned: 0x00 : HSM Return: SUCCESS
     
     Cfm3CreateUnwrapTemplate returned: 0x00 : HSM Return: SUCCESS
     
     Cfm3UnWrapKey returned: 0x00 : HSM Return: SUCCESS
     
     Private Key Unwrapped.  Key Handle: 524301
     
     Cluster Error Status
     Node id 0 and err state 0x00000000 : HSM Return: SUCCESS
     Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
     Node id 2 and err state 0x00000000 : HSM Return: SUCCESS
     ```

# 使用 AWS CloudHSM KMU 匯入公有金鑰
<a name="import-public-keys"></a>

使用 AWS CloudHSM key\$1mgmt\$1util (KMU) 中的 [importPubKey](key_mgmt_util-importPubKey.md) 命令來匯入公有金鑰。若要查看所有可用的選項，請使用 **importPubKey -h** 命令。

以下範例會從名為 `rsa2048.pub` 的檔案匯入 RSA 公有金鑰。

```
Command: importPubKey -f rsa2048.pub -l rsa2048-public-imported
Cfm3CreatePublicKey returned: 0x00 : HSM Return: SUCCESS

Public Key Handle: 524302

Cluster Error Status
Node id 0 and err state 0x00000000 : HSM Return: SUCCESS
Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
Node id 2 and err state 0x00000000 : HSM Return: SUCCESS
```

# 使用 AWS CloudHSM KMU 匯出金鑰
<a name="export-keys"></a>

若要使用 key AWS CloudHSM \$1mgmt\$1util (KMU) 從硬體安全模組 (HSM) 匯出 AWS CloudHSM 私密金鑰，也就是對稱金鑰和非對稱私有金鑰，您必須先建立包裝金鑰。您可以直接匯出公有金鑰，而不需包裝金鑰。

只有金鑰擁有者可以匯出金鑰。共用金鑰的使用者可以在密碼編譯操作中使用此金鑰，但無法匯出此金鑰。執行這個範例時，請務必匯出您建立的金鑰。

**重要**  
[exSymKey](key_mgmt_util-exSymKey.md) 命令可將私密金鑰的純文字 (未加密) 複本寫入檔案。匯出程序需要包裝金鑰，但檔案中的金鑰***不是***包裝金鑰。若要匯出金鑰的包裝 (加密) 複本，請使用 [wrapKey](key_mgmt_util-wrapKey.md) 命令。

**Topics**
+ [匯出私密金鑰](export-secret-keys.md)
+ [匯出公有金鑰](export-public-keys.md)

# 使用 AWS CloudHSM KMU 匯出私密金鑰
<a name="export-secret-keys"></a>

完成下列步驟， AWS CloudHSM 使用 key\$1mgmt\$1util (KMU) 從 匯出私密金鑰。

**匯出私密金鑰**

1. 使用 [genSymKey](key_mgmt_util-genSymKey.md) 命令來建立包裝金鑰。以下命令會建立僅對目前工作階段而言有效的 128 位元 AES 包裝金鑰。

   ```
   Command: genSymKey -t 31 -s 16 -sess -l export-wrapping-key
   Cfm3GenerateSymmetricKey returned: 0x00 : HSM Return: SUCCESS
   
   Symmetric Key Created.  Key Handle: 524304
   
   Cluster Error Status
   Node id 2 and err state 0x00000000 : HSM Return: SUCCESS
   ```

1. 依據您要匯出的私密金鑰類型而定，使用以下其中一個命令。
   + 若要匯出對稱金鑰，請使用 [exSymKey](key_mgmt_util-exSymKey.md) 命令。以下命令會將 AES 金鑰匯出到名為 `aes256.key.exp` 的檔案。若要查看所有可用的選項，請使用 **exSymKey -h** 命令。

     ```
     Command: exSymKey -k 524295 -out aes256.key.exp -w 524304
     Cfm3WrapKey returned: 0x00 : HSM Return: SUCCESS
     
     Cfm3UnWrapHostKey returned: 0x00 : HSM Return: SUCCESS
     
     
     Wrapped Symmetric Key written to file "aes256.key.exp"
     ```
**注意**  
命令的輸出顯示「包裝對稱金鑰」已寫入輸出檔。不過，輸出檔案包含純文字 (而非包裝) 金鑰。若要將包裝 (加密) 金鑰匯出到檔案，請使用 [wrapKey](key_mgmt_util-wrapKey.md) 命令。
   + 若要匯出私有金鑰，請使用 **exportPrivateKey** 命令。以下命令會將私有金鑰匯出到名為 `rsa2048.key.exp` 的檔案。若要查看所有可用的選項，請使用 **exportPrivateKey -h** 命令。

     ```
     Command: exportPrivateKey -k 524296 -out rsa2048.key.exp -w 524304
     Cfm3WrapKey returned: 0x00 : HSM Return: SUCCESS
     
     Cfm3UnWrapHostKey returned: 0x00 : HSM Return: SUCCESS
     
     PEM formatted private key is written to rsa2048.key.exp
     ```

# 使用 AWS CloudHSM KMU 匯出公有金鑰
<a name="export-public-keys"></a>

使用 AWS CloudHSM key\$1mgmt\$1util (KMU) 中的 **exportPubKey**命令匯出公有金鑰。若要查看所有可用的選項，請使用 **exportPubKey -h** 命令。

以下範例將 RSA 公有金鑰匯出到名為 `rsa2048.pub.exp` 的檔案。

```
Command: exportPubKey -k 524294 -out rsa2048.pub.exp
PEM formatted public key is written to rsa2048.pub.key

Cfm3ExportPubKey returned: 0x00 : HSM Return: SUCCESS
```

# 使用 KMU 和 CMU 刪除金鑰
<a name="delete-keys"></a>

使用 [deleteKey](key_mgmt_util-deleteKey.md) 命令來刪除金鑰，如下列範例所示。只有金鑰擁有者可以刪除金鑰。

```
Command: deleteKey -k 524300
Cfm3DeleteKey returned: 0x00 : HSM Return: SUCCESS

Cluster Error Status
Node id 0 and err state 0x00000000 : HSM Return: SUCCESS
Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
Node id 2 and err state 0x00000000 : HSM Return: SUCCESS
```

# 與 KMU 和 CMU 共用和取消共用金鑰
<a name="share-keys"></a>

在 中 AWS CloudHSM，建立金鑰的 CU 擁有金鑰。擁有者可以管理金鑰、匯出和刪除金鑰，以及可在密碼編譯操作中使用金鑰。擁有者還可以向其他 CU 使用者共用金鑰。共用金鑰的使用者可以在密碼編譯操作中使用此金鑰，但無法匯出或刪除此金鑰，或再與其他使用者共用。

當您建立金鑰時，您可以與其他 CU 使用者共用金鑰，例如使用 [genSymKey](key_mgmt_util-genSymKey.md) 或 [genRSAKeyPair](key_mgmt_util-genRSAKeyPair.md) 命令的 `-u` 參數。若要將現有的金鑰共用給另一個 HSM 使用者，請使用 [cloudhsm\$1mgmt\$1util](cloudhsm_mgmt_util.md) 命令列工具。這不同於本區段中大多數使用 [key\$1mgmt\$1util](key_mgmt_util.md) 命令列工具的任務。

您必須啟動 cloudhsm\$1mgmt\$1util、啟用端對端加密，並且登入 HSM，才能共用金鑰。若要共用金鑰，請以擁有金鑰的加密使用者 (CU) 身分登入 HSM。只有金鑰擁有者可以共用金鑰。

使用 **shareKey** 命令，並指定金鑰控點及一或多位使用者的 ID，以共用或取消共用金鑰。若要與多個使用者共用或取消共用，請指定以逗號分隔的使用者 ID 清單。若要共用金鑰，請使用 `1` 做為命令的最後一個參數，如下列範例所示。若要取消共用，請使用 `0`。

```
aws-cloudhsm > shareKey 524295 4 1
*************************CAUTION********************************
This is a CRITICAL operation, should be done on all nodes in the
cluster. AWS does NOT synchronize these changes automatically with the
nodes on which this operation is not executed or failed, please
ensure this operation is executed on all nodes in the cluster.
****************************************************************

Do you want to continue(y/n)? y
shareKey success on server 0(10.0.2.9)
shareKey success on server 1(10.0.3.11)
shareKey success on server 2(10.0.1.12)
```

下列顯示 **shareKey** 命令的語法。

```
aws-cloudhsm > shareKey <key handle> <user ID> <Boolean: 1 for share, 0 for unshare>
```

# 如何使用 AWS CloudHSM Management Utility 將金鑰標記為受信任
<a name="cloudhsm_using_trusted_keys_control_key_wrap"></a>

本節中的內容提供使用 AWS CloudHSM Management Utility (CMU) 將金鑰標記為信任的指示。

1. 使用 [loginHSM](cloudhsm_mgmt_util-loginLogout.md) 命令，以加密管理員 (CO) 身分登入。

1. 使用 [使用 CMU 設定 AWS CloudHSM 金鑰的屬性](cloudhsm_mgmt_util-setAttribute.md) 命令，將 `OBJ_ATTR_TRUSTED` (值 `134`) 設定為 true (`1`)。

   ```
   aws-cloudhsm > setAttribute <Key Handle> 134 1
   ```