Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# AWS CloudHSM Befehlszeilenschnittstelle (CLI)
<a name="cloudhsm_cli"></a>

**CloudHSM CLI** hilft Administratoren bei der Verwaltung von Benutzern und Krypto-Benutzern bei der Verwaltung von Schlüsseln in ihrem Cluster in. AWS CloudHSM Die CLI enthält Tools, mit denen Benutzer erstellt, gelöscht und aufgelistet, Benutzerkennwörter geändert und die Benutzer-Multi-Faktor-Authentifizierung (MFA) aktualisiert werden können. Sie umfasst auch Befehle zum Generieren, Löschen, Importieren und Exportieren von Schlüsseln, zum Abrufen und Festlegen von Attributen, zum Suchen von Schlüsseln und zum Ausführen kryptografischer Operationen.

Eine definierte Liste von CloudHSM-CLI-Benutzern finden Sie unter [HSM-Benutzerverwaltung mit CloudHSM CLI](manage-hsm-users-chsm-cli.md). Eine definierte Liste von Schlüsselattributen für die CloudHSM-CLI finden Sie unter. [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md) Informationen zur Verwendung der CloudHSM-CLI zur Verwaltung von Schlüsseln finden Sie unter. [Schlüsselverwaltung mit CloudHSM CLI](manage-keys-chsm-cli.md)

Informationen zum schnellen Einstieg finden Sie unter [Erste Schritte mit der AWS CloudHSM Befehlszeilenschnittstelle (CLI)](cloudhsm_cli-getting-started.md). Detaillierte Informationen über die CloudHSM-CLI-Befehle und Beispiele zu ihrer Verwendung finden Sie unter [Referenz für CloudHSM-CLI-Befehle](cloudhsm_cli-reference.md). 

**Topics**
+ [Unterstützte Plattformen](cloudhsm-cli-support.md)
+ [Erste Schritte](cloudhsm_cli-getting-started.md)
+ [Befehlsmodi](cloudhsm_cli-modes.md)
+ [Schlüsselattribute](cloudhsm_cli-key-attributes.md)
+ [Erweiterte -Konfigurationen](cloudhsm_cli-configs.md)
+ [Referenz](cloudhsm_cli-reference.md)

# AWS CloudHSM Von der Befehlszeilenschnittstelle (CLI) unterstützte Plattformen
<a name="cloudhsm-cli-support"></a>

In diesem Thema werden die Linux- und Windows-Plattformen beschrieben, die von der AWS CloudHSM CLI unterstützt werden.

## Linux-Support
<a name="w2aac23c15c11b5"></a>


| Unterstützte Plattformen | X86\$164-Architektur | ARM-Architektur | 
| --- | --- | --- | 
| Amazon Linux 2 | Ja | Ja | 
| Amazon Linux 2023 | Ja | Ja | 
| Red Hat Enterprise Linux 8 (8.3\$1) | Ja | Ja | 
| RedHat Enterprise Linux 9 (9,2 und höher) | Ja | Ja | 
| RedHat Enterprise Linux 10 (10.0\$1) | Ja | Ja | 
| Ubuntu 22.04 LTS | Ja | Ja | 
| Ubuntu 24.04 LTS | Ja | Ja | 
+ SDK 5.16 war die letzte Version, die Unterstützung für die Ubuntu 20.04 LTS-Plattform bot. [Weitere Informationen finden Sie auf der Ubuntu-Website.](https://ubuntu.com/blog/ubuntu-20-04-lts-end-of-life-standard-support-is-coming-to-an-end-heres-how-to-prepare)
+ SDK 5.12 war die letzte Version, die CentOS 7 (7.8\$1) Plattformunterstützung bot. Weitere Informationen finden Sie auf der [CentOS-Website](https://blog.centos.org/2023/04/end-dates-are-coming-for-centos-stream-8-and-centos-linux-7/).
+ SDK 5.12 war die letzte Version, die Unterstützung für die Plattform Red Hat Enterprise Linux 7 (7.8\$1) bot. Weitere Informationen finden Sie auf der [Red](https://www.redhat.com/en/technologies/linux-platforms/enterprise-linux/rhel-7-end-of-maintenance) Hat Website.
+ SDK 5.4.2 war die letzte Version, die CentOS 8-Plattformunterstützung bot. Weitere Informationen finden Sie auf der [CentOS-Website](https://www.centos.org/centos-linux-eol/).

## Windows-Unterstützung
<a name="w2aac23c15c11b7"></a>
+ Microsoft Windows Server 2016
+ Microsoft Windows Server 2019
+ Microsoft Windows Server 2022
+ Microsoft Windows Server 2025

# Erste Schritte mit der AWS CloudHSM Befehlszeilenschnittstelle (CLI)
<a name="cloudhsm_cli-getting-started"></a>

Mit der CloudHSM CLI Command Line Interface (CLI) können Sie Benutzer in Ihrem AWS CloudHSM Cluster verwalten. Verwenden Sie dieses Thema, um mit grundlegenden Benutzerverwaltungsaufgaben des Hardware Security Module (HSM) zu beginnen, z. B. Benutzer erstellen, Benutzer auflisten und CloudHSM CLI mit dem Cluster verbinden.

**Topics**
+ [Installieren Sie die CloudHSM-CLI](w2aac23c15c13b7.md)
+ [Verwenden Sie die CloudHSM-CLI](cloudhsm_cli-getting-started-use.md)

# Installieren Sie die CloudHSM-CLI
<a name="w2aac23c15c13b7"></a>

Verwenden Sie die folgenden Befehle, um die CloudHSM-CLI für herunterzuladen und zu installieren. AWS CloudHSM

------
#### [ Amazon Linux 2023 ]

Amazon Linux 2023 auf x86\$164-Architektur:

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-cli-latest.amzn2023.x86_64.rpm
```

```
$ sudo yum install ./cloudhsm-cli-latest.amzn2023.x86_64.rpm
```

Amazon Linux 2023 zur ARM64 Architektur:

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-cli-latest.amzn2023.aarch64.rpm
```

```
$ sudo yum install ./cloudhsm-cli-latest.amzn2023.aarch64.rpm
```

------
#### [ Amazon Linux 2 ]

Amazon Linux 2 auf x86\$164-Architektur:

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-cli-latest.el7.x86_64.rpm
```

```
$ sudo yum install ./cloudhsm-cli-latest.el7.x86_64.rpm
```

Amazon Linux 2 zur ARM64 Architektur:

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-cli-latest.el7.aarch64.rpm
```

```
$ sudo yum install ./cloudhsm-cli-latest.el7.aarch64.rpm
```

------
#### [ RHEL 10 (10.0\$1) ]

RHEL 10 auf der x86\$164-Architektur:

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-cli-latest.el10.x86_64.rpm
```

```
$ sudo yum install ./cloudhsm-cli-latest.el10.x86_64.rpm
```

RHEL 10 zur Architektur: ARM64 

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-cli-latest.el10.aarch64.rpm
```

```
$ sudo yum install ./cloudhsm-cli-latest.el10.aarch64.rpm
```

------
#### [ RHEL 9 (9.2\$1) ]

RHEL 9 auf der x86\$164-Architektur:

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-cli-latest.el9.x86_64.rpm
```

```
$ sudo yum install ./cloudhsm-cli-latest.el9.x86_64.rpm
```

RHEL 9 zur Architektur: ARM64 

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-cli-latest.el9.aarch64.rpm
```

```
$ sudo yum install ./cloudhsm-cli-latest.el9.aarch64.rpm
```

------
#### [ RHEL 8 (8.3\$1) ]

RHEL 8 auf x86\$164-Architektur:

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-cli-latest.el8.x86_64.rpm
```

```
$ sudo yum install ./cloudhsm-cli-latest.el8.x86_64.rpm
```

RHEL 8 zur ARM64 Architektur:

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-cli-latest.el8.aarch64.rpm
```

```
$ sudo yum install ./cloudhsm-cli-latest.el8.aarch64.rpm
```

------
#### [ Ubuntu 24.04 LTS ]

Ubuntu 24.04 LTS auf der x86\$164-Architektur:

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-cli_latest_u24.04_amd64.deb
```

```
$ sudo apt install ./cloudhsm-cli_latest_u24.04_amd64.deb
```

Ubuntu 24.04 LTS zur Architektur: ARM64 

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-cli_latest_u24.04_arm64.deb
```

```
$ sudo apt install ./cloudhsm-cli_latest_u24.04_arm64.deb
```

------
#### [ Ubuntu 22.04 LTS ]

Ubuntu 22.04 LTS auf der x86\$164-Architektur:

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-cli_latest_u22.04_amd64.deb
```

```
$ sudo apt install ./cloudhsm-cli_latest_u22.04_amd64.deb
```

Ubuntu 22.04 LTS zur Architektur: ARM64 

```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-cli_latest_u22.04_arm64.deb
```

```
$ sudo apt install ./cloudhsm-cli_latest_u22.04_arm64.deb
```

------
#### [ Windows Server 2022 ]

Öffnen Sie Windows Server 2022 auf einer x86\$164-Architektur PowerShell als Administrator und führen Sie den folgenden Befehl aus:

```
PS C:\> wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Windows/AWSCloudHSMCLI-latest.msi -Outfile C:\AWSCloudHSMCLI-latest.msi
```

```
PS C:\> Start-Process msiexec.exe -ArgumentList '/i C:\AWSCloudHSMCLI-latest.msi /quiet /norestart /log C:\client-install.txt' -Wait
```

------
#### [ Windows Server 2019 ]

Öffnen Sie Windows Server 2019 auf einer x86\$164-Architektur PowerShell als Administrator und führen Sie den folgenden Befehl aus:

```
PS C:\> wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Windows/AWSCloudHSMCLI-latest.msi -Outfile C:\AWSCloudHSMCLI-latest.msi
```

```
PS C:\> Start-Process msiexec.exe -ArgumentList '/i C:\AWSCloudHSMCLI-latest.msi /quiet /norestart /log C:\client-install.txt' -Wait
```

------
#### [ Windows Server 2016 ]

Öffnen Sie Windows Server 2016 auf einer x86\$164-Architektur PowerShell als Administrator und führen Sie den folgenden Befehl aus:

```
PS C:\> wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Windows/AWSCloudHSMCLI-latest.msi -Outfile C:\AWSCloudHSMCLI-latest.msi
```

```
PS C:\> Start-Process msiexec.exe -ArgumentList '/i C:\AWSCloudHSMCLI-latest.msi /quiet /norestart /log C:\client-install.txt' -Wait
```

------

Verwenden Sie die folgenden Befehle, um CloudHSM-CLI zu konfigurieren.

**So bootstrappen Sie eine Linux-EC2-Instance für Client-SDK 5**
+  Verwenden Sie das Configure-Tool, um die IP-Adresse der HSM(s) in Ihrem Cluster anzugeben. 

  ```
  $ sudo /opt/cloudhsm/bin/configure-cli -a <The ENI IPv4 / IPv6 addresses of the HSMs>
  ```

**So bootstrappen Sie eine Windows-EC2-Instance für Client-SDK 5**
+  Verwenden Sie das Configure-Tool, um die IP-Adresse der HSM(s) in Ihrem Cluster anzugeben. 

  ```
  PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-cli.exe" -a <The ENI IPv4 / IPv6 addresses of the HSMs>
  ```

# Verwenden Sie die CloudHSM-CLI
<a name="cloudhsm_cli-getting-started-use"></a>

Verwenden Sie die folgenden Befehle, um die CloudHSM-CLI zu starten und zu verwenden.

1. Verwenden Sie den folgenden Befehl, um die CloudHSM-CLI zu starten.

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

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

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

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

------

1. Verwenden Sie den **login**-Befehl, um sich beim Cluster anzumelden. Alle Benutzer können diesen Befehl verwenden.

   Mit dem Befehl im folgenden Beispiel wird *admin* angemeldet, das Standard-[Admin](understanding-users.md)-Konto. Sie legen das Passwort für diesen Benutzer nach der [Aktivierung des Clusters](activate-cluster.md) fest.

   ```
   aws-cloudhsm > login --username admin --role admin
   ```

   Sie werden vom System aufgefordert, Ihr Passwort einzugeben. Sie geben das Passwort ein und die Ausgabe zeigt, dass der Befehl erfolgreich war.

   ```
   Enter password:
   {
     "error_code": 0,
     "data": {
       "username": "admin",
       "role": "admin"
     }
   }
   ```

1. Führen Sie den **user list**-Befehl aus, um alle Benutzer im Cluster aufzulisten.

   ```
   aws-cloudhsm > user list
   {
     "error_code": 0,
     "data": {
       "users": [
         {
           "username": "admin",
           "role": "admin",
           "locked": "false",
           "mfa": [],
           "cluster-coverage": "full"
         },
         {
           "username": "app_user",
           "role": "internal(APPLIANCE_USER)",
           "locked": "false",
           "mfa": [],
           "cluster-coverage": "full"
         }
       ]
     }
   }
   ```

1.  Verwenden Sie **user create**, um einen CU-Benutzer mit dem Namen **example\$1user** zu erstellen. 

   Sie können erstellen CUs , weil Sie sich in einem vorherigen Schritt als Admin-Benutzer angemeldet haben. Nur Admin-Benutzer können Benutzerverwaltungsaufgaben wie das Erstellen und Löschen von Benutzern und das Ändern der Passwörter anderer Benutzer ausführen. 

   ```
   aws-cloudhsm > user create --username example_user --role crypto-user     
   Enter password:
   Confirm password:
   {
    "error_code": 0,
    "data": {
      "username": "example_user",
      "role": "crypto-user"
    }
   }
   ```

1.  Verwenden Sie **user list**, um alle Benutzer im Cluster aufzulisten. 

   ```
   aws-cloudhsm > user list
   {
     "error_code": 0,
     "data": {
       "users": [
         {
           "username": "admin",
           "role": "admin",
           "locked": "false",
           "mfa": [],
           "cluster-coverage": "full"
         },
         {
           "username": "example_user",
           "role": "crypto_user",
           "locked": "false",
           "mfa": [],
           "cluster-coverage": "full"
         },
         {
           "username": "app_user",
           "role": "internal(APPLIANCE_USER)",
           "locked": "false",
           "mfa": [],
           "cluster-coverage": "full"
         }
       ]
     }
   }
   ```

1. Verwenden Sie den **logout** Befehl, um sich vom AWS CloudHSM Cluster abzumelden.

   ```
   aws-cloudhsm > logout
   {
     "error_code": 0,
     "data": "Logout successful"
   }
   ```

1. Verwenden Sie den **quit**-Befehl, um die CLI zu stoppen.

   ```
   aws-cloudhsm > quit
   ```

# Befehlsmodi in der CloudHSM-CLI
<a name="cloudhsm_cli-modes"></a>

In der CloudHSM-CLI können Sie Befehle auf zwei verschiedene Arten ausführen: im Einzelbefehlsmodus und im interaktiven Modus. Der interaktive Modus ist für Benutzer konzipiert, und der Einzelbefehlsmodus ist für Skripts konzipiert.

**Anmerkung**  
Alle Befehle funktionieren im interaktiven Modus und im Einzelbefehlsmodus.

## interaktiver Modus
<a name="cloudhsm_cli-mode-interactive"></a>

Verwenden Sie die folgenden Befehle, um den interaktiven CloudHSM-CLI-Modus zu starten

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

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

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

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

------

Wenn Sie die CLI im interaktiven Modus verwenden, können Sie sich mit dem **login**-Befehl bei einem Benutzerkonto anmelden.

```
aws-cloudhsm > login --username <USERNAME> --role ROLE>
```

Um alle CloudHSM-CLI-Befehle auszuführen, führen Sie den folgenden Befehl aus:

```
aws-cloudhsm > help
```

Um die Syntax für einen CloudHSM-CLI-Befehl anzufordern, führen Sie den folgenden Befehl aus:

```
aws-cloudhsm >  help <command-name>
```

Um eine Liste der Benutzer auf dem zu erhalten HSMs, geben Sie ein**user list**.

```
aws-cloudhsm > user list
```

Um Ihre CloudHSM-CLI-Sitzung zu beenden, führen Sie den folgenden Befehl aus:

```
aws-cloudhsm > quit
```

## Einzelbefehlsmodus
<a name="cloudhsm_cli-mode-single-command"></a>

**Anmerkung**  
Wenn Sie den Einzelbefehlsmodus verwenden, müssen Sie alle Sonderzeichen in Umgebungsvariablen und Befehlszeilenargumenten maskieren, die von Ihrer Shell interpretiert werden könnten.

Wenn Sie die CloudHSM-CLI im Einzelbefehlsmodus ausführen, müssen Sie zwei Umgebungsvariablen setzen, um die Anmeldedaten bereitzustellen: CLOUDHSM\$1PIN und CLOUDHSM\$1ROLE:

```
$ export CLOUDHSM_ROLE=admin
```

```
$ export CLOUDHSM_PIN=admin_username:admin_password
```

Danach können Sie Befehle mit den in Ihrer Umgebung gespeicherten Anmeldeinformationen ausführen.

```
$ cloudhsm-cli user change-password --username alice --role crypto-user
Enter password:
Confirm password:
{
    "error_code": 0,
    "data": {
      "username": "alice",
      "role": "crypto-user"
    }
}
```

# Schlüsselattribute für CloudHSM-CLI
<a name="cloudhsm_cli-key-attributes"></a>

In diesem Thema wird beschrieben, wie Sie die CloudHSM-CLI zum Festlegen von Schlüsselattributen verwenden. Ein Schlüsselattribut in der CloudHSM-CLI kann den Typ eines Schlüssels definieren, wie ein Schlüssel funktionieren kann oder wie ein Schlüssel beschriftet wird. Einige Attribute definieren eindeutige Merkmale (z. B. den Typ eines Schlüssels). Andere Attribute können auf true oder false gesetzt werden. Wenn Sie sie ändern, wird entweder ein Teil der Funktionalität des Schlüssels aktiviert oder deaktiviert.

Beispiele zur Verwendung von Schlüsselattributen finden Sie in den Befehlen, die unter dem übergeordneten Befehl [Die Schlüsselkategorie in CloudHSM CLI](cloudhsm_cli-key.md) aufgeführt sind.

Die folgenden Themen enthalten zusätzliche Informationen zu Schlüsselattributen in der CloudHSM-CLI.

**Topics**
+ [Unterstützte Attribute](cloudhsm_cli-key-attributes-table.md)
+ [Prüfwert](chsm-cli-key-attribute-details.md)
+ [Verwandte Themen](chsm_cli-key-attributes-seealso.md)

# Unterstützte Attribute für CloudHSM CLI
<a name="cloudhsm_cli-key-attributes-table"></a>

Als bewährte Methode legen Sie nur Werte für Attribute fest, die Sie einschränken möchten. Wenn Sie keinen Wert angeben, verwendet CloudHSM-CLI den in der folgenden Tabelle angegebenen Standardwert.

In der folgenden Tabelle sind die wichtigsten Attribute, möglichen Werte, Standardwerte und zugehörige Hinweise für die CloudHSM-CLI aufgeführt. Eine leere Zelle in der Spalte **Wert** gibt an, dass dem Attribut kein spezifischer Standardwert zugewiesen ist.


****  

| CloudHSM-CLI-Attribut | Wert | Modifizierbar mit [key set-attribute](cloudhsm_cli-key-set-attribute.md) | Kann bei der Schlüsselerstellung eingestellt werden | 
| --- | --- | --- | --- | 
| always-sensitive |  Der Wert ist `True`, wenn `sensitive` immer auf `True` gesetzt wurde und sich nie geändert hat.  | Nein | Nein | 
| check-value | Der Prüfwert des Schlüssels. Weitere Informationen finden Sie unter [Weitere Details](chsm-cli-key-attribute-details.md). | Nein | Nein | 
| class | Die möglichen Werte lauten: `secret-key`, `public-key` und `private-key`. | Nein | Ja | 
| curve |  Elliptische Kurve, die zur Generierung des EC-Schlüsselpaars verwendet wird. Gültige Werte:`secp224r1`,`secp256r1`,, `prime256v1``secp384r1`, und `secp256k1` `secp521r1` `ed25519` `ed25519`wird nur auf hsm2m.medium-Instances im Nicht-FIPS-Modus unterstützt.  | Nein | Einstellbar mit EC, nicht einstellbar mit RSA | 
| decrypt | Standard: `False` | Ja | Ja | 
| derive | Standard: `False` | Derive kann für hsm2m.medium-Instances festgelegt werden. Es kann nicht für RSA-Schlüssel auf hsm1.medium-Instances festgelegt werden. | Ja | 
| destroyable | Standard: `True` | Ja | Ja | 
| ec-point | Bei EC-Schlüsseln die DER-Kodierung des ANSI ECPoint X9.62-Werts „Q“ in einem Hexadezimalformat. Für andere Schlüsseltypen ist dieses Attribut nicht vorhanden. | Nein | Nein | 
| encrypt | Standard: `False` | Ja | Ja | 
| extractable | Standard: `True` | Nein | Ja | 
| id | Standard: leer | Die ID kann auf hsm2m.medium-Instanzen festgelegt werden. Sie kann nicht auf hsm1.medium-Instances festgelegt werden. | Ja | 
| key-length-bytes | Erforderlich für die Generierung eines AES-Schlüssels.Gültige Werte: `16`, `24` und `32` Byte. | Nein | Nein | 
| key-type | Die möglichen Werte lauten: `aes`, `rsa` und `ec`. | Nein | Ja | 
| label | Standard: leer | Ja | Ja | 
| local | Standard: `True` für Schlüssel, die im HSM generiert wurden, `False` für Schlüssel, die in das HSM importiert wurden. | Nein | Nein | 
| modifiable | Standard: `True` | Kann von „wahr“ auf „falsch“ geändert werden, aber nicht von „falsch“ auf „wahr“. | Ja | 
| modulus | Der Modulus, der zum Generieren eines RSA-Schlüsselpaares verwendet wurde. Für andere Schlüsseltypen ist dieses Attribut nicht vorhanden. | Nein | Nein | 
| modulus-size-bits | Erforderlich für die Generierung eines RSA-Schlüsselpaars.Der Mindestwert ist `2048`. | Nein | Einstellbar mit RSA, nicht einstellbar mit EC | 
| never-extractable |  Der Wert ist `True`, wenn extrahierbar noch nie auf `False` gesetzt wurde. Der Wert ist `False`, wenn extrahierbar jemals auf `True` gesetzt wurde.  | Nein | Nein | 
| private | Standard: `True` | Nein | Ja | 
| public-exponent | Erforderlich für die Generierung eines RSA-Schlüsselpaars.Gültige Werte: Bei diesem Wert muss es sich eine ungerade Zahl gleich oder größer als `65537` handeln. | Nein | Einstellbar mit RSA, nicht einstellbar mit EC | 
| sensitive |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-key-attributes-table.html)  | Nein | Einstellbar mit privaten Schlüsseln, nicht einstellbar mit öffentlichen Schlüsseln. | 
| sign |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-key-attributes-table.html)  | Ja | Ja | 
| token | Standard: `True` | Kann von falsch zu wahr geändert werden, aber nicht von wahr zu falsch. | Ja | 
| trusted | Standard: `False` | Nur Admin-Benutzer können diesen Parameter festlegen. | Nein | 
| unwrap | Standard: False | Ja | Ja, außer für öffentliche Schlüssel. | 
| unwrap-template | Für die Werte sollte die Attributvorlage verwendet werden, die auf jeden Schlüssel angewendet wird, der mit diesem Schlüssel zum Packen entpackt wird. | Ja | Nein | 
| verify |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-key-attributes-table.html)  | Ja | Ja | 
| wrap | Standard: False | Ja | Ja, außer für private Schlüssel. | 
| wrap-template | Für die Werte sollte die Attributvorlage verwendet werden, die dem Schlüssel entspricht, der mit diesem Schlüssel zum Packen gepackt wurde. | Ja | Nein | 
| wrap-with-trusted | Standard: `False` | Ja | Ja | 

# Wert in CloudHSM CLI überprüfen
<a name="chsm-cli-key-attribute-details"></a>

Der *Prüfwert* in der CloudHSM-CLI ist ein 3-Byte-Hash oder eine Prüfsumme eines Schlüssels, der generiert wird, wenn das HSM einen Schlüssel importiert oder generiert. Sie können einen Prüfwert auch außerhalb des HSM berechnen, z. B. nachdem Sie einen Schlüssel exportiert haben. Anschließend können Sie die Prüfwerte vergleichen, um die Identität und Integrität des Schlüssels zu bestätigen. Um den Prüfwert eines Schlüssels zu ermitteln, verwenden Sie die [Schlüsselliste](cloudhsm_cli-key-list.md) mit dem verbose-Flag.

AWS CloudHSM verwendet die folgenden Standardmethoden, um einen Prüfwert zu generieren:
+ **Symmetrische Schlüssel**: Die ersten 3 Byte des Ergebnisses der Verschlüsselung eines Nullblocks mit dem Schlüssel.
+ **Asymmetrische Schlüsselpaare**: Die ersten 3 Byte des SHA-1-Hashs des öffentlichen Schlüssels.
+ **HMAC-Schlüssel**: KCV für HMAC-Schlüssel wird derzeit nicht unterstützt.

# Verwandte Themen für CloudHSM CLI
<a name="chsm_cli-key-attributes-seealso"></a>

In den folgenden Themen finden Sie weitere Informationen zur CloudHSM-CLI.
+ [Die Schlüsselkategorie in CloudHSM CLI](cloudhsm_cli-key.md)
+ [Referenz für CloudHSM-CLI-Befehle](cloudhsm_cli-reference.md)

# Erweiterte Konfigurationen für CloudHSM CLI
<a name="cloudhsm_cli-configs"></a>

Die AWS CloudHSM Befehlszeilenschnittstelle (CLI) umfasst die folgende erweiterte Konfiguration, die nicht Teil der allgemeinen Konfigurationen ist, die die meisten Kunden verwenden. Diese Konfigurationen bieten zusätzliche Funktionen.
+ [Verbindung zu mehreren Clustern herstellen](cloudhsm_cli-configs-multi-cluster.md)

# Verbindung zu mehreren Clustern mit CloudHSM CLI herstellen
<a name="cloudhsm_cli-configs-multi-cluster"></a>

 Mit AWS CloudHSM Client SDK 5 können Sie die CloudHSM-CLI so konfigurieren, dass Verbindungen zu mehreren CloudHSM-Clustern von einer einzigen CLI-Instanz aus möglich sind. 

In den folgenden Themen wird beschrieben, wie Sie die CloudHSM CLI Multi-Cluster-Funktionalität verwenden, um eine Verbindung mit mehreren Clustern herzustellen.

**Topics**
+ [Voraussetzungen](cloudhsm_cli-multi-cluster-prereqs.md)
+ [Konfigurieren Sie die Multi-Cluster-Funktionalität](cloudhsm_cli-multi-cluster-config-run.md)
+ [Fügen Sie einen Cluster hinzu](cloudhsm_cli-multi-cluster-add-cluster.md)
+ [Entfernen Sie einen Cluster](cloudhsm_cli-multi-cluster-remove-cluster.md)
+ [Interagieren Sie mit Clustern](cloudhsm_cli-multi-cluster-usage.md)

# Voraussetzungen für mehrere Cluster AWS CloudHSM
<a name="cloudhsm_cli-multi-cluster-prereqs"></a>

Bevor Sie Ihren Cluster so konfigurieren, dass er eine Verbindung AWS CloudHSM zu mehreren Clustern herstellt, müssen Sie die folgenden Voraussetzungen erfüllen: 
+ Zwei oder mehr AWS CloudHSM Cluster, zu denen Sie eine Verbindung herstellen möchten, zusammen mit ihren Clusterzertifikaten.
+ Eine EC2 Instance mit Sicherheitsgruppen, die korrekt konfiguriert sind, um eine Verbindung zu allen oben genannten Clustern herzustellen. Weitere Informationen zum Einrichten eines Clusters und der Client-Instanz finden Sie unter [Erste Schritte mit AWS CloudHSM](getting-started.md).
+ Um die Multi-Cluster-Funktionalität einzurichten, müssen Sie die CloudHSM-CLI bereits heruntergeladen und installiert haben. Wenn Sie dies noch nicht getan haben, lesen Sie die Anweisungen unter [Erste Schritte mit der AWS CloudHSM Befehlszeilenschnittstelle (CLI)](cloudhsm_cli-getting-started.md).
+  Sie können nicht auf einen Cluster zugreifen, der mit konfiguriert ist, `./configure-cli[.exe] -a` da er nicht mit einem verknüpft ist. `cluster-id` Sie können ihn neu konfigurieren, indem Sie `config-cli add-cluster` wie in diesem Handbuch beschrieben vorgehen. 

# Konfigurieren Sie die CloudHSM-CLI für Multi-Cluster-Funktionalität
<a name="cloudhsm_cli-multi-cluster-config-run"></a>

Gehen Sie folgendermaßen vor, um Ihre CloudHSM-CLI für Multi-Cluster-Funktionalität zu konfigurieren:

1. Identifizieren Sie die Cluster, mit denen Sie eine Verbindung herstellen möchten.

1. Fügen Sie diese Cluster mithilfe des `add-cluster` Unterbefehls [configure-cli](configure-sdk-5.md) wie unten beschrieben zu Ihrer CloudHSM CLI-Konfiguration hinzu.

1. Starten Sie alle CloudHSM CLI-Prozesse neu, damit die neue Konfiguration wirksam wird.

# Fügen Sie Ihrer Konfiguration einen Cluster hinzu AWS CloudHSM
<a name="cloudhsm_cli-multi-cluster-add-cluster"></a>

Wenn Sie eine Verbindung zu mehreren Clustern herstellen, verwenden Sie den `configure-cli add-cluster` Befehl, um Ihrer Konfiguration einen Cluster hinzuzufügen.

## Syntax
<a name="cloudhsm_cli-multi-cluster-add-cluster-syntax"></a>

```
configure-cli add-cluster [OPTIONS]
        --cluster-id <CLUSTER ID> 
        [--region <REGION>]
        [--endpoint <ENDPOINT>]
        [--hsm-ca-cert <HSM CA CERTIFICATE FILE>]
        [--client-cert-hsm-tls-file <CLIENT CERTIFICATE FILE>]
        [--client-key-hsm-tls-file <CLIENT KEY FILE>]
        [-h, --help]
```

## Beispiele
<a name="cloudhsm_cli-multi-cluster-add-cluster-examples"></a>

### Fügen Sie mithilfe des `cluster-id`-Parameters einen Cluster hinzu
<a name="w2aac23c15c19b7c13b7b3b1"></a>

**Example**  
 Verwenden Sie den `configure-cli add-cluster` zusammen mit dem `cluster-id`-Parameter, um Ihrer Konfiguration einen Cluster (mit der ID von `cluster-1234567`) hinzuzufügen.   

```
$ sudo /opt/cloudhsm/bin/configure-cli add-cluster --cluster-id <cluster-1234567>
```

```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-cli.exe" add-cluster --cluster-id <cluster-1234567>
```

**Tipp**  
Wenn die Verwendung von `configure-cli add-cluster` mit dem `cluster-id`-Parameter nicht dazu führt, dass der Cluster hinzugefügt wird, finden Sie im folgenden Beispiel eine längere Version dieses Befehls, die auch die Parameter `--region` und `--endpoint` zur Identifizierung des hinzugefügten Clusters erfordert. Wenn zum Beispiel die Region des Clusters eine andere ist als die, die als Standard für Ihre AWS CLI konfiguriert ist, sollten Sie den `--region`-Parameter verwenden, um die richtige Region zu verwenden. Darüber hinaus haben Sie die Möglichkeit, den AWS CloudHSM API-Endpunkt anzugeben, der für den Anruf verwendet werden soll. Dies kann für verschiedene Netzwerkkonfigurationen erforderlich sein, z. B. für die Verwendung von VPC-Schnittstellenendpunkten, für die nicht den Standard-DNS-Hostnamen verwendet wird. AWS CloudHSM

### Fügen Sie einen Cluster mit den Parametern `cluster-id`, `endpoint`, und `region` hinzu
<a name="w2aac23c15c19b7c13b7b3b3"></a>

**Example**  
 Verwenden Sie `configure-cli add-cluster` zusammen mit den Parametern `cluster-id`, `endpoint` und `region`, um Ihrer Konfiguration einen Cluster (mit der ID von `cluster-1234567`) hinzuzufügen.   

```
$ sudo /opt/cloudhsm/bin/configure-cli add-cluster --cluster-id <cluster-1234567> --region <us-east-1> --endpoint <https://cloudhsmv2.us-east-1.amazonaws.com>
```

```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-cli.exe" add-cluster --cluster-id <cluster-1234567> --region <us-east-1> --endpoint <https://cloudhsmv2.us-east-1.amazonaws.com>
```

Weitere Hinweise zu den Parametern `--cluster-id`, `--region` und `--endpoint` finden Sie unter [AWS CloudHSM Konfigurationsparameter für das Client-SDK 5](configure-tool-params5.md).

## Parameters
<a name="cloudhsm_cli-multi-cluster-add-cluster-parameters"></a>

**--cluster-id *<Cluster ID>***  
 Führt einen `DescribeClusters`-Aufruf aus, um alle IP-Adressen der HSM-Elastic-Network-Schnittstelle (ENI) im Cluster mit der Cluster-ID zu finden. Das System fügt die ENI-IP-Adressen zu den AWS CloudHSM Konfigurationsdateien hinzu.  
Wenn Sie den `--cluster-id` Parameter von einer EC2 Instance innerhalb einer VPC verwenden, die keinen Zugriff auf das öffentliche Internet hat, müssen Sie einen VPC-Schnittstellen-Endpunkt erstellen, mit dem Sie eine Verbindung herstellen können. AWS CloudHSM Weitere Informationen über VPC-Endpunkte finden Sie unter [AWS CloudHSM und VPC-Endpunkte](cloudhsm-vpc-endpoint.md).
Erforderlich: Ja

**--endpoint *<Endpoint>***  
Geben Sie den AWS CloudHSM API-Endpunkt an, der für den `DescribeClusters` Aufruf verwendet wird. Sie müssen diese Option in Kombination mit `--cluster-id` festlegen.   
Erforderlich: Nein

**--hsm-ca-cert *<HsmCA Certificate Filepath>***  
Gibt den Dateipfad zum HSM-CA-Zertifikat an.  
Erforderlich: Nein

**--region *<Region>***  
Geben Sie die Region Ihres Clusters an. Sie müssen diese Option in Kombination mit `--cluster-id` festlegen.  
Wenn Sie den `--region`-Parameter nicht angeben, wählt das System die Region aus, indem es versucht, die Umgebungsvariablen `AWS_DEFAULT_REGION` oder `AWS_REGION` zu lesen. Wenn diese Variablen nicht festgelegt sind, überprüft das System die Region, die Ihrem Profil in Ihrer AWS-Config-Datei zugeordnet ist (normalerweise `~/.aws/config`), sofern Sie in der `AWS_CONFIG_FILE`-Umgebungsvariable keine andere Datei angegeben haben. Wenn keine der oben genannten Optionen festgelegt ist, verwendet das System standardmäßig die `us-east-1`-Region.  
Erforderlich: Nein

**-- -Datei client-cert-hsm-tls *<client certificate hsm tls path>***  
 Pfad zum Client-Zertifikat, das für die gegenseitige Authentifizierung zwischen TLS Client und HSM verwendet wird.   
 Verwenden Sie diese Option nur, wenn Sie mindestens einen Vertrauensanker auf HSM mit CloudHSM CLI registriert haben. Sie müssen diese Option in Kombination mit `--client-key-hsm-tls-file` festlegen.   
Erforderlich: Nein

**-- -Datei client-key-hsm-tls *<client key hsm tls path>***  
 Pfad zum Client-Schlüssel, der für die gegenseitige Authentifizierung zwischen TLS Client und HSM verwendet wird.   
 Verwenden Sie diese Option nur, wenn Sie mindestens einen Vertrauensanker auf HSM mit CloudHSM CLI registriert haben. Sie müssen diese Option in Kombination mit `--client-cert-hsm-tls-file` festlegen.   
Erforderlich: Nein

# Entfernen Sie einen Cluster aus Ihrer Konfiguration AWS CloudHSM
<a name="cloudhsm_cli-multi-cluster-remove-cluster"></a>

Wenn Sie mit der CloudHSM-CLI eine Verbindung zu mehreren Clustern herstellen, verwenden Sie den `configure-cli remove-cluster` Befehl, um einen Cluster aus Ihrer Konfiguration zu entfernen.

## Syntax
<a name="cloudhsm_cli-multi-cluster-remove-cluster-syntax"></a>

```
configure-cli remove-cluster [OPTIONS]
        --cluster-id <CLUSTER ID>
        [-h, --help]
```

## Beispiele
<a name="cloudhsm_cli-multi-cluster-remove-cluster-examples"></a>

### Entfernen Sie mithilfe des `cluster-id`-Parameters einen Cluster
<a name="w2aac23c15c19b7c15b7b3b1"></a>

**Example**  
 Verwenden Sie den `configure-cli remove-cluster` zusammen mit dem `cluster-id`-Parameter, um aus Ihrer Konfiguration einen Cluster (mit der ID von `cluster-1234567`) zu entfernen.   

```
$ sudo /opt/cloudhsm/bin/configure-cli remove-cluster --cluster-id <cluster-1234567>
```

```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-cli.exe" remove-cluster --cluster-id <cluster-1234567>
```

Weitere Informationen zum Parameter `--cluster-id` erhalten Sie unter [AWS CloudHSM Konfigurationsparameter für das Client-SDK 5](configure-tool-params5.md).

## Parameter
<a name="cloudhsm_cli-multi-cluster-remove-cluster-parameters"></a>

**--cluster-id *<Cluster ID>***  
Die ID des Clusters, der aus der Konfiguration entfernt werden soll.  
Erforderlich: Ja

# Interagieren Sie mit mehreren Clustern in AWS CloudHSM
<a name="cloudhsm_cli-multi-cluster-usage"></a>

Nachdem Sie mehrere Cluster mit der CloudHSM-CLI konfiguriert haben, verwenden Sie den `cloudhsm-cli` Befehl, um mit ihnen zu interagieren.

## Beispiele
<a name="cloudhsm_cli-multi-cluster-cluster-usage-examples"></a>

### `cluster-id`Bei Verwendung des interaktiven Modus einen Standard festlegen
<a name="w2aac23c15c19b7c17b5b3b1"></a>

**Example**  
 Verwenden Sie den [interaktiver Modus](cloudhsm_cli-modes.md#cloudhsm_cli-mode-interactive) zusammen mit dem `cluster-id` Parameter, um einen Standardcluster (mit der ID von`cluster-1234567`) aus Ihrer Konfiguration festzulegen.   

```
$ cloudhsm-cli interactive --cluster-id <cluster-1234567>
```

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

### Einstellung von`cluster-id`, wenn ein einzelner Befehl ausgeführt wird
<a name="w2aac23c15c19b7c17b5b5b1"></a>

**Example**  
 Verwenden Sie den `cluster-id` Parameter, um den Cluster (mit der ID von`cluster-1234567`) festzulegen, von [Liste HSMs mit CloudHSM CLI](cloudhsm_cli-cluster-hsm-info.md) dem aus Sie abrufen möchten.   

```
$ cloudhsm-cli cluster hsm-info --cluster-id <cluster-1234567>
```

```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\cloudhsm-cli.exe" cluster hsm-info --cluster-id <cluster-1234567>
```

# Referenz für CloudHSM-CLI-Befehle
<a name="cloudhsm_cli-reference"></a>

CloudHSM CLI unterstützt Administratoren bei der Verwaltung von Benutzern in ihrem Cluster. AWS CloudHSM CloudHSM-CLI kann in zwei Modi ausgeführt werden: im interaktiven Modus und im Einzelbefehlsmodus. Informationen zum schnellen Einstieg finden Sie unter [Erste Schritte mit der AWS CloudHSM Befehlszeilenschnittstelle (CLI)](cloudhsm_cli-getting-started.md). 

Um die meisten CloudHSM-CLI-Befehle auszuführen, müssen Sie die CloudHSM-CLI starten und sich beim HSM anmelden. Wenn Sie etwas hinzufügen oder löschen HSMs, aktualisieren Sie die Konfigurationsdateien für CloudHSM CLI. Andernfalls sind die Änderungen, die Sie vornehmen, möglicherweise nicht für alle HSMs Mitglieder des Clusters wirksam.

Die folgenden Themen beschreiben Befehle in CloudHSM-CLI. 


| Befehl | Description | Benutzertyp | 
| --- | --- | --- | 
| [activate](cloudhsm_cli-cluster-activate.md) | Aktiviert ein CloudHSM-Cluster und bestätigt, dass das Cluster neu ist. Dies muss geschehen, bevor andere Operationen ausgeführt werden können. | Nicht aktivierter Admin | 
| [hsm-info](cloudhsm_cli-cluster-hsm-info.md) | Listen Sie die HSMs in Ihrem Cluster auf. | Alle [1](#cli-ref-1), auch nicht authentifizierte Benutzer. Eine Anmeldung ist nicht erforderlich. | 
| [ecdsa](cloudhsm_cli-crypto-sign-ecdsa.md) | Generiert eine Signatur mithilfe eines privaten EC-Schlüssels und des ECDSA-Signaturmechanismus.  | Crypto-Benutzer (Crypto User, CU) | 
| [ed25519ph](cloudhsm_cli-crypto-sign-ed25519ph.md) | Generiert eine Signatur unter Verwendung eines privaten Ed25519-Schlüssels und des HashEd DSA-Signaturmechanismus.  | CU | 
| [rsa-pkcs](cloudhsm_cli-crypto-sign-rsa-pkcs.md) | Generiert eine Signatur unter Verwendung eines privaten RSA-Schlüssels und des RSA-PKCS-Signaturmechanismus. | CU | 
| [rsa-pkcs-pss](cloudhsm_cli-crypto-sign-rsa-pkcs-pss.md) | Generiert eine Signatur unter Verwendung eines privaten RSA-Schlüssels und des Signaturmechanismus. RSA-PKCS-PSS | CU | 
| [ecdsa](cloudhsm_cli-crypto-verify-ecdsa.md) | Bestätigt, dass eine Datei im HSM mit einem bestimmten öffentlichen Schlüssel signiert wurde. Überprüft, ob die Signatur mithilfe des ECDSA-Signaturmechanismus generiert wurde. Vergleicht eine signierte Datei mit einer Quelldatei und ermittelt anhand eines bestimmten öffentlichen ECDSA-Schlüssels und Signaturmechanismus, ob die beiden kryptografisch verwandt sind.  | CU | 
| [ed25519ph](cloudhsm_cli-crypto-verify-ed25519ph.md) | Überprüft HashEd DSA-Signaturen mithilfe eines öffentlichen Ed25519-Schlüssels. | CU | 
| [rsa-pkcs](cloudhsm_cli-crypto-verify-rsa-pkcs.md) | Bestätigt, dass eine Datei im HSM mit einem bestimmten öffentlichen Schlüssel signiert wurde. Überprüft, ob die Signatur mithilfe des RSA-PKCS-Signaturmechanismus generiert wurde. Vergleicht eine signierte Datei mit einer Quelldatei und bestimmt anhand eines bestimmten öffentlichen RSA-Schlüssels und Signaturmechanismus, ob die beiden kryptografisch verwandt sind. | CU | 
| [rsa-pkcs-pss](cloudhsm_cli-crypto-verify-rsa-pkcs-pss.md) | Bestätigt, dass eine Datei im HSM mit einem bestimmten öffentlichen Schlüssel signiert wurde. Überprüft, ob die Signatur mithilfe des RSA-PKCS-PSS Signaturmechanismus generiert wurde. Vergleicht eine signierte Datei mit einer Quelldatei und ermittelt anhand eines bestimmten öffentlichen RSA-Schlüssels und Signaturmechanismus, ob die beiden kryptografisch verwandt sind. | CU | 
| [key delete](cloudhsm_cli-key-delete.md) | Löscht einen Schlüssel aus Ihrem Cluster. AWS CloudHSM  | CU | 
| [key generate-file](cloudhsm_cli-key-generate-file.md) | Generiert eine Schlüsseldatei in Ihrem AWS CloudHSM Cluster. | CU | 
| [Schlüssel generate-asymmetric-pair rsa](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md) | Generiert ein asymmetrisches RSA-Schlüsselpaar in Ihrem AWS CloudHSM Cluster. | CU | 
| [Schlüssel ec generate-asymmetric-pair](cloudhsm_cli-key-generate-asymmetric-pair-ec.md) | Generiert ein asymmetrisches key pair mit elliptischen Kurven (EC) in Ihrem Cluster. AWS CloudHSM  | CU | 
| [key generate-symmetric aes](cloudhsm_cli-key-generate-symmetric-aes.md) | Generiert einen symmetrischen AES-Schlüssel in Ihrem Cluster. AWS CloudHSM  | CU | 
| [key generate-symmetric generic-secret](cloudhsm_cli-key-generate-symmetric-generic-secret.md) | Generiert einen symmetrischen Generic Secret-Schlüssel in Ihrem AWS CloudHSM Cluster. | CU | 
| [Schlüssel importieren (PEM)](cloudhsm_cli-key-import-pem.md) | Importiert einen Schlüssel im PEM-Format in ein HSM. Sie können ihn verwenden, um öffentliche und außerhalb des HSM erstellte Schlüssel zu importieren. | CU | 
| [key list](cloudhsm_cli-key-list.md) | Findet alle Schlüssel für den aktuellen Benutzer in Ihrem AWS CloudHSM Cluster. | CU | 
| [Schlüssel replizieren](cloudhsm_cli-key-replicate.md) | Replizieren Sie einen Schlüssel von einem Quellcluster auf einen geklonten Zielcluster. | CU | 
| [key set-attribute](cloudhsm_cli-key-set-attribute.md) | Legt die Attribute der Schlüssel in Ihrem AWS CloudHSM Cluster fest. | CUs kann diesen Befehl ausführen, Admins können das vertrauenswürdige Attribut festlegen. | 
| [key share](cloudhsm_cli-key-share.md) | Teilt sich einen Schlüssel mit anderen Mitgliedern CUs Ihres AWS CloudHSM Clusters. | CU | 
| [key unshare](cloudhsm_cli-key-unshare.md) | Macht die gemeinsame Nutzung eines Schlüssels mit anderen CUs in Ihrem AWS CloudHSM Cluster rückgängig. | CU | 
| [aes-gcm](cloudhsm_cli-key-unwrap-aes-gcm.md) | Entpackt einen Payload-Schlüssel mithilfe des AES-Wrapping-Schlüssels und des AES-GCM-Entpackungsmechanismus in den Cluster. | CU | 
| [aes-no-pad](cloudhsm_cli-key-unwrap-aes-no-pad.md) | Entpackt einen Payload-Schlüssel mithilfe des AES-Wrapping-Schlüssels und des Entpackungsmechanismus in den Cluster. AES-NO-PAD | CU | 
| [aes-pkcs5-pad](cloudhsm_cli-key-unwrap-aes-pkcs5-pad.md) | Entpackt einen Payload-Schlüssel mithilfe des AES-Wrapping-Schlüssels und des AES-PAD-Entpackungsmechanismus. PKCS5 | CU | 
| [aes-zero-pad](cloudhsm_cli-key-unwrap-aes-zero-pad.md) | Entpackt einen Payload-Schlüssel mithilfe des AES-Wrapping-Schlüssels und des Entpackungsmechanismus in den Cluster. AES-ZERO-PAD | CU | 
| [cloudhsm-aes-gcm](cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm.md) | Entpackt mithilfe des AES-Wrapping-Schlüssels und des Entpackungsmechanismus einen Payload-Schlüssel in den Cluster. CLOUDHSM-AES-GCM | CU | 
| [rsa-aes](cloudhsm_cli-key-unwrap-rsa-aes.md) | Entpackt einen Payload-Schlüssel mithilfe eines privaten RSA-Schlüssels und des RSA-AES-Entpackungsmechanismus. | CU | 
| [rsa-oaep](cloudhsm_cli-key-unwrap-rsa-oaep.md) | Entpackt einen Payload-Schlüssel mithilfe des privaten RSA-Schlüssels und des RSA-OAEP-Entpackungsmechanismus. | CU | 
| [rsa-pkcs](cloudhsm_cli-key-unwrap-rsa-pkcs.md) | Entpackt einen Payload-Schlüssel mithilfe des privaten RSA-Schlüssels und des RSA-PKCS-Entpackungsmechanismus. | CU | 
| [aes-gcm](cloudhsm_cli-key-wrap-aes-gcm.md) | Wrappt einen Payload-Schlüssel mithilfe eines AES-Schlüssels auf dem HSM und des AES-GCM-Wrapping-Mechanismus ein. | CU | 
| [aes-no-pad](cloudhsm_cli-key-wrap-aes-no-pad.md) | Umschließt einen Payload-Schlüssel mithilfe eines AES-Schlüssels auf dem HSM und dem Wrapping-Mechanismus. AES-NO-PAD | CU | 
| [aes-pkcs5-pad](cloudhsm_cli-key-wrap-aes-pkcs5-pad.md) | Umschließt einen Payload-Schlüssel mithilfe eines AES-Schlüssels auf dem HSM und des AES-PAD-Wrapping-Mechanismus. PKCS5 | CU | 
| [aes-zero-pad](cloudhsm_cli-key-wrap-aes-zero-pad.md) | Umschließt einen Payload-Schlüssel mithilfe eines AES-Schlüssels auf dem HSM und dem Wrapping-Mechanismus. AES-ZERO-PAD | CU | 
| [cloudhsm-aes-gcm](cloudhsm_cli-key-wrap-cloudhsm-aes-gcm.md) | Umschließt einen Payload-Schlüssel mithilfe eines AES-Schlüssels auf dem HSM und dem Wrapping-Mechanismus. CLOUDHSM-AES-GCM | CUs | 
| [rsa-aes](cloudhsm_cli-key-wrap-rsa-aes.md) | Umschließt einen Payload-Schlüssel mithilfe eines öffentlichen RSA-Schlüssels auf dem HSM und des RSA-AES-Wrapping-Mechanismus. | CU | 
| [rsa-oaep](cloudhsm_cli-key-wrap-rsa-oaep.md) | Umschließt einen Payload-Schlüssel mithilfe eines öffentlichen RSA-Schlüssels auf dem HSM und des RSA-OAEP-Wrapping-Mechanismus. | CU | 
| [ Umschließen eines Schlüssels mit RSA-PKCS mithilfe der CloudHSM-CLIrsa-pkcs  Der **key wrap rsa-pkcs** Befehl umschließt einen Payload-Schlüssel mithilfe eines öffentlichen RSA-Schlüssels auf dem HSM und des Wrapping-Mechanismus. `RSA-PKCS`   Verwenden Sie den **key wrap rsa-pkcs** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe eines öffentlichen RSA-Schlüssels auf dem Hardware-Sicherheitsmodul (HSM) und dem Wrapping-Mechanismus zu verpacken. `RSA-PKCS` Das Attribut des Payload-Schlüssels `extractable` muss auf gesetzt sein. `true` Nur der Besitzer eines Schlüssels, d. h. der Crypto-Benutzer (CU), der den Schlüssel erstellt hat, kann den Schlüssel umschließen. Benutzer, die den Schlüssel gemeinsam nutzen, können den Schlüssel für kryptografische Operationen verwenden. Um den **key wrap rsa-pkcs** Befehl verwenden zu können, benötigen Sie zunächst einen RSA-Schlüssel in Ihrem AWS CloudHSM Cluster. Sie können ein RSA-Schlüsselpaar mit dem [Die generate-asymmetric-pair Kategorie in CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair.md) Befehl und dem auf `true` gesetzten `wrap` Attribut generieren.  Benutzertyp  Die folgenden Benutzertypen können diesen Befehl ausführen.   Crypto-Benutzer () CUs     Voraussetzungen    Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.     Syntax  

```
aws-cloudhsm > help key wrap rsa-pkcs
Usage: key wrap rsa-pkcs [OPTIONS] --payload-filter [<PAYLOAD_FILTER>...] --wrapping-filter [<WRAPPING_FILTER>...]

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --payload-filter [<PAYLOAD_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a payload key
      --wrapping-filter [<WRAPPING_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a wrapping key
      --path <PATH>
          Path to the binary file where the wrapped key data will be saved
      --wrapping-approval <WRAPPING_APPROVALR>
          File path of signed quorum token file to approve operation for wrapping key
      --payload-approval <PAYLOAD_APPROVALR>
          File path of signed quorum token file to approve operation for payload key
  -h, --help
          Print help
```   Beispiel  Dieses Beispiel zeigt, wie der **key wrap rsa-pkcs** Befehl mit einem öffentlichen RSA-Schlüssel verwendet wird. 

**Example**  

```
aws-cloudhsm > key wrap rsa-pkcs --payload-filter attr.label=payload-key --wrapping-filter attr.label=rsa-public-key-example
{
  "error_code": 0,
  "data": {
    "payload_key_reference": "0x00000000001c08f1",
    "wrapping_key_reference": "0x00000000007008da",
    "wrapped_key_data": "am0Nc7+YE8FWs+5HvU7sIBcXVb24QA0l65nbNAD+1bK+e18BpSfnaI3P+r8Dp+pLu1ofoUy/vtzRjZoCiDofcz4EqCFnGl4GdcJ1/3W/5WRvMatCa2d7cx02swaeZcjKsermPXYRO1lGlfq6NskwMeeTkV8R7Rx9artFrs1y0DdIgIKVaiFHwnBIUMnlQrR2zRmMkfwU1jxMYmOYyD031F5VbnjSrhfMwkww2la7uf/c3XdFJ2+0Bo94c6og/yfPcpOOobJlITCoXhtMRepSdO4OggYq/6nUDuHCtJ86pPGnNahyr7+sAaSI3a5ECQLUjwaIARUCyoRh7EFK3qPXcg=="
  }
```   Argumente   

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md) 

***<PAYLOAD\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Payload-Schlüssels“.  
Erforderlich: Ja 

***<PATH>***  
Pfad zur Binärdatei, in der die verpackten Schlüsseldaten gespeichert werden.  
Erforderlich: Nein 

***<WRAPPING\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Umbruchschlüssels“.   
Erforderlich: Ja 

***<WRAPPING\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zum Umschließen des Schlüssels zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst beim Umschließen des Schlüssels größer als 1 ist. 

***<PAYLOAD\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang für den Payload-Schlüssel zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst des Payload-Schlüssels größer als 1 ist.    Verwandte Themen    [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)   [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)    ](cloudhsm_cli-key-wrap-rsa-pkcs.md) | Umschließt einen Payload-Schlüssel mithilfe eines öffentlichen RSA-Schlüssels auf dem HSM und des RSA-PKCS-Wrapping-Mechanismus. | CU | 
| [login](cloudhsm_cli-login.md) | Melden AWS CloudHSM Sie sich bei Ihrem Cluster an. | Administrator, Crypto-Benutzer (CU) und Appliance-Benutzer (AU) | 
| [logout](cloudhsm_cli-logout.md) | Melden Sie sich von Ihrem AWS CloudHSM Cluster ab. | Administrator, CU und Appliance-Benutzer (AU) | 
| [quorum token-sign delete](cloudhsm_cli-qm-token-del.md) | Löscht ein oder mehrere Token für einen vom Quorum autorisierten Dienst. | Admin. | 
| [quorum token-sign generate](cloudhsm_cli-qm-token-gen.md) | Generiert ein Token für einen vom Quorum autorisierten Dienst. | Admin. | 
| [quorum token-sign list](cloudhsm_cli-qm-token-list.md) | Listet alle token-sign-Quorum-Token auf, die in Ihrem CloudHSM-Cluster vorhanden sind. | Alle [1](#cli-ref-1), auch nicht authentifizierte Benutzer. Eine Anmeldung ist nicht erforderlich. | 
| [Quorum-Tokenzeichen list-quorum-values](cloudhsm_cli-qm-token-list-qm.md) | Listet die in Ihrem CloudHSM-Cluster festgelegten Quorumwerte auf. | Alle [1](#cli-ref-1), auch nicht authentifizierte Benutzer. Eine Anmeldung ist nicht erforderlich. | 
| [Quorum-Tokenzeichen set-quorum-value](cloudhsm_cli-qm-token-set-qm.md) | Legt einen neuen Quorumwert für einen vom Quorum autorisierten Dienst fest. | Admin. | 
| [user change-mfa](cloudhsm_cli-user-change-mfa.md) | Ändert die Strategie zur Multi-Faktor-Authentifizierung (MFA) eines Benutzers. | Admin, CU | 
| [user change-password](cloudhsm_cli-user-change-password.md) | Ändert die Passwörter von Benutzern auf dem. HSMs Jeder Benutzer kann das eigene Passwort ändern. Admins können das Passwort jedes Benutzers ändern. | Admin, CU | 
| [user create](cloudhsm_cli-user-create.md) | Erstellt einen Benutzer in Ihrem AWS CloudHSM Cluster. | Admin. | 
| [user delete](cloudhsm_cli-user-delete.md) | Löscht einen Benutzer in Ihrem AWS CloudHSM Cluster. | Admin. | 
| [user list](cloudhsm_cli-user-list.md) | Listet die Benutzer in Ihrem AWS CloudHSM Cluster auf. | Alle [1](#cli-ref-1), auch nicht authentifizierte Benutzer. Eine Anmeldung ist nicht erforderlich. | 
| [user change-quorum token-sign register](cloudhsm_cli-user-chqm-token-reg.md) | Registriert die Quorumstrategie mit Quorum-token-sign für einen Benutzer. | Admin. | 

**Anmerkungen**
+ [1] Alle Benutzer umfasst alle aufgelisteten Rollen und Benutzer, die nicht angemeldet sind.

# Die Cluster-Kategorie in CloudHSM CLI
<a name="cloudhsm_cli-cluster"></a>

In der CloudHSM-CLI **cluster** ist dies eine übergeordnete Kategorie für eine Gruppe von Befehlen, die in Kombination mit der übergeordneten Kategorie einen Befehl erstellen, der spezifisch für Cluster ist. Derzeit besteht die Cluster-Kategorie aus den folgenden Befehlen:

**Topics**
+ [activate](cloudhsm_cli-cluster-activate.md)
+ [hsm-info](cloudhsm_cli-cluster-hsm-info.md)
+ [mtls](cloudhsm_cli-cluster-mtls.md)

# Aktivieren Sie einen Cluster mit CloudHSM CLI
<a name="cloudhsm_cli-cluster-activate"></a>

Verwenden Sie den **cluster activate** Befehl in der CloudHSM-CLI, um [einen neuen Cluster in zu aktivieren](activate-cluster.md). AWS CloudHSM Dieser Befehl muss ausgeführt werden, bevor der Cluster zum Ausführen von kryptografischen Operationen verwendet werden kann.

## Benutzertyp
<a name="cluster-activate-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Nicht aktivierter Admin

## Syntax
<a name="chsm-cli-cluster-activate-syntax"></a>

Dieser Befehl hat keine Parameter.

```
aws-cloudhsm > help cluster activate
Activate a cluster

This command will set the initial Admin password. This process will cause your CloudHSM cluster to
move into the ACTIVE state.

USAGE:
    cloudhsm-cli cluster activate [OPTIONS] [--password <PASSWORD>]

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error

      --password <PASSWORD>
          Optional: Plaintext activation password If you do not include this argument you will be prompted for it

  -h, --help
          Print help (see a summary with '-h')
```

## Beispiel
<a name="chsm-cli-cluster-activate-examples"></a>

Dieser Befehl aktiviert Ihr Cluster, indem er das anfängliche Passwort für Ihren Admin-Benutzer festlegt.

```
aws-cloudhsm > cluster activate
Enter password:
Confirm password:
{
  "error_code": 0,
  "data": "Cluster activation successful"
}
```

## Verwandte Themen
<a name="chsm-cluster-activate-seealso"></a>
+ [user create](cloudhsm_cli-user-create.md)
+ [user delete](cloudhsm_cli-user-delete.md)
+ [user change-password](cloudhsm_cli-user-change-password.md)

# Liste HSMs mit CloudHSM CLI
<a name="cloudhsm_cli-cluster-hsm-info"></a>

Verwenden Sie den **cluster hsm-info** Befehl in der CloudHSM-CLI, um die Hardware-Sicherheitsmodule (HSMs) in Ihrem AWS CloudHSM Cluster aufzulisten. Sie müssen nicht bei CloudHSM-CLI angemeldet sein, um diesen Befehl auszuführen.

**Anmerkung**  
Wenn Sie hinzufügen oder löschen HSMs, aktualisieren Sie die Konfigurationsdateien, die der AWS CloudHSM Client und die Befehlszeilentools verwenden. Andernfalls sind die Änderungen, die Sie vornehmen, möglicherweise nicht für alle Mitglieder HSMs des Clusters wirksam.

## Benutzertyp
<a name="chsm-cluster-hsm-info-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Alle Benutzer. Sie müssen nicht angemeldet sein, um diesen Befehl auszuführen.

## Syntax
<a name="chsm-cluster-hsm-info-syntax"></a>

```
aws-cloudhsm > help cluster hsm-info
List info about each HSM in the cluster

Usage: cloudhsm-cli cluster hsm-info [OPTIONS]

Options:
      --cluster-id <CLUSTER_ID>  Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
  -h, --help                     Print help
```

## Beispiel
<a name="chsm-cluster-hsm-info-examples"></a>

Dieser Befehl listet die HSMs vorhandenen Elemente in Ihrem AWS CloudHSM Cluster auf.

```
aws-cloudhsm > cluster hsm-info
{
  "error_code": 0,
  "data": {
    "hsms": [
      {
        "vendor": "Marvell Semiconductors, Inc.",
        "model": "NITROX-III CNN35XX-NFBE",
        "serial-number": "5.3G1941-ICM000590",
        "hardware-version-major": "5",
        "hardware-version-minor": "3",
        "firmware-version-major": "2",
        "firmware-version-minor": "6",
        "firmware-build-number": "16",
        "firmware-id": "CNN35XX-NFBE-FW-2.06-16"
        "fips-state": "2 [FIPS mode with single factor authentication]"
      },
      {
        "vendor": "Marvell Semiconductors, Inc.",
        "model": "NITROX-III CNN35XX-NFBE",
        "serial-number": "5.3G1941-ICM000625",
        "hardware-version-major": "5",
        "hardware-version-minor": "3",
        "firmware-version-major": "2",
        "firmware-version-minor": "6",
        "firmware-build-number": "16",
        "firmware-id": "CNN35XX-NFBE-FW-2.06-16"
        "fips-state": "2 [FIPS mode with single factor authentication]"
      },
      {
        "vendor": "Marvell Semiconductors, Inc.",
        "model": "NITROX-III CNN35XX-NFBE",
        "serial-number": "5.3G1941-ICM000663",
        "hardware-version-major": "5",
        "hardware-version-minor": "3",
        "firmware-version-major": "2",
        "firmware-version-minor": "6",
        "firmware-build-number": "16",
        "firmware-id": "CNN35XX-NFBE-FW-2.06-16"
        "fips-state": "2 [FIPS mode with single factor authentication]"
      }
    ]
  }
}
```

Diese Ausgabe hat die folgenden Attribute:
+ **Anbieter**: Der Name des Anbieters des HSM. 
+ **Modell**: Die Modellnummer des HSM.
+ **Seriennummer**: Die Seriennummer des HSM. Dies kann sich aufgrund von Ersetzungen ändern.
+ **H ardware-version-major**: Die wichtigste Hardwareversion.
+ **H ardware-version-minor**: Die kleinere Hardwareversion.
+ **F irmware-version-major**: Die Haupt-Firmware-Version.
+ **F irmware-version-minor**: Die kleinere Firmware-Version.
+ **F irmware-build-number**: Die Build-Nummer der Firmware.
+ **Firmware-id**: Die Firmware-ID, die die Haupt- und Nebenversionen zusammen mit dem Build enthält.
+ **FIPS-Status**: Der FIPS-Modus des Clusters und der darin befindliche. HSMs Im FIPS-Modus lautet die Ausgabe „2 [FIPS-Modus mit Einzelfaktor-Authentifizierung]“. Im Nicht-FIPS-Modus lautet die Ausgabe „0 [Nicht-FIPS-Modus mit Einzelfaktor-Authentifizierung]“.

## Verwandte Themen
<a name="chsm-cluster-hsm-info-seealso"></a>
+ [Aktivieren Sie einen Cluster mit CloudHSM CLI](cloudhsm_cli-cluster-activate.md)

# Die Cluster-MTLS-Kategorie in der CloudHSM-CLI
<a name="cloudhsm_cli-cluster-mtls"></a>

In CloudHSM CLI **cluster mtls** ist dies eine übergeordnete Kategorie für eine Gruppe von Befehlen, die in Kombination mit der übergeordneten Kategorie einen Befehl erstellen, der spezifisch für Cluster ist. AWS CloudHSM Derzeit besteht diese Kategorie aus den folgenden Befehlen:

**Topics**
+ [deregister-trust-anchor](cloudhsm_cli-cluster-mtls-deregister-trust-anchor.md)
+ [Erzwingung durchführen](cloudhsm_cli-cluster-mtls-get-enforcement.md)
+ [list-trust-anchors](cloudhsm_cli-cluster-mtls-list-trust-anchors.md)
+ [register-trust-anchor](cloudhsm_cli-cluster-mtls-register-trust-anchor.md)
+ [Durchsetzung festlegen](cloudhsm_cli-cluster-mtls-set-enforcement.md)

# Einen Vertrauensanker mit der CloudHSM-CLI deregistrieren
<a name="cloudhsm_cli-cluster-mtls-deregister-trust-anchor"></a>

Verwenden Sie den **cluster mtls deregister-trust-anchor** Befehl in der CloudHSM-CLI, um einen Vertrauensanker für gegenseitiges TLS zwischen Client und abzumelden. AWS CloudHSM

## Benutzertyp
<a name="cluster-mtls-deregister-trust-anchor-userType"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Admin.

## Voraussetzungen
<a name="cluster-mtls-deregister-trust-anchor-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als Admin-Benutzer angemeldet sein.

## Syntax
<a name="cluster-mtls-deregister-trust-anchor-syntax"></a>

```
aws-cloudhsm > help cluster mtls deregister-trust-anchor
            
Deregister a trust anchor for mtls

Usage: cluster mtls deregister-trust-anchor [OPTIONS] --certificate-reference [<CERTIFICATE_REFERENCE>...]

Options:
      --certificate-reference <CERTIFICATE_REFERENCE>  A hexadecimal or decimal certificate reference
      --cluster-id <CLUSTER_ID>  Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --approval <APPROVAL>  Filepath of signed quorum token file to approve operation
  -h, --help                     Print help
```

## Beispiel
<a name="cluster-mtls-deregister-trust-anchor-examples"></a>

**Example**  
Im folgenden Beispiel entfernt dieser Befehl einen Vertrauensanker aus dem HSM.  

```
aws-cloudhsm > cluster mtls deregister-trust-anchor --certificate-reference 0x01
                
{
  "error_code": 0,
  "data": {
    "message": "Trust anchor with reference 0x01 deregistered successfully"
  }
}
```
Anschließend können Sie den **list-trust-anchors** Befehl ausführen, um zu bestätigen, dass der Vertrauensanker aus dem folgenden Verzeichnis abgemeldet wurde: AWS CloudHSM  

```
aws-cloudhsm > cluster mtls list-trust-anchors
                
{
  "error_code": 0,
  "data": {
    "trust_anchors": []
  }
}
```

## Argumente
<a name="cluster-mtls-deregister-trust-anchor-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

** *<CERTIFICATE\$1REFERENCE>* **  
Eine hexadezimale oder dezimale Zertifikatsreferenz.  
 **Erforderlich**: Ja  
Nachdem Sie einen Vertrauensanker im Cluster deregistriert haben, werden alle vorhandenen mTLS-Verbindungen, die das von diesem Vertrauensanker signierte Client-Zertifikat verwenden, gelöscht.

** *<APPROVAL>* **  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Quorumclusterdienstes größer als 1 ist.

## Verwandte Themen
<a name="cluster-mtls-deregister-trust-anchor-seealso"></a>
+  [Cluster-MTLS reregister-trust-anchor](cloudhsm_cli-cluster-mtls-register-trust-anchor.md) 
+  [Cluster-MTLS list-trust-anchors](cloudhsm_cli-cluster-mtls-list-trust-anchors.md) 
+  [mTLS einrichten (empfohlen)](getting-started-setup-mtls.md) 

# Holen Sie sich die mTLS-Durchsetzungsstufe mit der CloudHSM CLI
<a name="cloudhsm_cli-cluster-mtls-get-enforcement"></a>

Verwenden Sie den **cluster mtls get-enforcement** Befehl in der CloudHSM-CLI, um die Durchsetzungsstufe für die Verwendung von gegenseitigem TLS zwischen Client und zu ermitteln. AWS CloudHSM

## Benutzertyp
<a name="cluster-mtls-get-enforcement-userType"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Admin.
+ Krypto-Benutzer () CUs

## Voraussetzungen
<a name="cluster-mtls-get-enforcement-requirements"></a>
+ Um diesen Befehl ausführen zu können, müssen Sie als Admin-Benutzer oder Crypto-Benutzer (CUs) angemeldet sein.

## Syntax
<a name="cluster-mtls-get-enforcement-syntax"></a>

```
aws-cloudhsm > help cluster mtls get-enforcement
            
Get the status of mtls enforcement in the cluster

Usage: cluster mtls get-enforcement [OPTIONS]

Options:
      --cluster-id <CLUSTER_ID>  Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
  -h, --help                     Print help
```

## Beispiel
<a name="cluster-mtls-get-enforcement-examples"></a>

**Example**  
Im folgenden Beispiel listet dieser Befehl die Mtls-Erzwingungsstufe von auf AWS CloudHSM.  

```
aws-cloudhsm > cluster mtls get-enforcement
                
{
  "error_code": 0,
  "data": {
    "mtls-enforcement-level": "none"
  }
}
```

## Argumente
<a name="cluster-mtls-get-enforcement-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

## Verwandte Themen
<a name="cluster-mtls-get-enforcement-seealso"></a>
+  [Durchsetzung von Cluster-MTLS-Sets](cloudhsm_cli-cluster-mtls-set-enforcement.md) 
+  [mTLS einrichten (empfohlen)](getting-started-setup-mtls.md) 

# Vertrauensanker mit CloudHSM CLI auflisten
<a name="cloudhsm_cli-cluster-mtls-list-trust-anchors"></a>

Verwenden Sie den **cluster mtls list-trust-anchors** Befehl in der CloudHSM-CLI, um alle Vertrauensanker aufzulisten, die für gegenseitiges TLS zwischen Client und verwendet werden können. AWS CloudHSM

## Benutzertyp
<a name="cluster-mtls-list-trust-anchors-userType"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Alle Benutzer. Sie müssen nicht angemeldet sein, um diesen Befehl auszuführen.

## Syntax
<a name="cluster-mtls-list-trust-anchors-syntax"></a>

```
aws-cloudhsm > help cluster mtls list-trust-anchors
            
List all trust anchors for mtls

Usage: cluster mtls list-trust-anchors [OPTIONS]

Options:
      --cluster-id <CLUSTER_ID>  Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
  -h, --help                     Print help
```

## Beispiel
<a name="cluster-mtls-list-trust-anchors-examples"></a>

**Example**  
Im folgenden Beispiel listet dieser Befehl alle registrierten Vertrauensanker aus dem auf. AWS CloudHSM  

```
aws-cloudhsm > cluster mtls list-trust-anchors
                
{
  "error_code": 0,
  "data": {
    "trust_anchors": [
      {
        "certificate-reference": "0x01",
        "certificate": "<PEM Encoded Certificate 1>",
        "cluster-coverage": "full"
      },
      {
        "certificate-reference": "0x02",
        "certificate": "<PEM Encoded Certificate 2>",
        "cluster-coverage": "full"
      }
    ]
  }
}
```

## Argumente
<a name="cluster-mtls-list-trust-anchors-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

## Verwandte Themen
<a name="cluster-mtls-register-trust-anchor-seealso"></a>
+  [Cluster-MTLS reregister-trust-anchor](cloudhsm_cli-cluster-mtls-register-trust-anchor.md) 
+  [Cluster-MTLS deregister-trust-anchor](cloudhsm_cli-cluster-mtls-deregister-trust-anchor.md) 
+  [mTLS einrichten (empfohlen)](getting-started-setup-mtls.md) 

# Registrieren Sie einen Vertrauensanker mit CloudHSM CLI
<a name="cloudhsm_cli-cluster-mtls-register-trust-anchor"></a>

Verwenden Sie den **cluster mtls register-trust-anchor** Befehl in der CloudHSM-CLI, um einen Vertrauensanker für gegenseitiges TLS zwischen Client und zu registrieren. AWS CloudHSM

## Benutzertyp
<a name="cluster-mtls-register-trust-anchor-userType"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Admin.

## Voraussetzungen
<a name="cluster-mtls-register-trust-anchor-requirements"></a>

Der AWS CloudHSM akzeptiert Vertrauensanker mit den folgenden Schlüsseltypen:


****  

| Schlüsseltyp | Description | 
| --- | --- | 
| EC |  Die Kurven secp256r1 (P-256), secp384r1 (P-384) und secp521r1 (P-521).  | 
| RSA |  2048-Bit-, 3072-Bit- und 4096-Bit-RSA-Schlüssel.  | 

## Syntax
<a name="cluster-mtls-register-trust-anchor-syntax"></a>

```
aws-cloudhsm > help cluster mtls register-trust-anchor
            
Register a trust anchor for mtls

Usage: cluster mtls register-trust-anchor [OPTIONS] --path [<PATH>...]

Options:
      --cluster-id <CLUSTER_ID>  Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --path <PATH>  Filepath of the trust anchor to register
      --approval <APPROVAL>  Filepath of signed quorum token file to approve operation
  -h, --help                     Print help
```

## Beispiel
<a name="cluster-mtls-register-trust-anchor-examples"></a>

**Example**  
Im folgenden Beispiel registriert dieser Befehl einen Vertrauensanker auf dem HSM. Die maximale Anzahl von Vertrauensankern, die registriert werden können, beträgt zwei (2).  

```
aws-cloudhsm > cluster mtls register-trust-anchor --path /home/rootCA
                
{
  "error_code": 0,
  "data": {
    "trust_anchor": {
      "certificate-reference": "0x01",
      "certificate": "<PEM Encoded Certificate>",
      "cluster-coverage": "full"
    }
  }
}
```
Sie können dann den **list-trust-anchors** Befehl ausführen, um zu bestätigen, dass der Vertrauensanker registriert wurde auf AWS CloudHSM:  

```
aws-cloudhsm > cluster mtls list-trust-anchors
                
{
  "error_code": 0,
  "data": {
    "trust_anchors": [
      {
        "certificate-reference": "0x01",
        "certificate": "<PEM Encoded Certificate>",
        "cluster-coverage": "full"
      }
    ]
  }
}
```

## Argumente
<a name="cluster-mtls-register-trust-anchor-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

** *<PATH>* **  
Dateipfad des zu registrierenden Vertrauensankers.  
 **Erforderlich**: Ja  
AWS CloudHSM unterstützt die Registrierung von Zwischenzertifikaten als Vertrauensanker. In solchen Fällen muss die gesamte PEM-kodierte Zertifikatskettendatei im HSM registriert werden, wobei die Zertifikate in hierarchischer Reihenfolge angeordnet sind.   
 AWS CloudHSM unterstützt eine Zertifikatskette von 6980 Byte.

** *<APPROVAL>* **  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Quorumclusterdienstes größer als 1 ist.

## Verwandte Themen
<a name="cluster-mtls-register-trust-anchor-seealso"></a>
+  [Cluster-MTLS deregister-trust-anchor](cloudhsm_cli-cluster-mtls-deregister-trust-anchor.md) 
+  [Cluster-MTLS list-trust-anchors](cloudhsm_cli-cluster-mtls-list-trust-anchors.md) 
+  [mTLS einrichten (empfohlen)](getting-started-setup-mtls.md) 

# Legen Sie die mTLS-Durchsetzungsstufe mit der CloudHSM CLI fest
<a name="cloudhsm_cli-cluster-mtls-set-enforcement"></a>

Verwenden Sie den **cluster mtls set-enforcement** Befehl in der CloudHSM-CLI, um die Durchsetzungsstufe für die Verwendung von gegenseitigem TLS zwischen Client und festzulegen. AWS CloudHSM

## Benutzertyp
<a name="cluster-mtls-set-enforcement-userType"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Admin mit dem Benutzernamen als Admin

## Voraussetzungen
<a name="cluster-mtls-set-enforcement-requirements"></a>

Um diesen Befehl auszuführen:
+ Mindestens ein Vertrauensanker wurde erfolgreich auf dem registriert AWS CloudHSM.
+ Konfigurieren Sie die CloudHSM-CLI mit dem richtigen privaten Schlüssel und dem richtigen Client-Zertifikat und starten Sie die CloudHSM-CLI unter einer gegenseitigen TLS-Verbindung.
+ Sie müssen als Standard-Administrator mit dem Benutzernamen „admin“ angemeldet sein. Jeder andere Admin-Benutzer kann diesen Befehl nicht ausführen.

## Syntax
<a name="cluster-mtls-set-enforcement-syntax"></a>

```
aws-cloudhsm > help cluster mtls set-enforcement
            
Set mtls enforcement policy in the cluster

Usage: cluster mtls set-enforcement [OPTIONS] --level [<LEVEL>...]

Options:
      --cluster-id <CLUSTER_ID>  Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --level <LEVEL>  Level to be set for mtls in the cluster [possible values: none, cluster]
      --approval <APPROVAL>  Filepath of signed quorum token file to approve operation
  -h, --help                     Print help
```

## Beispiel
<a name="cluster-mtls-set-enforcement-examples"></a>

**Example**  
Im folgenden Beispiel legt dieser Befehl die MTLS-Erzwingungsstufe des gewünschten AWS CloudHSM Clusters fest. Der Befehl set-enforcement kann nur in einer gegenseitigen TLS-Verbindung ausgeführt werden, wenn Sie als Admin-Benutzer mit dem Benutzernamen admin angemeldet sind. Weitere Informationen finden Sie unter [mTLS-Erzwingung einrichten](getting-started-setup-mtls.md#getting-start-setup-mtls-enforcement) für. AWS CloudHSM  

```
aws-cloudhsm > cluster mtls set-enforcement --level cluster
                
{
  "error_code": 0,
  "data": {
    "message": "Mtls enforcement level set to Cluster successfully"
  }
}
```
Anschließend können Sie den **get-enforcement** Befehl ausführen, um zu bestätigen, dass die Erzwingungsstufe auf Cluster gesetzt wurde:  

```
aws-cloudhsm > cluster mtls get-enforcement
                
{
  "error_code": 0,
  "data": {
    "mtls-enforcement-level": "cluster"
  }
}
```

## Argumente
<a name="cluster-mtls-set-enforcement-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

** *<LEVEL>* **  
Stufe, die für MTLS im Cluster festgelegt werden soll.   
 **Zulässige Werte**   
+  **Cluster**: Erzwingt die Verwendung von gegenseitigem TLS zwischen Client und AWS CloudHSM Cluster.
+  **none**: Erzwingen Sie nicht die Verwendung von gegenseitigem TLS zwischen Client und AWS CloudHSM Cluster.
 **Erforderlich**: Ja  
Nachdem Sie die mTLS-Nutzung im Cluster erzwungen haben, werden alle bestehenden Nicht-MTLS-Verbindungen gelöscht und Sie können nur mit mTLS-Zertifikaten eine Verbindung zum Cluster herstellen.

** *<APPROVAL>* **  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Quorumclusterdienstes größer als 1 ist.

## Verwandte Themen
<a name="cluster-mtls-set-enforcement-seealso"></a>
+  [Erzwingung von Cluster-MTLS](cloudhsm_cli-cluster-mtls-get-enforcement.md) 
+  [mTLS einrichten (empfohlen)](getting-started-setup-mtls.md) 

# Die Krypto-Kategorie in CloudHSM CLI
<a name="cloudhsm_cli-crypto"></a>

In der CloudHSM-CLI **crypto** ist dies eine übergeordnete Kategorie für eine Gruppe von Befehlen, die in Kombination mit der übergeordneten Kategorie einen Befehl erstellen, der für kryptografische Operationen spezifisch ist. Derzeit besteht diese Kategorie aus den folgenden Befehlen: 
+ [sign](cloudhsm_cli-crypto-sign.md)
  + [ecdsa](cloudhsm_cli-crypto-sign-ecdsa.md)
  + [ed25519ph](cloudhsm_cli-crypto-sign-ed25519ph.md)
  + [rsa-pkcs](cloudhsm_cli-crypto-sign-rsa-pkcs.md)
  + [rsa-pkcs-pss](cloudhsm_cli-crypto-sign-rsa-pkcs-pss.md)
+ [verify](cloudhsm_cli-crypto-verify.md)
  + [ecdsa](cloudhsm_cli-crypto-verify-ecdsa.md)
  + [ed25519ph](cloudhsm_cli-crypto-verify-ed25519ph.md)
  + [rsa-pkcs](cloudhsm_cli-crypto-verify-rsa-pkcs.md)
  + [rsa-pkcs-pss](cloudhsm_cli-crypto-verify-rsa-pkcs-pss.md)

# Die Kategorie Kryptozeichen in CloudHSM CLI
<a name="cloudhsm_cli-crypto-sign"></a>

In der CloudHSM-CLI **crypto sign** ist dies eine übergeordnete Kategorie für eine Gruppe von Befehlen, die in Kombination mit der übergeordneten Kategorie einen ausgewählten privaten Schlüssel in Ihrem AWS CloudHSM Cluster verwendet, um eine Signatur zu generieren. **crypto sign**hat die folgenden Unterbefehle:
+ [Generieren Sie eine Signatur mit dem ECDSA-Mechanismus in der CloudHSM-CLI](cloudhsm_cli-crypto-sign-ecdsa.md)
+ [Generieren Sie eine Signatur mit dem HashEd DSA-Mechanismus in der CloudHSM-CLI](cloudhsm_cli-crypto-sign-ed25519ph.md)
+ [Generieren Sie eine Signatur mit dem RSA-PKCS-Mechanismus in der CloudHSM-CLI](cloudhsm_cli-crypto-sign-rsa-pkcs.md)
+ [Generieren Sie eine Signatur mit dem RSA-PKCS-PSS Mechanismus in CloudHSM CLI](cloudhsm_cli-crypto-sign-rsa-pkcs-pss.md)

Um sie verwenden zu können**crypto sign**, benötigen Sie einen privaten Schlüssel in Ihrem HSM. Sie können einen privaten Schlüssel mit den folgenden Befehlen generieren:
+ [Schlüssel generate-asymmetric-pair ec](cloudhsm_cli-key-generate-asymmetric-pair-ec.md)
+ [Schlüssel generate-asymmetric-pair RSA](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md)

# Generieren Sie eine Signatur mit dem ECDSA-Mechanismus in der CloudHSM-CLI
<a name="cloudhsm_cli-crypto-sign-ecdsa"></a>

Verwenden Sie den **crypto sign ecdsa** Befehl in der CloudHSM-CLI, um eine Signatur mithilfe eines privaten EC-Schlüssels und des ECDSA-Signaturmechanismus zu generieren. 

Um den **crypto sign ecdsa** Befehl verwenden zu können, benötigen Sie zunächst einen privaten EC-Schlüssel in Ihrem Cluster. AWS CloudHSM Sie können mit dem [Generieren Sie ein asymmetrisches EC-Schlüsselpaar mit CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair-ec.md) Befehl, dessen `sign` Attribut auf gesetzt ist, einen privaten EC-Schlüssel generieren`true`.

Die resultierende ECDSA-Signatur wird in dem Format generiert`r||s`, in dem die Komponenten R und S als binäre Rohdaten verkettet und im Base64-codierten Format zurückgegeben werden.

**Anmerkung**  
Signaturen können mit Unterbefehlen verifiziert werden. AWS CloudHSM [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md)

## Benutzertyp
<a name="cloudhsm_cli-crypto-sign-ecdsa-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Krypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-crypto-sign-ecdsa-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-crypto-sign-ecdsa-syntax"></a>

```
aws-cloudhsm > help crypto sign ecdsa
Sign with the ECDSA mechanism

Usage: crypto sign ecdsa --key-filter [<KEY_FILTER>>...] --hash-function <HASH_FUNCTION> <--data-path <DATA_PATH>|--data <DATA>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --key-filter [<KEY_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key
      --hash-function <HASH_FUNCTION>
          [possible values: sha1, sha224, sha256, sha384, sha512]
      --data-path <DATA_PATH>
          The path to the file containing the data to be signed
      --data <DATA>
          Base64 Encoded data to be signed
      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
      --data-type <DATA_TYPE>
          The type of data passed in, either raw or digest [possible values: raw, digest]
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-crypto-sign-ecdsa-examples"></a>

Diese Beispiele zeigen, wie eine Signatur mithilfe des ECDSA-Signaturmechanismus und der `SHA256` Hash-Funktion generiert wird. **crypto sign ecdsa** Dieser Befehl verwendet einen privaten Schlüssel im HSM.

**Example Beispiel: Generieren Sie eine Signatur für Base-64-kodierte Daten**  

```
aws-cloudhsm > crypto sign ecdsa --key-filter attr.label=ec-private --hash-function sha256 --data YWJjMTIz
{
  "error_code": 0,
  "data": {
    "key-reference": "0x00000000007808dd",
    "signature": "4zki+FzjhP7Z/KqoQvh4ueMAxQQVp7FQguZ2wOS3Q5bzk+Hc5irV5iTkuxQbropPttVFZ8V6FgR2fz+sPegwCw=="
  }
}
```

**Example Beispiel: Generieren Sie eine Signatur für eine Datendatei**  

```
aws-cloudhsm > crypto sign ecdsa --key-filter attr.label=ec-private --hash-function sha256 --data-path data.txt
{
  "error_code": 0,
  "data": {
    "key-reference": "0x00000000007808dd",
    "signature": "4zki+FzjhP7Z/KqoQvh4ueMAxQQVp7FQguZ2wOS3Q5bzk+Hc5irV5iTkuxQbropPttVFZ8V6FgR2fz+sPegwCw=="
  }
}
```

## Argumente
<a name="cloudhsm_cli-crypto-sign-ecdsa-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<DATA>***  
Base64-kodierte Daten, die signiert werden sollen.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<DATA\$1PATH>***  
Gibt den Speicherort der zu signierenden Daten an.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<HASH\$1FUNCTION>***  
Gibt die Hash-Funktion an.   
Zulässige Werte:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Erforderlich: Ja

***<KEY\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form attr.key\$1attribute\$1name=KEY\$1ATTRIBUTE\$1VALUE, um einen passenden Schlüssel auszuwählen.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter Schlüsselattribute für CloudHSM CLI.  
Erforderlich: Ja

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des privaten Schlüssels für den Schlüsselnutzungsdienst größer als 1 ist.

***<DATA\$1TYPE>***  
 Gibt an, ob der Wert des Datenparameters als Teil des Signaturalgorithmus gehasht werden soll. Wird `raw` für Daten ohne Hashwert verwendet; wird `digest` für Digests verwendet, die bereits gehasht wurden.   
Zulässige Werte:  
+ RAW
+ Digest

## Verwandte Themen
<a name="cloudhsm_cli-crypto-sign-ecdsa-seealso"></a>
+ [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md)
+ [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md)

# Generieren Sie eine Signatur mit dem HashEd DSA-Mechanismus in der CloudHSM-CLI
<a name="cloudhsm_cli-crypto-sign-ed25519ph"></a>

**Wichtig**  
HashEdDSA-Signaturvorgänge werden nur auf hsm2m.medium-Instances im Nicht-FIPS-Modus unterstützt.

Verwenden Sie den **crypto sign ed25519ph** Befehl in der CloudHSM-CLI, um eine Signatur mithilfe eines privaten Ed25519-Schlüssels und des HashEd DSA-Signaturmechanismus zu generieren. Weitere Informationen zu HashEd DSA finden Sie unter [NIST](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-5.pdf) SP 186-5, Abschnitt 7.8.

Um den **crypto sign ed25519ph** Befehl verwenden zu können, benötigen Sie zunächst einen privaten Ed25519-Schlüssel in Ihrem Cluster. AWS CloudHSM Sie können einen privaten Ed25519-Schlüssel generieren, indem Sie den [Generieren Sie ein asymmetrisches EC-Schlüsselpaar mit CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair-ec.md) Befehl verwenden, wobei der `curve` Parameter auf `ed25519` und das `sign` Attribut auf gesetzt ist. `true`

**Anmerkung**  
Signaturen können AWS CloudHSM mit [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md) Unterbefehlen verifiziert werden.

## Benutzertyp
<a name="cloudhsm_cli-crypto-sign-ed25519ph-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Krypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-crypto-sign-ed25519ph-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.
+ HashEdDSA-Signaturvorgänge werden nur auf hsm2m.medium-Instances im Nicht-FIPS-Modus unterstützt.

## Syntax
<a name="cloudhsm_cli-crypto-sign-ed25519ph-syntax"></a>

```
aws-cloudhsm > help crypto sign ed25519ph
Sign with the Ed25519ph mechanism

Usage: crypto sign ed25519ph [OPTIONS] --key-filter [<KEY_FILTER>...] --data-type <DATA_TYPE> --hash-function <HASH_FUNCTION> <--data-path <DATA_PATH>|--data <DATA>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --key-filter [<KEY_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key
      --data-path <DATA_PATH>
          The path to the file containing the data to be signed
      --data <DATA>
          Base64 Encoded data to be signed
      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
      --data-type <DATA_TYPE>
          The type of data passed in, either raw or digest [possible values: raw, digest]
      --hash-function <HASH_FUNCTION>
          Hash function [possible values: sha512]
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-crypto-sign-ed25519ph-examples"></a>

Diese Beispiele zeigen, wie eine Signatur mithilfe des **crypto sign ed25519ph** Ed25519PH-Signaturmechanismus und der Hash-Funktion generiert wird. `sha512` Dieser Befehl verwendet einen privaten Schlüssel im HSM.

**Example Beispiel: Generieren Sie eine Signatur für Base-64-kodierte Daten**  

```
aws-cloudhsm > crypto sign ed25519ph \
    --key-filter attr.label=ed25519-private \
    --data-type raw \
    --hash-function sha512 \
    --data YWJj
{
  "error_code": 0,
  "data": {
    "key-reference": "0x0000000000401cdf",
    "signature": "mKcCIvC4Ehqp0w+BPWg/gJ5GK0acf/h2OUmbuU5trkEx+FBCRjwqNVogA9BirfWqoQuMYeY2Biqq0RwqJgg0Bg=="
  }
}
```

**Example Beispiel: Generieren Sie eine Signatur für eine Datendatei**  

```
aws-cloudhsm > crypto sign ed25519ph \
    --key-filter attr.label=ed25519-private \
    --data-type raw \
    --hash-function sha512 \
    --data-path data.txt
{
  "error_code": 0,
  "data": {
    "key-reference": "0x0000000000401cdf",
    "signature": "mKcCIvC4Ehqp0w+BPWg/gJ5GK0acf/h2OUmbuU5trkEx+FBCRjwqNVogA9BirfWqoQuMYeY2Biqq0RwqJgg0Bg=="
  }
}
```

## Argumente
<a name="cloudhsm_cli-crypto-sign-ed25519ph-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<DATA>***  
Base64-kodierte Daten, die signiert werden sollen.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<DATA\$1PATH>***  
Gibt den Speicherort der zu signierenden Daten an.  
Erforderlich: Ja (sofern nicht über den Datenparameter angegeben)

***<HASH\$1FUNCTION>***  
Gibt die Hash-Funktion an. ED25519Ph unterstützt nur. SHA512   
Zulässige Werte:  
+ sha512
Erforderlich: Ja

***<KEY\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form attr.key\$1attribute\$1name=KEY\$1ATTRIBUTE\$1VALUE, um einen passenden Schlüssel auszuwählen.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter. [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)  
Erforderlich: Ja

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des privaten Schlüssels für den Schlüsselverwendungsdienst größer als 1 ist.

***<DATA\$1TYPE>***  
 Gibt an, ob der Wert des Datenparameters als Teil des Signaturalgorithmus gehasht werden soll. Wird `raw` für Daten ohne Hashwert verwendet; wird `digest` für Digests verwendet, die bereits gehasht wurden.   
Zulässige Werte:  
+ RAW
+ Digest
Erforderlich: Ja

## Verwandte Themen
<a name="cloudhsm_cli-crypto-sign-ed25519ph-seealso"></a>
+ [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md)
+ [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md)

# Generieren Sie eine Signatur mit dem RSA-PKCS-Mechanismus in der CloudHSM-CLI
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs"></a>

Verwenden Sie den **crypto sign rsa-pkcs** Befehl in der CloudHSM-CLI, um eine Signatur mithilfe eines privaten RSA-Schlüssels und des RSA-PKCS-Signaturmechanismus zu generieren.

Um den **crypto sign rsa-pkcs** Befehl verwenden zu können, benötigen Sie zunächst einen privaten RSA-Schlüssel in Ihrem Cluster. AWS CloudHSM Sie können mit dem [Generieren Sie ein asymmetrisches RSA-Schlüsselpaar mit CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md) Befehl, dessen `sign` Attribut auf gesetzt ist, einen privaten RSA-Schlüssel generieren. `true`

**Anmerkung**  
Signaturen können AWS CloudHSM mit [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md) Unterbefehlen verifiziert werden.

## Benutzertyp
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Krypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-syntax"></a>

```
aws-cloudhsm > help crypto sign rsa-pkcs
Sign with the RSA-PKCS mechanism

Usage: crypto sign rsa-pkcs --key-filter [<KEY_FILTER>>...] --hash-function <HASH_FUNCTION> <--data-path <DATA_PATH>|--data <DATA>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --key-filter [<KEY_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key
      --hash-function <HASH_FUNCTION>
          [possible values: sha1, sha224, sha256, sha384, sha512]
      --data-path <DATA_PATH>
          The path to the file containing the data to be signed
      --data <DATA>
          Base64 Encoded data to be signed
      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
      --data-type <DATA_TYPE>
          The type of data passed in, either raw or digest [possible values: raw, digest]
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-examples"></a>

Diese Beispiele zeigen, wie eine Signatur mithilfe des RSA-PKCS-Signaturmechanismus und `SHA256` der Hash-Funktion generiert wird. **crypto sign rsa-pkcs** Dieser Befehl verwendet einen privaten Schlüssel im HSM.

**Example Beispiel: Generieren Sie eine Signatur für Base-64-kodierte Daten**  

```
aws-cloudhsm > crypto sign rsa-pkcs --key-filter attr.label=rsa-private --hash-function sha256 --data YWJjMTIz
{
  "error_code": 0,
  "data": {
    "key-reference": "0x00000000007008db",
    "signature": "XJ7mRyHnDRYrDWTQuuNb+5mhoXx7VTsPMjgOQW4iMN7E42eNHj2Q0oovMmBdHUEH0F4HYG8FBJOBhvGuM8J/z6y41GbowVpUT6WzjnIQs79K9i7i6oR1TYjLnIS3r/zkimuXcS8/ZxyDzru+GO9BUT9FFU/of9cvu4Oyn6a5+IXuCbKNQs19uASuFARUTZ0a0Ny1CB1MulxUpqGTmI91J6evlP7k/2khwDmJ5E8FEar5/Cvbn9t21p3Uj561ngTXrYbIZ2KHpef9jQh/cEIvFLG61sexJjQi8EdTxeDA+I3ITO0qrvvESvA9+Sj7kdG2ceIicFS8/8LwyxiIC31UHQ=="
  }
}
```

**Example Beispiel: Generieren Sie eine Signatur für eine Datendatei**  

```
aws-cloudhsm > crypto sign rsa-pkcs --key-filter attr.label=rsa-private --hash-function sha256 --data-path data.txt
{
  "error_code": 0,
  "data": {
    "key-reference": "0x00000000007008db",
    "signature": "XJ7mRyHnDRYrDWTQuuNb+5mhoXx7VTsPMjgOQW4iMN7E42eNHj2Q0oovMmBdHUEH0F4HYG8FBJOBhvGuM8J/z6y41GbowVpUT6WzjnIQs79K9i7i6oR1TYjLnIS3r/zkimuXcS8/ZxyDzru+GO9BUT9FFU/of9cvu4Oyn6a5+IXuCbKNQs19uASuFARUTZ0a0Ny1CB1MulxUpqGTmI91J6evlP7k/2khwDmJ5E8FEar5/Cvbn9t21p3Uj561ngTXrYbIZ2KHpef9jQh/cEIvFLG61sexJjQi8EdTxeDA+I3ITO0qrvvESvA9+Sj7kdG2ceIicFS8/8LwyxiIC31UHQ=="
  }
}
```

## Argumente
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<DATA>***  
Base64-kodierte Daten, die signiert werden sollen.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<DATA\$1PATH>***  
Gibt den Speicherort der zu signierenden Daten an.  
Erforderlich: Ja (sofern nicht in Form von Daten angegeben)

***<HASH\$1FUNCTION>***  
Spezifiziert die Hash-Funktion.   
Zulässige Werte:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Erforderlich: Ja

***<KEY\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` zur Auswahl eines passenden Schlüssels.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter Schlüsselattribute für CloudHSM CLI.  
Erforderlich: Ja

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des privaten Schlüssels für den Schlüsselnutzungsdienst größer als 1 ist.

***<DATA\$1TYPE>***  
 Gibt an, ob der Wert des Datenparameters als Teil des Signaturalgorithmus gehasht werden soll. Wird `raw` für Daten ohne Hashwert verwendet; wird `digest` für Digests verwendet, die bereits gehasht wurden.   
[Für RSA-PKCS müssen die Daten im DER-codierten Format übergeben werden, wie in RFC 8017, Abschnitt 9.2 spezifiziert](https://www.rfc-editor.org/rfc/rfc8017#section-9.2)  
Zulässige Werte:  
+ RAW
+ Digest

## Verwandte Themen
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-seealso"></a>
+ [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md)
+ [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md)

# Generieren Sie eine Signatur mit dem RSA-PKCS-PSS Mechanismus in CloudHSM CLI
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-pss"></a>

Verwenden Sie den **crypto sign rsa-pkcs-pss** Befehl in der CloudHSM-CLI, um mithilfe eines privaten RSA-Schlüssels und des `RSA-PKCS-PSS` Signaturmechanismus eine Signatur zu generieren.

Um den **crypto sign rsa-pkcs-pss** Befehl verwenden zu können, benötigen Sie zunächst einen privaten RSA-Schlüssel in Ihrem Cluster. AWS CloudHSM Sie können mit dem [Generieren Sie ein asymmetrisches RSA-Schlüsselpaar mit CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md) Befehl, dessen `sign` Attribut auf gesetzt ist, einen privaten RSA-Schlüssel generieren. `true`

**Anmerkung**  
Signaturen können AWS CloudHSM mit [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md) Unterbefehlen verifiziert werden.

## Benutzertyp
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Krypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-syntax"></a>

```
aws-cloudhsm > help crypto sign rsa-pkcs-pss
Sign with the RSA-PKCS-PSS mechanism

Usage: crypto sign rsa-pkcs-pss [OPTIONS] --key-filter [<KEY_FILTER>...] --hash-function <HASH_FUNCTION> --mgf <MGF> --salt-length <SALT_LENGTH> <--data-path <DATA_PATH>|--data <DATA>>

Options:
      --cluster-id <CLUSTER_ID>        Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --key-filter [<KEY_FILTER>...]   Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key
      --hash-function <HASH_FUNCTION>  [possible values: sha1, sha224, sha256, sha384, sha512]
      --data-path <DATA_PATH>          The path to the file containing the data to be signed
      --data <DATA>                    Base64 Encoded data to be signed
      --mgf <MGF>                      The mask generation function [possible values: mgf1-sha1, mgf1-sha224, mgf1-sha256, mgf1-sha384, mgf1-sha512]
      --salt-length <SALT_LENGTH>      The salt length
      --approval <APPROVAL>            Filepath of signed quorum token file to approve operation
      --data-type <DATA_TYPE>          The type of data passed in, either raw or digest [possible values: raw, digest]
  -h, --help                           Print help
```

## Beispiel
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-examples"></a>

Diese Beispiele zeigen, wie eine Signatur mithilfe des `RSA-PKCS-PSS` Signaturmechanismus und der `SHA256` Hash-Funktion generiert wird. **crypto sign rsa-pkcs-pss** Dieser Befehl verwendet einen privaten Schlüssel im HSM.

**Example Beispiel: Generieren Sie eine Signatur für Base-64-kodierte Daten**  

```
aws-cloudhsm > crypto sign rsa-pkcs-pss --key-filter attr.label=rsa-private --hash-function sha256 --data YWJjMTIz --salt-length 10 --mgf mgf1-sha256
{
  "error_code": 0,
  "data": {
    "key-reference": "0x00000000007008db",
    "signature": "H/z1rYVMzNAa31K4amE5MTiwGxDdCTgQXCJXRBKVOVm7ZuyI0fGE4sT/BUN+977mQEV2TqtWpTsiF2IpwGM1VfSBRt7h/g4o6YERm1tTQLl7q+AJ7uGGK37zCsWQrAo7Vy8NzPShxekePo/ZegrB1aHWN1fE8H3IPUKqLuMDI9o1Jq6kM986ExS7YmeOIclcZkyykTWqHLQVL2C3+A2bHJZBqRcM5XoIpk8HkPypjpN+m4FNUds30GAemoOMl6asSrEJSthaZWV53OBsDOqzA8Rt8JdhXS+GZp3vNLdL1OTBELDPweXVgAu4dBX0FOvpw/gg6sNvuaDK4YOBv2fqKg=="
  }
}
```

**Example Beispiel: Generieren Sie eine Signatur für eine Datendatei**  

```
aws-cloudhsm > crypto sign rsa-pkcs-pss --key-filter attr.label=rsa-private --hash-function sha256 --data-path data.txt --salt-length 10 --mgf mgf1-sha256
{
  "error_code": 0,
  "data": {
    "key-reference": "0x00000000007008db",
    "signature": "H/z1rYVMzNAa31K4amE5MTiwGxDdCTgQXCJXRBKVOVm7ZuyI0fGE4sT/BUN+977mQEV2TqtWpTsiF2IpwGM1VfSBRt7h/g4o6YERm1tTQLl7q+AJ7uGGK37zCsWQrAo7Vy8NzPShxekePo/ZegrB1aHWN1fE8H3IPUKqLuMDI9o1Jq6kM986ExS7YmeOIclcZkyykTWqHLQVL2C3+A2bHJZBqRcM5XoIpk8HkPypjpN+m4FNUds30GAemoOMl6asSrEJSthaZWV53OBsDOqzA8Rt8JdhXS+GZp3vNLdL1OTBELDPweXVgAu4dBX0FOvpw/gg6sNvuaDK4YOBv2fqKg=="
  }
}
```

## Argumente
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<DATA>***  
Base64-kodierte Daten, die signiert werden sollen.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<DATA\$1PATH>***  
Gibt den Speicherort der zu signierenden Daten an.  
Erforderlich: Ja (sofern nicht in Form von Daten angegeben)

***<HASH\$1FUNCTION>***  
Spezifiziert die Hash-Funktion.   
Zulässige Werte:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Erforderlich: Ja

***<KEY\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` zur Auswahl eines passenden Schlüssels.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter Schlüsselattribute für CloudHSM CLI.  
Erforderlich: Ja

***<MGF>***  
Spezifiziert die Funktion zur Maskengenerierung.  
Die Hash-Funktion der Maskengenerierungsfunktion muss mit der Hash-Funktion des Signaturmechanismus übereinstimmen.
Zulässige Werte:  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Erforderlich: Ja

***<SALT\$1LENGTH>***  
Gibt die Länge des Salzes an.  
Erforderlich: Ja

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des privaten Schlüssels für den Schlüsselverwendungsdienst größer als 1 ist.

***<DATA\$1TYPE>***  
 Gibt an, ob der Wert des Datenparameters als Teil des Signaturalgorithmus gehasht werden soll. Wird `raw` für Daten ohne Hashwert verwendet; wird `digest` für Digests verwendet, die bereits gehasht wurden.   
Zulässige Werte:  
+ RAW
+ Digest

## Verwandte Themen
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-seealso"></a>
+ [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md)
+ [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md)

## Verwandte Themen
<a name="cloudhsm_cli-crypto-sign-seealso"></a>
+ [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md)

# Die Kategorie Crypto Verify in CloudHSM CLI
<a name="cloudhsm_cli-crypto-verify"></a>

In der CloudHSM-CLI **crypto verify** ist dies eine übergeordnete Kategorie für eine Gruppe von Befehlen, die in Kombination mit der übergeordneten Kategorie bestätigt, ob eine Datei mit einem bestimmten Schlüssel signiert wurde. **crypto verify**hat die folgenden Unterbefehle: 
+ [kryptoverifizieren (ecdsa)](cloudhsm_cli-crypto-verify-ecdsa.md)
+ [kryptoverifizieren Sie ed25519ph](cloudhsm_cli-crypto-verify-ed25519ph.md)
+ [kryptoverifizieren Sie RSA-PKCS](cloudhsm_cli-crypto-verify-rsa-pkcs.md)
+ [kryptoverifizieren rsa-pkcs-pss](cloudhsm_cli-crypto-verify-rsa-pkcs-pss.md)

Der **crypto verify** Befehl vergleicht eine signierte Datei mit einer Quelldatei und analysiert anhand eines bestimmten öffentlichen Schlüssels und Signierungsmechanismus, ob sie kryptografisch verwandt sind.

**Anmerkung**  
Dateien können AWS CloudHSM mit dem Vorgang angemeldet werden. [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md)

# Überprüfen Sie eine mit dem ECDSA-Mechanismus signierte Signatur in der CloudHSM-CLI
<a name="cloudhsm_cli-crypto-verify-ecdsa"></a>

Verwenden Sie den **crypto verify ecdsa** Befehl in der CloudHSM-CLI, um die folgenden Vorgänge abzuschließen:
+ Bestätigen Sie, dass eine Datei im HSM mit einem bestimmten öffentlichen Schlüssel signiert wurde.
+ Stellen Sie sicher, dass die Signatur mithilfe des ECDSA-Signaturmechanismus generiert wurde.
+ Vergleichen Sie eine signierte Datei mit einer Quelldatei und stellen Sie anhand eines bestimmten öffentlichen ECDSA-Schlüssels und Signaturmechanismus fest, ob die beiden kryptografisch verwandt sind. 
+  Die ECDSA-Überprüfungsfunktion erwartet die Signatur in dem Format`r||s`, in dem die Komponenten R und S als binäre Rohdaten verkettet werden. 

Um den **crypto verify ecdsa** Befehl verwenden zu können, benötigen Sie zunächst einen öffentlichen EC-Schlüssel in Ihrem Cluster. AWS CloudHSM Sie können einen öffentlichen EC-Schlüssel importieren, indem Sie den [Importieren Sie einen Schlüssel im PEM-Format mit der CloudHSM-CLI](cloudhsm_cli-key-import-pem.md) Befehl verwenden, dessen `verify` Attribut auf gesetzt ist`true`.

**Anmerkung**  
Sie können in der CloudHSM-CLI eine Signatur mit [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md) Unterbefehlen generieren.

## Benutzertyp
<a name="cloudhsm_cli-crypto-verify-ecdsa-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-crypto-verify-ecdsa-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-crypto-verify-ecdsa-syntax"></a>

```
aws-cloudhsm > help crypto verify ecdsa
Verify with the ECDSA mechanism

Usage: crypto verify ecdsa --key-filter [<KEY_FILTER>...] --hash-function <HASH_FUNCTION> <--data-path <DATA_PATH>|--data <DATA>> <--signature-path <SIGNATURE_PATH>|--signature <SIGNATURE>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --key-filter [<KEY_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key
      --hash-function <HASH_FUNCTION>
          [possible values: sha1, sha224, sha256, sha384, sha512]
      --data-path <DATA_PATH>
          The path to the file containing the data to be verified
      --data <DATA>
          Base64 encoded data to be verified
      --signature-path <SIGNATURE_PATH>
          The path to where the signature is located
      --signature <SIGNATURE>
          Base64 encoded signature to be verified
      --data-type <DATA_TYPE>
          The type of data passed in, either raw or digest [possible values: raw, digest]
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-crypto-verify-ecdsa-examples"></a>

Diese Beispiele zeigen, wie eine Signatur verifiziert werden kann, die mithilfe des ECDSA-Signaturmechanismus und der `SHA256` Hash-Funktion generiert wurde. **crypto verify ecdsa** Dieser Befehl verwendet einen öffentlichen Schlüssel im HSM.

**Example Beispiel: Überprüfen Sie eine Base64-codierte Signatur mit Base64-codierten Daten**  

```
aws-cloudhsm > crypto verify ecdsa --hash-function sha256 --key-filter attr.label=ec-public --data YWJjMTIz --signature 4zki+FzjhP7Z/KqoQvh4ueMAxQQVp7FQguZ2wOS3Q5bzk+Hc5irV5iTkuxQbropPttVFZ8V6FgR2fz+sPegwCw==
{
  "error_code": 0,
  "data": {
    "message": "Signature verified successfully"
  }
}
```

**Example Beispiel: Überprüfen Sie eine Signaturdatei mit einer Datendatei**  

```
aws-cloudhsm > crypto verify ecdsa --hash-function sha256 --key-filter attr.label=ec-public --data-path data.txt --signature-path signature-file
{
   "error_code": 0,
  "data": {
    "message": "Signature verified successfully"
  }
}
```

**Example Beispiel: Nachweis einer falschen Signaturbeziehung**  
Mit diesem Befehl wird überprüft, ob die unter befindlichen Daten mit einem öffentlichen Schlüssel mit der Bezeichnung signiert `/home/data` wurden. Dabei wird der ECDSA-Signaturmechanismus `ecdsa-public` verwendet, um die Signatur zu erzeugen, die sich in befindet. `/home/signature` Da die angegebenen Argumente keine echte Signaturbeziehung bilden, gibt der Befehl eine Fehlermeldung zurück.  

```
aws-cloudhsm > crypto verify ecdsa --hash-function sha256 --key-filter attr.label=ec-public --data aW52YWxpZA== --signature +ogk7M7S3iTqFg3SndJfd91dZFr5Qo6YixJl8JwcvqqVgsVuO6o+VKvTRjz0/V05kf3JJbBLr87Q+wLWcMAJfA==
{
  "error_code": 1,
  "data": "Signature verification failed"
}
```

## Argumente
<a name="cloudhsm_cli-crypto-verify-ecdsa-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<DATA>***  
Base64-kodierte Daten, die signiert werden sollen.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<DATA\$1PATH>***  
Gibt den Speicherort der zu signierenden Daten an.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<HASH\$1FUNCTION>***  
Gibt die Hash-Funktion an.   
Zulässige Werte:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Erforderlich: Ja

***<KEY\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` zur Auswahl eines passenden Schlüssels.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter Schlüsselattribute für CloudHSM CLI.  
Erforderlich: Ja

***<SIGNATURE>***  
Base64-kodierte Signatur.  
Erforderlich: Ja (sofern nicht über den Signaturpfad angegeben)

***<SIGNATURE\$1PATH>***  
Gibt den Speicherort der Signatur an.  
Erforderlich: Ja (sofern nicht im Signaturpfad angegeben)

***<DATA\$1TYPE>***  
 Gibt an, ob der Wert des Datenparameters als Teil des Signaturalgorithmus gehasht werden soll. Wird `raw` für Daten ohne Hashwert verwendet; wird `digest` für Digests verwendet, die bereits gehasht wurden.   
Zulässige Werte:  
+ RAW
+ Digest

## Verwandte Themen
<a name="cloudhsm_cli-crypto-verify-ecdsa-seealso"></a>
+ [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md)
+ [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md)

# Überprüfen Sie eine mit dem HashEd DSA-Mechanismus signierte Signatur in der CloudHSM-CLI
<a name="cloudhsm_cli-crypto-verify-ed25519ph"></a>

**Wichtig**  
HashEdVorgänge zur Überprüfung der DSA-Signatur werden nur auf hsm2m.medium-Instances im Nicht-FIPS-Modus unterstützt.

Verwenden Sie den **crypto verify ed25519ph** Befehl in der CloudHSM-CLI, um die folgenden Vorgänge abzuschließen:
+ Überprüfen Sie die Signaturen von Daten oder Dateien mithilfe eines bestimmten öffentlichen Ed25519-Schlüssels.
+ Vergewissern Sie sich, dass die Signatur mithilfe des HashEd DSA-Signaturmechanismus generiert wurde. Weitere Informationen zu HashEd DSA finden Sie unter [NIST SP 186-5](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-5.pdf), Abschnitt 7.8.

Um den **crypto verify ed25519ph** Befehl verwenden zu können, benötigen Sie zunächst einen öffentlichen Ed25519-Schlüssel in Ihrem Cluster. AWS CloudHSM Sie können ein Ed25519-Schlüsselpaar mit dem [Generieren Sie ein asymmetrisches EC-Schlüsselpaar mit CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair-ec.md) Befehl generieren, bei dem der `curve` Parameter auf `ed25519` und das `verify` Attribut auf gesetzt ist`true`, oder einen öffentlichen Ed25519-Schlüssel mit dem [Importieren Sie einen Schlüssel im PEM-Format mit der CloudHSM-CLI](cloudhsm_cli-key-import-pem.md) Befehl importieren, bei dem das Attribut auf gesetzt ist. `verify` `true`

**Anmerkung**  
Sie können in der CloudHSM-CLI eine Signatur mit [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md) Unterbefehlen generieren.

## Benutzertyp
<a name="cloudhsm_cli-crypto-verify-ed25519ph-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-crypto-verify-ed25519ph-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.
+ HashEdVorgänge zur Überprüfung der DSA-Signatur werden nur auf hsm2m.medium-Instances im Nicht-FIPS-Modus unterstützt.

## Syntax
<a name="cloudhsm_cli-crypto-verify-ed25519ph-syntax"></a>

```
aws-cloudhsm > help crypto verify ed25519ph
Verify with the Ed25519ph mechanism

Usage: crypto verify ed25519ph [OPTIONS] --key-filter [<KEY_FILTER>...] --data-type <DATA_TYPE> --hash-function <HASH_FUNCTION> <--data-path <DATA_PATH>|--data <DATA>> <--signature-path <SIGNATURE_PATH>|--signature <SIGNATURE>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --key-filter [<KEY_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key
      --data-path <DATA_PATH>
          The path to the file containing the data to be verified
      --data <DATA>
          Base64 encoded data to be verified
      --signature-path <SIGNATURE_PATH>
          The path to where the signature is located
      --signature <SIGNATURE>
          Base64 encoded signature to be verified
      --data-type <DATA_TYPE>
          The type of data passed in, either raw or digest [possible values: raw, digest]
      --hash-function <HASH_FUNCTION>
          Hash function [possible values: sha512]
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-crypto-verify-ed25519ph-examples"></a>

Diese Beispiele zeigen, wie eine Signatur verifiziert wird, **crypto verify ed25519ph** die mit dem Signaturmechanismus und der Hash-Funktion ED25519PH generiert wurde. `sha512` Dieser Befehl verwendet einen öffentlichen Ed25519-Schlüssel im HSM.

**Example Beispiel: Überprüfen Sie eine Base64-codierte Signatur mit Base64-codierten Daten**  

```
aws-cloudhsm > crypto verify ed25519ph \
    --hash-function sha512 \
    --key-filter attr.label=ed25519-public \
    --data-type raw \
    --data YWJj \
    --signature mKcCIvC4Ehqp0w+BPWg/gJ5GK0acf/h2OUmbuU5trkEx+FBCRjwqNVogA9BirfWqoQuMYeY2Biqq0RwqJgg0Bg==
{
  "error_code": 0,
  "data": {
    "message": "Signature verified successfully"
  }
}
```

**Example Beispiel: Überprüfen Sie eine Signaturdatei mit einer Datendatei**  

```
aws-cloudhsm > crypto verify ed25519ph \
    --hash-function sha512 \
    --key-filter attr.label=ed25519-public \
    --data-type raw \
    --data-path data.txt \
    --signature-path signature-file
{
  "error_code": 0,
  "data": {
    "message": "Signature verified successfully"
  }
}
```

## Argumente
<a name="cloudhsm_cli-crypto-verify-ed25519ph-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<DATA>***  
Base64-kodierte Daten müssen verifiziert werden.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<DATA\$1PATH>***  
Gibt den Speicherort der zu überprüfenden Daten an.  
Erforderlich: Ja (sofern nicht über den Datenparameter angegeben)

***<HASH\$1FUNCTION>***  
Gibt die Hash-Funktion an. ED25519Ph unterstützt nur. SHA512   
Zulässige Werte:  
+ sha512
Erforderlich: Ja

***<KEY\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` zur Auswahl eines passenden Schlüssels.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter. [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)  
Erforderlich: Ja

***<SIGNATURE>***  
Base64-kodierte Signatur.  
Erforderlich: Ja (sofern nicht im Signaturpfad angegeben)

***<SIGNATURE\$1PATH>***  
Gibt den Speicherort der Signatur an.  
Erforderlich: Ja (sofern nicht über den Signaturparameter angegeben)

***<DATA\$1TYPE>***  
 Gibt an, ob der Wert des Datenparameters als Teil des Überprüfungsalgorithmus gehasht werden soll. Wird `raw` für Daten ohne Hashwert verwendet; wird `digest` für Digests verwendet, die bereits gehasht wurden.   
Zulässige Werte:  
+ RAW
+ Digest
Erforderlich: Ja

## Verwandte Themen
<a name="cloudhsm_cli-crypto-verify-ed25519ph-seealso"></a>
+ [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md)
+ [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md)
+ [Generieren Sie eine Signatur mit dem HashEd DSA-Mechanismus in der CloudHSM-CLI](cloudhsm_cli-crypto-sign-ed25519ph.md)

# Überprüfen Sie eine mit dem RSA-PKCS-Mechanismus signierte Signatur in der CloudHSM-CLI
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs"></a>

Verwenden Sie den **crypto verify rsa-pkcs** Befehl in der CloudHSM-CLI, um die folgenden Vorgänge abzuschließen:
+ Bestätigen Sie, dass eine Datei im HSM mit einem bestimmten öffentlichen Schlüssel signiert wurde.
+ Stellen Sie sicher, dass die Signatur mithilfe des `RSA-PKCS` Signaturmechanismus generiert wurde.
+ Vergleicht eine signierte Datei mit einer Quelldatei und ermittelt anhand eines bestimmten öffentlichen RSA-Schlüssels und Signaturmechanismus, ob die beiden kryptografisch verwandt sind.

Um den **crypto verify rsa-pkcs** Befehl verwenden zu können, müssen Sie zunächst über einen öffentlichen RSA-Schlüssel in Ihrem Cluster verfügen. AWS CloudHSM 

**Anmerkung**  
Sie können mithilfe der CloudHSM-CLI mit den Unterbefehlen eine Signatur generieren. [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md)

## Benutzertyp
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-syntax"></a>

```
aws-cloudhsm > help crypto verify rsa-pkcs
Verify with the RSA-PKCS mechanism

Usage: crypto verify rsa-pkcs --key-filter [<KEY_FILTER>...] --hash-function <HASH_FUNCTION> <--data-path <DATA_PATH>|--data <DATA>> <--signature-path <SIGNATURE_PATH>|--signature <SIGNATURE>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --key-filter [<KEY_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key
      --hash-function <HASH_FUNCTION>
          [possible values: sha1, sha224, sha256, sha384, sha512]
      --data-path <DATA_PATH>
          The path to the file containing the data to be verified
      --data <DATA>
          Base64 encoded data to be verified
      --signature-path <SIGNATURE_PATH>
          The path to where the signature is located
      --signature <SIGNATURE>
          Base64 encoded signature to be verified
      --data-type <DATA_TYPE>
          The type of data passed in, either raw or digest [possible values: raw, digest]
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-examples"></a>

Diese Beispiele zeigen, wie eine Signatur verifiziert werden kann, die mithilfe des RSA-PKCS-Signaturmechanismus und `SHA256` der Hash-Funktion generiert wurde. **crypto verify rsa-pkcs** Dieser Befehl verwendet einen öffentlichen Schlüssel im HSM.

**Example Beispiel: Überprüfen Sie eine Base64-codierte Signatur mit Base64-codierten Daten**  

```
aws-cloudhsm > crypto verify rsa-pkcs --hash-function sha256 --key-filter attr.label=rsa-public --data YWJjMTIz --signature XJ7mRyHnDRYrDWTQuuNb+5mhoXx7VTsPMjgOQW4iMN7E42eNHj2Q0oovMmBdHUEH0F4HYG8FBJOBhvGuM8J/z6y41GbowVpUT6WzjnIQs79K9i7i6oR1TYjLnIS3r/zkimuXcS8/ZxyDzru+GO9BUT9FFU/of9cvu4Oyn6a5+IXuCbKNQs19uASuFARUTZ0a0Ny1CB1MulxUpqGTmI91J6evlP7k/2khwDmJ5E8FEar5/Cvbn9t21p3Uj561ngTXrYbIZ2KHpef9jQh/cEIvFLG61sexJjQi8EdTxeDA+I3ITO0qrvvESvA9+Sj7kdG2ceIicFS8/8LwyxiIC31UHQ==
{
  "error_code": 0,
  "data": {
    "message": "Signature verified successfully"
  }
}
```

**Example Beispiel: Verifizieren Sie eine Signaturdatei mit einer Datendatei**  

```
aws-cloudhsm > crypto verify rsa-pkcs --hash-function sha256 --key-filter attr.label=rsa-public --data-path data.txt --signature-path signature-file
{
  "error_code": 0,
  "data": {
    "message": "Signature verified successfully"
  }
}
```

**Example Beispiel: Beweisen Sie die Beziehung zwischen falschen Signaturen**  
Mit diesem Befehl wird überprüft, ob die ungültigen Daten mit einem öffentlichen Schlüssel mit der Bezeichnung signiert wurden. Dabei wird der RSAKCS-Signaturmechanismus `rsa-public` verwendet, um die Signatur zu erzeugen, die sich in befindet. `/home/signature` Da die angegebenen Argumente keine echte Signaturbeziehung bilden, gibt der Befehl eine Fehlermeldung zurück.  

```
aws-cloudhsm > crypto verify rsa-pkcs --hash-function sha256 --key-filter attr.label=rsa-public --data aW52YWxpZA== --signature XJ7mRyHnDRYrDWTQuuNb+5mhoXx7VTsPMjgOQW4iMN7E42eNHj2Q0oovMmBdHUEH0F4HYG8FBJOBhvGuM8J/z6y41GbowVpUT6WzjnIQs79K9i7i6oR1TYjLnIS3r/zkimuXcS8/ZxyDzru+GO9BUT9FFU/of9cvu4Oyn6a5+IXuCbKNQs19uASuFARUTZ0a0Ny1CB1MulxUpqGTmI91J6evlP7k/2khwDmJ5E8FEar5/Cvbn9t21p3Uj561ngTXrYbIZ2KHpef9jQh/cEIvFLG61sexJjQi8EdTxeDA+I3ITO0qrvvESvA9+Sj7kdG2ceIicFS8/8LwyxiIC31UHQ==
{
  "error_code": 1,
  "data": "Signature verification failed"
}
```

## Argumente
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<DATA>***  
Base64-kodierte Daten, die signiert werden sollen.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<DATA\$1PATH>***  
Gibt den Speicherort der zu signierenden Daten an.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<HASH\$1FUNCTION>***  
Gibt die Hash-Funktion an.   
Zulässige Werte:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Erforderlich: Ja

***<KEY\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` zur Auswahl eines passenden Schlüssels.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter Schlüsselattribute für CloudHSM CLI.  
Erforderlich: Ja

***<SIGNATURE>***  
Base64-kodierte Signatur.  
Erforderlich: Ja (sofern nicht über den Signaturpfad angegeben)

***<SIGNATURE\$1PATH>***  
Gibt den Speicherort der Signatur an.  
Erforderlich: Ja (sofern nicht über den Signaturpfad angegeben)

***<DATA\$1TYPE>***  
 Gibt an, ob der Wert des Datenparameters als Teil des Signaturalgorithmus gehasht werden soll. Wird `raw` für Daten ohne Hashwert verwendet; wird `digest` für Digests verwendet, die bereits gehasht wurden.   
[Für RSA-PKCS müssen die Daten im DER-codierten Format übergeben werden, wie in RFC 8017, Abschnitt 9.2 spezifiziert](https://www.rfc-editor.org/rfc/rfc8017#section-9.2)  
Zulässige Werte:  
+ RAW
+ Digest

## Verwandte Themen
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-seealso"></a>
+ [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md)
+ [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md)

# Verifizieren Sie eine Signatur, die mit dem RSA-PKCS-PSS Mechanismus in der CloudHSM-CLI signiert wurde
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-pss"></a>

Verwenden Sie den **crypto sign rsa-pkcs-pss** Befehl in der CloudHSM-CLI, um die folgenden Vorgänge abzuschließen.
+ Bestätigen Sie, dass eine Datei im HSM mit einem bestimmten öffentlichen Schlüssel signiert wurde.
+ Stellen Sie sicher, dass die Signatur mithilfe des RSA-PKCS-PSS Signaturmechanismus generiert wurde.
+ Vergleicht eine signierte Datei mit einer Quelldatei und ermittelt anhand eines bestimmten öffentlichen RSA-Schlüssels und Signaturmechanismus, ob die beiden kryptografisch verwandt sind.

Um den **crypto verify rsa-pkcs-pss** Befehl verwenden zu können, müssen Sie zunächst über einen öffentlichen RSA-Schlüssel in Ihrem Cluster verfügen. AWS CloudHSM Sie können einen öffentlichen RSA-Schlüssel mit dem Befehl key import pem (ADD UNWRAP LINK HERE) importieren, wobei das `verify` Attribut auf gesetzt ist. `true`

**Anmerkung**  
Sie können mithilfe der CloudHSM-CLI mit den Unterbefehlen eine Signatur generieren. [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md)

## Benutzertyp
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-pss-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-pss-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-pss-syntax"></a>

```
aws-cloudhsm > help crypto verify rsa-pkcs-pss
Verify with the RSA-PKCS-PSS mechanism

Usage: crypto verify rsa-pkcs-pss --key-filter [<KEY_FILTER>...] --hash-function <HASH_FUNCTION> --mgf <MGF> --salt-length >SALT_LENGTH< <--data-path <DATA_PATH>|--data <DATA> <--signature-path <SIGNATURE_PATH>|--signature <SIGNATURE>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --key-filter [<KEY_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key
      --hash-function <HASH_FUNCTION>
          [possible values: sha1, sha224, sha256, sha384, sha512]
      --data-path <DATA_PATH>
          The path to the file containing the data to be verified
      --data <DATA>
          Base64 encoded data to be verified
      --signature-path <SIGNATURE_PATH>
          The path to where the signature is located
      --signature <SIGNATURE>
          Base64 encoded signature to be verified
      --data-type <DATA_TYPE>
          The type of data passed in, either raw or digest [possible values: raw, digest]
      --mgf <MGF>
          The mask generation function [possible values: mgf1-sha1, mgf1-sha224, mgf1-sha256, mgf1-sha384, mgf1-sha512]
      --salt-length <SALT_LENGTH>
          The salt length
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-pss-examples"></a>

Diese Beispiele zeigen, wie eine Signatur verifiziert werden kann, die mithilfe des RSA-PKCS-PSS Signaturmechanismus und der `SHA256` Hash-Funktion generiert wurde. **crypto verify rsa-pkcs-pss** Dieser Befehl verwendet einen öffentlichen Schlüssel im HSM.

**Example Beispiel: Überprüfen Sie eine Base64-codierte Signatur mit Base64-codierten Daten**  

```
aws-cloudhsm > crypto verify rsa-pkcs-pss --key-filter attr.label=rsa-public --hash-function sha256 --data YWJjMTIz --salt-length 10 --mgf mgf1-sha256 --signature H/z1rYVMzNAa31K4amE5MTiwGxDdCTgQXCJXRBKVOVm7ZuyI0fGE4sT/BUN+977mQEV2TqtWpTsiF2IpwGM1VfSBRt7h/g4o6YERm1tTQLl7q+AJ7uGGK37zCsWQrAo7Vy8NzPShxekePo/ZegrB1aHWN1fE8H3IPUKqLuMDI9o1Jq6kM986ExS7YmeOIclcZkyykTWqHLQVL2C3+A2bHJZBqRcM5XoIpk8HkPypjpN+m4FNUds30GAemoOMl6asSrEJSthaZWV53OBsDOqzA8Rt8JdhXS+GZp3vNLdL1OTBELDPweXVgAu4dBX0FOvpw/gg6sNvuaDK4YOBv2fqKg==
{
  "error_code": 0,
  "data": {
    "message": "Signature verified successfully"
  }
}
```

**Example Beispiel: Verifizieren Sie eine Signaturdatei mit einer Datendatei**  

```
aws-cloudhsm > crypto verify rsa-pkcs-pss --key-filter attr.label=rsa-public --hash-function sha256 --data-path data.txt --salt-length 10 --mgf mgf1-sha256 --signature signature-file
{
  "error_code": 0,
  "data": {
    "message": "Signature verified successfully"
  }
}
```

**Example Beispiel: Nachweis einer falschen Signaturbeziehung**  
Mit diesem Befehl wird überprüft, ob die ungültigen Daten mit einem öffentlichen Schlüssel mit der Bezeichnung signiert wurden. Dabei wird der RSAPKCSPSS-Signaturmechanismus `rsa-public` verwendet, um die Signatur zu erzeugen, die sich in befindet. `/home/signature` Da die angegebenen Argumente keine echte Signaturbeziehung bilden, gibt der Befehl eine Fehlermeldung zurück.  

```
aws-cloudhsm > crypto verify rsa-pkcs-pss --key-filter attr.label=rsa-public --hash-function sha256 --data aW52YWxpZA== --salt-length 10 --mgf mgf1-sha256 --signature H/z1rYVMzNAa31K4amE5MTiwGxDdCTgQXCJXRBKVOVm7ZuyI0fGE4sT/BUN+977mQEV2TqtWpTsiF2IpwGM1VfSBRt7h/g4o6YERm1tTQLl7q+AJ7uGGK37zCsWQrAo7Vy8NzPShxekePo/ZegrB1aHWN1fE8H3IPUKqLuMDI9o1Jq6kM986ExS7YmeOIclcZkyykTWqHLQVL2C3+A2bHJZBqRcM5XoIpk8HkPypjpN+m4FNUds30GAemoOMl6asSrEJSthaZWV53OBsDOqzA8Rt8JdhXS+GZp3vNLdL1OTBELDPweXVgAu4dBX0FOvpw/gg6sNvuaDK4YOBv2fqKg==
{
  "error_code": 1,
  "data": "Signature verification failed"
}
```

## Argumente
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-pss-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<DATA>***  
Base64-kodierte Daten, die signiert werden sollen.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<DATA\$1PATH>***  
Gibt den Speicherort der zu signierenden Daten an.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<HASH\$1FUNCTION>***  
Gibt die Hash-Funktion an.   
Zulässige Werte:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Erforderlich: Ja

***<KEY\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` zur Auswahl eines passenden Schlüssels.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter Schlüsselattribute für CloudHSM CLI.  
Erforderlich: Ja

***<MFG>***  
Spezifiziert die Funktion zur Maskengenerierung.  
Die Hash-Funktion der Maskengenerierungsfunktion muss mit der Hash-Funktion des Signaturmechanismus übereinstimmen.
Zulässige Werte:  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Erforderlich: Ja

***<SIGNATURE>***  
Base64-kodierte Signatur.  
Erforderlich: Ja (sofern nicht über den Signaturpfad angegeben)

***<SIGNATURE\$1PATH>***  
Gibt den Speicherort der Signatur an.  
Erforderlich: Ja (sofern nicht über den Signaturpfad angegeben)

***<DATA\$1TYPE>***  
 Gibt an, ob der Wert des Datenparameters als Teil des Signaturalgorithmus gehasht werden soll. Wird `raw` für Daten ohne Hashwert verwendet; wird `digest` für Digests verwendet, die bereits gehasht wurden.   
Zulässige Werte:  
+ RAW
+ Digest

## Verwandte Themen
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-pss-seealso"></a>
+ [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md)
+ [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md)

# Die Schlüsselkategorie in CloudHSM CLI
<a name="cloudhsm_cli-key"></a>

In der CloudHSM-CLI **key** ist dies eine übergeordnete Kategorie für eine Gruppe von Befehlen, die in Kombination mit der übergeordneten Kategorie einen schlüsselspezifischen Befehl erstellen. Derzeit besteht diese Kategorie aus den folgenden Befehlen:
+ [delete](cloudhsm_cli-key-delete.md)
+ [generate-file](cloudhsm_cli-key-generate-file.md)
+ [key generate-asymmetric-pair](cloudhsm_cli-key-generate-asymmetric-pair.md)
  + [Schlüssel rsa generate-asymmetric-pair](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md)
  + [Schlüssel usw. generate-asymmetric-pair](cloudhsm_cli-key-generate-asymmetric-pair-ec.md)
+ [key generate-symmetric](cloudhsm_cli-key-generate-symmetric.md)
  + [key generate-symmetric aes](cloudhsm_cli-key-generate-symmetric-aes.md)
  + [key generate-symmetric generic-secret](cloudhsm_cli-key-generate-symmetric-generic-secret.md)
+ [PEM importieren](cloudhsm_cli-key-import-pem.md)
+ [list](cloudhsm_cli-key-list.md)
+ [Replikat](cloudhsm_cli-key-replicate.md)
+ [set-attribute](cloudhsm_cli-key-set-attribute.md)
+ [share](cloudhsm_cli-key-share.md)
+ [unshare](cloudhsm_cli-key-unshare.md)
+ [auspacken](cloudhsm_cli-key-unwrap.md)
+ [umwickeln](cloudhsm_cli-key-wrap.md)

# Löschen Sie einen Schlüssel mit CloudHSM CLI
<a name="cloudhsm_cli-key-delete"></a>

Verwenden Sie den **key delete** Befehl in der CloudHSM-CLI, um einen Schlüssel aus einem AWS CloudHSM Cluster zu löschen. Sie können nur jeweils einen Schlüssel löschen. Das Löschen eines Schlüssels in einem Schlüsselpaar hat keine Auswirkungen auf den anderen Schlüssel in diesem Paar. 

Nur der CU, der den Schlüssel erstellt hat und somit Eigentümer des Schlüssels ist, kann den Schlüssel löschen. Benutzer, die den Schlüssel gemeinsam nutzen, ihn aber nicht besitzen, können den Schlüssel für kryptografische Operationen verwenden, ihn aber nicht löschen.

## Benutzertyp
<a name="key-delete-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="key-delete-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="key-delete-syntax"></a>

```
aws-cloudhsm > help key delete
Delete a key in the HSM cluster

Usage: key delete [OPTIONS] --filter [<FILTER>...]

Options:
      --cluster-id <CLUSTER_ID>  Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --filter [<FILTER>...]     Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key for deletion
  -h, --help                     Print help
```

## Beispiel
<a name="key-delete-examples"></a>

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

## Argumente
<a name="key-delete-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein passender Schlüssel zum Löschen ausgewählt werden soll.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)  
Erforderlich: Ja

## Verwandte Themen
<a name="key-delete-seealso"></a>
+ [Schlüssel für einen Benutzer mit CloudHSM CLI auflisten](cloudhsm_cli-key-list.md)
+ [Exportieren Sie einen asymmetrischen Schlüssel mit CloudHSM CLI](cloudhsm_cli-key-generate-file.md)
+ [Freigabe eines Schlüssels mithilfe der CloudHSM-CLI rückgängig machen](cloudhsm_cli-key-unshare.md)
+ [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)
+ [Schlüssel mithilfe der CloudHSM-CLI filtern](manage-keys-cloudhsm-cli-filtering.md)

# Exportieren Sie einen asymmetrischen Schlüssel mit CloudHSM CLI
<a name="cloudhsm_cli-key-generate-file"></a>

Verwenden Sie den **key generate-file** Befehl in der CloudHSM-CLI, um einen asymmetrischen Schlüssel aus dem Hardware-Sicherheitsmodul (HSM) zu exportieren. Wenn das Ziel ein privater Schlüssel ist, wird der Verweis auf den privaten Schlüssel im gefälschten PEM-Format exportiert. Wenn das Ziel ein öffentlicher Schlüssel ist, werden die Bytes des öffentlichen Schlüssels im PEM-Format exportiert.

Die gefälschte PEM-Datei, die nicht das eigentliche Material des privaten Schlüssels enthält, sondern stattdessen auf den privaten Schlüssel im HSM verweist, kann verwendet werden, um die Übertragung von Ihrem SSL/TLS Webserver auf zu einrichten. AWS CloudHSM Weitere Informationen finden Sie unter [SSL/TLS-Offloading](ssl-offload.md).

## Benutzertyp
<a name="key-generate-file-user-type"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Krypto-Benutzer () CUs

## Voraussetzungen
<a name="key-generate-file-requirements"></a>

Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="key-generate-file-syntax"></a>

```
aws-cloudhsm > help key generate-file
Generate a key file from a key in the HSM cluster. This command does not export any private key data from the HSM

Usage: key generate-file --encoding <ENCODING> --path <PATH> --filter [<FILTER>...]

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --encoding <ENCODING>
          Encoding format for the key file

          Possible values:
          - reference-pem: PEM formatted key reference (supports private keys)
          - pem:           PEM format (supports public keys)

      --path <PATH>
          Filepath where the key file will be written

      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key for file generation

  -h, --help
          Print help (see a summary with '-h')
```

## Beispiel
<a name="key-generate-file-examples"></a>

Dieses Beispiel zeigt, wie Sie **key generate-file** damit eine Schlüsseldatei in Ihrem AWS CloudHSM Cluster generieren können.

**Example**  

```
aws-cloudhsm > key generate-file --encoding reference-pem --path /tmp/ec-private-key.pem --filter attr.label="ec-test-private-key"
{
  "error_code": 0,
  "data": {
    "message": "Successfully generated key file"
  }
}
```

## Argumente
<a name="key-generate-file-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein passender Schlüssel zum Löschen ausgewählt werden soll.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Nein

***<ENCODING>***  
Gibt das Kodierungsformat für die Schlüsseldatei an  
Erforderlich: Ja

***<PATH>***  
Gibt den Dateipfad an, in den die Schlüsseldatei geschrieben wird  
Erforderlich: Ja

## Generieren von KSP-Schlüsselreferenzen (Windows)
<a name="key-generate-ksp-key-reference"></a>

**Anmerkung**  
Diese Funktion ist nur in SDK-Version 5.16.0 und höher verfügbar.

### Voraussetzungen
<a name="key-generate-ksp-key-reference-requirements"></a>
+ Sie können KSP-Schlüsselreferenzen nur auf Windows-Plattformen generieren.
+ Sie müssen sich als Crypto-Benutzer (CU) anmelden.

### Speicherort der Datei
<a name="key-generate-ksp-key-reference-options"></a>

Standardmäßig speichert AWS CloudHSM generierte Dateien in: `C:\Users\Default\AppData\Roaming\Microsoft\Crypto\CaviumKSP\GlobalPartition`

Verwenden Sie den Parameter, um einen anderen Speicherort anzugeben. `--path`

### Syntax
<a name="key-generate-ksp-key-reference-syntax"></a>

```
aws-cloudhsm > help key generate-file --encoding ksp-key-reference 
Generate a key file from a key in the HSM cluster. This command does not export any private key data from the HSM

Usage: key generate-file --encoding <ENCODING> --path <PATH> --filter [<FILTER>...]

Options:
      --encoding <ENCODING>
        Encoding format for the key file

        Possible values:
        - reference-pem:     PEM formatted key reference (supports private keys)
        - pem:               PEM format (supports public keys)
        - ksp-key-reference: KSP key reference format

      --cluster-id <CLUSTER_ID>
        Unique Id to choose which of the clusters in the config file to run the operation against. If not provided with multiple clusters configured, will error

      --path <PATH>
        Directory path where the key file will be written

      --filter [<FILTER>...]
        Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key for file generation

      --all
        Generate ksp key reference for all available key pairs in HSM

  -h, --help
        Print help (see a summary with '-h')
```

### Beispiel — Generieren Sie eine KSP-Schlüsselreferenz mithilfe eines Attributfilters für einen privaten Schlüssel
<a name="key-generate-ksp-key-reference-example1"></a>

Das folgende Beispiel generiert eine KSP-Schlüsselreferenz für einen privaten Schlüssel mit einer bestimmten Bezeichnung.

**Example**  

```
aws-cloudhsm > key generate-file --encoding ksp-key-reference --path  --filter attr.label="ec-test-private-key"
{
  "error_code": 0,
  "data": {
    "message": "Successfully generated key file"
  }
}
```

### Beispiel — Generieren Sie KSP-Schlüsselreferenzen für alle Schlüsselpaare
<a name="key-generate-ksp-key-reference-example2"></a>

Im folgenden Beispiel werden KSP-Schlüsselreferenzen für alle Schlüsselpaare in Ihrem Cluster generiert.

**Example**  

```
aws-cloudhsm > key generate-file --encoding ksp-key-reference --all
{
  "error_code": 0,
  "data": {
    "message": "Successfully generated key file"
  }
}
```

## Verwandte Themen
<a name="key-generate-file-seealso"></a>
+ [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)
+ [Schlüssel mithilfe der CloudHSM-CLI filtern](manage-keys-cloudhsm-cli-filtering.md)
+ [Die generate-asymmetric-pair Kategorie in CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair.md)
+ [Die Kategorie „Symmetrisch generieren“ in CloudHSM CLI](cloudhsm_cli-key-generate-symmetric.md)

# Die generate-asymmetric-pair Kategorie in CloudHSM CLI
<a name="cloudhsm_cli-key-generate-asymmetric-pair"></a>

In der CloudHSM-CLI **key generate-asymmetric-pair** ist dies eine übergeordnete Kategorie für eine Gruppe von Befehlen, die in Kombination mit der übergeordneten Kategorie einen Befehl erstellen, der asymmetrische Schlüsselpaare generiert. Derzeit besteht diese Kategorie aus den folgenden Befehlen:
+ [Schlüssel, ec generate-asymmetric-pair](cloudhsm_cli-key-generate-asymmetric-pair-ec.md)
+ [Schlüssel generate-asymmetric-pair RSA](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md)

# Generieren Sie ein asymmetrisches EC-Schlüsselpaar mit CloudHSM CLI
<a name="cloudhsm_cli-key-generate-asymmetric-pair-ec"></a>

Verwenden Sie den **key asymmetric-pair ec** Befehl in der CloudHSM-CLI, um ein asymmetrisches EC-Schlüsselpaar (Elliptic Curve) in Ihrem Cluster zu generieren. AWS CloudHSM 

## Benutzertyp
<a name="key-generate-asymmetric-pair-ec-user-type"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Krypto-Benutzer () CUs

## Voraussetzungen
<a name="key-generate-asymmetric-pair-ec-requirements"></a>

Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="key-generate-asymmetric-pair-ec-syntax"></a>

```
aws-cloudhsm > help key generate-asymmetric-pair ec
Generate an Elliptic-Curve Cryptography (ECC) key pair

Usage: key generate-asymmetric-pair ec [OPTIONS] --public-label <PUBLIC_LABEL> --private-label <PRIVATE_LABEL> --curve <CURVE>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --public-label <PUBLIC_LABEL>
          Label for the public key
      --private-label <PRIVATE_LABEL>
          Label for the private key
      --session
          Creates a session key pair that exists only in the current session. The key cannot be recovered after the session ends
      --curve <CURVE>
          Elliptic curve used to generate the key pair [possible values: prime256v1, secp256r1, secp224r1, secp384r1, secp256k1, secp521r1, ed25519]
      --public-attributes [<PUBLIC_KEY_ATTRIBUTES>...]
          Space separated list of key attributes to set for the generated EC public key in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE
      --private-attributes [<PRIVATE_KEY_ATTRIBUTES>...]
          Space separated list of key attributes to set for the generated EC private key in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE
      --share-crypto-users [<SHARE_CRYPTO_USERS>...]
          Space separated list of Crypto User usernames to share the EC private key with
      --manage-private-key-quorum-value <MANAGE_PRIVATE_KEY_QUORUM_VALUE>
          The quorum value for key management operations for the private key
      --use-private-key-quorum-value <USE_PRIVATE_KEY_QUORUM_VALUE>
          The quorum value for key usage operations for the private key
  -h, --help
          Print help
```

## Beispiele
<a name="key-generate-asymmetric-pair-ec-examples"></a>

Diese Beispiele zeigen, wie Sie mit diesem **key generate-asymmetric-pair ec**-Befehl ein EC-Schlüsselpaar erstellen.

**Example Beispiel: Ein EC-Schlüsselpaar erstellen**  

```
aws-cloudhsm > key generate-asymmetric-pair ec \
    --curve secp224r1 \
    --public-label ec-public-key-example \
    --private-label ec-private-key-example
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x000000000012000b",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "ec",
        "label": "ec-public-key-example",
        "id": "",
        "check-value": "0xd7c1a7",
        "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": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 57,
        "ec-point": "0x047096513df542250a6b228fd9cb67fd0c903abc93488467681974d6f371083fce1d79da8ad1e9ede745fb9f38ac8622a1b3ebe9270556000c",
        "curve": "secp224r1"
      }
    },
"private_key": {
      "key-reference": "0x000000000012000c",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "ec",
        "label": "ec-private-key-example",
        "id": "",
        "check-value": "0xd7c1a7",
        "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": false,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 122,
        "ec-point": "0x047096513df542250a6b228fd9cb67fd0c903abc93488467681974d6f371083fce1d79da8ad1e9ede745fb9f38ac8622a1b3ebe9270556000c",
        "curve": "secp224r1"
      }
    }
  }
}
```

**Example Beispiel: Erstellen Sie ein EC-Schlüsselpaar mit optionalen Attributen**  

```
aws-cloudhsm > key generate-asymmetric-pair ec \
    --curve secp224r1 \
    --public-label ec-public-key-example \
    --private-label ec-private-key-example \
    --public-attributes encrypt=true \
    --private-attributes decrypt=true
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x00000000002806eb",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "ec",
        "label": "ec-public-key-example",
        "id": "",
        "check-value": "0xedef86",
        "class": "public-key",
        "encrypt": true,
        "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": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 57,
        "ec-point": "0x0487af31882189ec29eddf17a48e8b9cebb075b7b5afc5522fe9c83a029a450cc68592889a1ebf45f32240da5140d58729ffd7b2d44262ddb8",
        "curve": "secp224r1"
      }
    },
    "private_key": {
      "key-reference": "0x0000000000280c82",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "ec",
        "label": "ec-private-key-example",
        "id": "",
        "check-value": "0xedef86",
        "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": false,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 122,
        "ec-point": "0x0487af31882189ec29eddf17a48e8b9cebb075b7b5afc5522fe9c83a029a450cc68592889a1ebf45f32240da5140d58729ffd7b2d44262ddb8",
        "curve": "secp224r1"
      }
    }
  }
}
```

**Example Beispiel: Erstellen Sie ein EC-Schlüsselpaar mit Quorumwerten**  
Bei der Generierung eines Schlüssels mit Quorumsteuerungen muss der Schlüssel einer Mindestanzahl von Benutzern zugeordnet werden, die dem größten Schlüsselquorumwert entspricht. Zu den assoziierten Benutzern gehören der Schlüsselinhaber und Crypto-Benutzer, mit denen der Schlüssel geteilt wird. Um die Mindestanzahl der Benutzer zu ermitteln, mit denen der Schlüssel geteilt werden soll, ermitteln Sie den größten Quorumwert zwischen dem Quorumwert für die Schlüsselnutzung und dem Quorumwert für die Schlüsselverwaltung und subtrahieren Sie 1, um den Schlüsselbesitzer zu berücksichtigen, der standardmäßig mit dem Schlüssel verknüpft ist. Verwenden Sie den Befehl, um den Schlüssel mit mehreren Benutzern zu teilen. **[Einen Schlüssel mit CloudHSM CLI teilen](cloudhsm_cli-key-share.md)**  

```
aws-cloudhsm > key generate-asymmetric-pair ec \
    --curve secp224r1 \
    --public-label ec-public-key-example \
    --private-label ec-private-key-example \
    --public-attributes verify=true \
    --private-attributes sign=true
    --share-crypto-users cu2 cu3 cu4 \
    --manage-private-key-quorum-value 4 \
    --use-private-key-quorum-value 2
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x00000000002806eb",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "ec",
        "label": "ec-public-key-example",
        "id": "",
        "check-value": "0xedef86",
        "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": 57,
        "ec-point": "0x0487af31882189ec29eddf17a48e8b9cebb075b7b5afc5522fe9c83a029a450cc68592889a1ebf45f32240da5140d58729ffd7b2d44262ddb8",
        "curve": "secp224r1"
      }
    },
    "private_key": {
      "key-reference": "0x0000000000280c82",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [
          {
            "username": "cu2",
            "key-coverage": "full"
          },
          {
            "username": "cu3",
            "key-coverage": "full"
          },
          {
            "username": "cu4",
            "key-coverage": "full"
          },
        ],
        "key-quorum-values": {
          "manage-key-quorum-value": 4,
          "use-key-quorum-value": 2
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "ec",
        "label": "ec-private-key-example",
        "id": "",
        "check-value": "0xedef86",
        "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": 122,
        "ec-point": "0x0487af31882189ec29eddf17a48e8b9cebb075b7b5afc5522fe9c83a029a450cc68592889a1ebf45f32240da5140d58729ffd7b2d44262ddb8",
        "curve": "secp224r1"
      }
    }
  }
}
```

## Argumente
<a name="key-generate-asymmetric-pair-ec-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<CURVE>***  
Gibt die ID für die elliptische Kurve an.  
+ prime256v1
+ secp256r1
+ secp224r1
+ secp384r1
+ secp256k1
+ secp521r1
+ ed25519 (wird nur auf hsm2m.medium-Instances im Nicht-FIPS-Modus unterstützt)
Erforderlich: Ja

***<PUBLIC\$1KEY\$1ATTRIBUTES>***  
Gibt eine durch Leerzeichen getrennte Liste von Schlüsselattributen an, die für den generierten öffentlichen EC-Schlüssel festgelegt werden sollen, in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (z. B. `verify=true`)  
Eine Liste der unterstützten Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Nein

***<PUBLIC\$1LABEL>***  
Gibt eine benutzerdefinierte Bezeichnung für den öffentlichen Schlüssel an. Die maximal zulässige Größe für Client SDK 5.11 und höher `label` beträgt 127 Zeichen. Das Client-SDK 5.10 und früher ist auf 126 Zeichen begrenzt.  
Erforderlich: Ja

***<PRIVATE\$1KEY\$1ATTRIBUTES>***  
Gibt eine durch Leerzeichen getrennte Liste von Schlüsselattributen an, die für den generierten privaten EC-Schlüssel festgelegt werden sollen, in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (z. B. `sign=true`)  
Eine Liste der unterstützten Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Nein

***<PRIVATE\$1LABEL>***  
Gibt eine benutzerdefinierte Bezeichnung für den private-key an. Die maximal zulässige Größe für Client-SDK 5.11 und höher `label` beträgt 127 Zeichen. Das Client-SDK 5.10 und früher ist auf 126 Zeichen begrenzt.  
Erforderlich: Ja

***<SESSION>***  
Erstellt einen Schlüssel, der nur in der aktuellen Sitzung existiert. Der Schlüssel kann nach Ende der Sitzung nicht wiederhergestellt werden.  
Verwenden Sie diesen Parameter, wenn Sie einen Schlüssel zum Packen nur für kurze Zeit benötigen, z. B. einen Schlüssel, der einen anderen Schlüssel verschlüsselt und dann schnell entschlüsselt. Verwenden Sie keinen Sitzungsschlüssel, um Daten zu verschlüsseln, die Sie nach dem Ende der Sitzung möglicherweise entschlüsseln müssen.  
Standardmäßig handelt es sich bei den generierten Schlüsseln um persistente (Token-)Schlüssel. Das Übergeben von <SESSION> ändert dies und stellt sicher, dass es sich bei einem mit diesem Argument generierten Schlüssel um einen (kurzlebigen) Sitzungsschlüssel handelt.  
Erforderlich: Nein

***<SHARE\$1CRYPTO\$1USERS>***  
Gibt eine durch Leerzeichen getrennte Liste von Crypto-Benutzernamen an, mit denen der private EC-Schlüssel gemeinsam genutzt werden soll  
Erforderlich: Nein

***<MANAGE\$1PRIVATE\$1KEY\$1QUORUM\$1VALUE>***  
Der Quorumwert für die Schlüsselverwaltungsvorgänge des privaten Schlüssels. Dieser Wert muss kleiner oder gleich der Anzahl der Benutzer sein, denen der Schlüssel zugeordnet ist. Dazu gehören Benutzer, mit denen der Schlüssel geteilt wird, und der Schlüsselbesitzer. Maximaler Wert von 8.  
Erforderlich: Nein

***<USE\$1PRIVATE\$1KEY\$1QUORUM\$1VALUE>***  
Der Quorumwert für die Schlüsselverwendungsvorgänge des privaten Schlüssels. Dieser Wert muss kleiner oder gleich der Anzahl der Benutzer sein, denen der Schlüssel zugeordnet ist. Dazu gehören Benutzer, mit denen der Schlüssel geteilt wird, und der Schlüsselbesitzer. Maximaler Wert von 8.  
Erforderlich: Nein

## Verwandte Themen
<a name="key-generate-asymmetric-pair-ec-seealso"></a>
+ [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)
+ [Schlüssel mithilfe der CloudHSM-CLI filtern](manage-keys-cloudhsm-cli-filtering.md)

# Generieren Sie ein asymmetrisches RSA-Schlüsselpaar mit CloudHSM CLI
<a name="cloudhsm_cli-key-generate-asymmetric-pair-rsa"></a>

Verwenden Sie den **key generate-asymmetric-pair rsa** Befehl in der CloudHSM-CLI, um ein asymmetrisches RSA-Schlüsselpaar in Ihrem Cluster zu generieren. AWS CloudHSM 

## Benutzertyp
<a name="key-generate-asymmetric-pair-rsa-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Krypto-Benutzer () CUs

## Voraussetzungen
<a name="key-generate-asymmetric-pair-rsa-requirements"></a>

Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="key-generate-asymmetric-pair-rsa-syntax"></a>

```
aws-cloudhsm > help key generate-asymmetric-pair rsa
Generate an RSA key pair

Usage: key generate-asymmetric-pair rsa [OPTIONS] --public-label <PUBLIC_LABEL> --private-label <PRIVATE_LABEL> --modulus-size-bits <MODULUS_SIZE_BITS> --public-exponent <PUBLIC_EXPONENT>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --public-label <PUBLIC_LABEL>
          Label for the public key
      --private-label <PRIVATE_LABEL>
          Label for the private key
      --session
          Creates a session key pair that exists only in the current session. The key cannot be recovered after the session ends
      --modulus-size-bits <MODULUS_SIZE_BITS>
          Modulus size in bits used to generate the RSA key pair
      --public-exponent <PUBLIC_EXPONENT>
          Public exponent used to generate the RSA key pair
      --public-attributes [<PUBLIC_KEY_ATTRIBUTES>...]
          Space separated list of key attributes to set for the generated RSA public key in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE
      --private-attributes [<PRIVATE_KEY_ATTRIBUTES>...]
          Space separated list of key attributes to set for the generated RSA private key in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE
      --share-crypto-users [<SHARE_CRYPTO_USERS>...]
          Space separated list of Crypto User usernames to share the RSA key with
      --manage-private-key-quorum-value <MANAGE_PRIVATE_KEY_QUORUM_VALUE>
          The quorum value for key management operations for the private key
      --use-private-key-quorum-value <USE_PRIVATE_KEY_QUORUM_VALUE>
          The quorum value for key usage operations for the private key
  -h, --help
          Print help
```

## Beispiele
<a name="key-generate-asymmetric-pair-rsa-examples"></a>

Diese Beispiele verdeutlichen, wie mit `key generate-asymmetric-pair rsa` ein RSA-Schlüsselpaar erstellt wird.

**Example Beispiel: Ein RSA-Schlüsselpaar erstellen**  

```
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
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x0000000000160010",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "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": "",
        "check-value": "0x498e1f",
        "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": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 512,
        "public-exponent": "0x010001",
        "modulus": "0xdfca0669dc8288ed3bad99509bd21c7e6192661407021b3f4cdf4a593d939dd24f4d641af8e4e73b04c847731c6dbdff3385818e08dd6efcbedd6e5b130344968c
e89a065e7d1a46ced96b46b909db2ab6be871ee700fd0a448b6e975bb64cae77c49008749212463e37a577baa57ce3e574cb057e9db131e119badf50c938f26e8a5975c61a8ba7ffe7a1115a
bcebb7d20bd6df1948ae336ae23b52d73b7f3b6acc2543edb6358e08d326d280ce489571f4d34e316a2ea1904d513ca12fa04075fc09ad005c81b7345d7804ff24c45117f0a1020dca7794df037a10aadec8653473b2088711f7b7d8b58431654e14e31af0e00511da641058fb7475ffdbe60f",
        "modulus-size-bits": 2048
      }
    },
"private_key": {
      "key-reference": "0x0000000000160011",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "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-private-key-example",
        "id": "",
        "check-value": "0x498e1f",
        "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": false,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 1217,
        "public-exponent": "0x010001",
        "modulus": "0xdfca0669dc8288ed3bad99509bd21c7e6192661407021b3f4cdf4a593d939dd24f4d641af8e4e73b04c847731c6dbdff3385818e08dd6efcbedd6e5b130344968ce89a065e7d1a46ced96b46b909db2ab6be871ee700fd0a448b6e975bb64cae77c49008749212463e37a577baa57ce3e574cb057e9db131e119badf50c938f26e8a5975c61a8ba7ffe7a1115abcebb7d20bd6df1948ae336ae23b52d73b7f3b6acc2543edb6358e08d326d280ce489571f4d34e316a2ea1904d513ca12fa04075fc09ad005c81b7345d7804ff24c45117f0a1020dca7794df037a10aadec8653473b2088711f7b7d8b58431654e14e31af0e00511da641058fb7475ffdbe60f",
        "modulus-size-bits": 2048
      }
    }
  }
}
```

**Example Beispiel: Erstellen eines RSA-Schlüsselpaars mit optionalen Attributen**  

```
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 encrypt=true \
--private-attributes decrypt=true
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x0000000000280cc8",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "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": "",
        "check-value": "0x01fe6e",
        "class": "public-key",
        "encrypt": true,
        "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": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 512,
        "public-exponent": "0x010001",
        "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c
73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634d
f6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc
133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0ac
ac3160f0ca9725d38318b7",
        "modulus-size-bits": 2048
      }
    },
    "private_key": {
      "key-reference": "0x0000000000280cc7",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "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-private-key-example",
        "id": "",
        "check-value": "0x01fe6e",
        "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": false,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 1217,
        "public-exponent": "0x010001",
        "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634df6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0acac3160f0ca9725d38318b7",
        "modulus-size-bits": 2048
      }
    }
  }
}
```

**Example Beispiel: Erstellen Sie ein RSA-Schlüsselpaar mit Quorumwerten**  
Beim Generieren eines Schlüssels mit Quorumsteuerelementen muss der Schlüssel einer Mindestanzahl von Benutzern zugeordnet werden, die dem größten Schlüsselquorumwert entspricht. Zu den assoziierten Benutzern gehören der Schlüsselinhaber und Crypto-Benutzer, mit denen der Schlüssel geteilt wird. Um die Mindestanzahl der Benutzer zu ermitteln, mit denen der Schlüssel geteilt werden soll, ermitteln Sie den größten Quorumwert zwischen dem Quorumwert für die Schlüsselnutzung und dem Quorumwert für die Schlüsselverwaltung und subtrahieren Sie 1, um den Schlüsselbesitzer zu berücksichtigen, der standardmäßig mit dem Schlüssel verknüpft ist. Verwenden Sie den Befehl, um den Schlüssel mit mehreren Benutzern zu teilen. **[Einen Schlüssel mit CloudHSM CLI teilen](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 cu2 cu3 cu4 \
--manage-private-key-quorum-value 4 \
--use-private-key-quorum-value 2
{
  "error_code": 0,
  "data": {
    "public_key": {
      "key-reference": "0x0000000000280cc8",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "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": "",
        "check-value": "0x01fe6e",
        "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": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 512,
        "public-exponent": "0x010001",
        "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c
73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634d
f6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc
133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0ac
ac3160f0ca9725d38318b7",
        "modulus-size-bits": 2048
      }
    },
    "private_key": {
      "key-reference": "0x0000000000280cc7",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [
          {
            "username": "cu2",
            "key-coverage": "full"
          },
          {
            "username": "cu3",
            "key-coverage": "full"
          },
          {
            "username": "cu4",
            "key-coverage": "full"
          },
        ],
        "key-quorum-values": {
          "manage-key-quorum-value": 4,
          "use-key-quorum-value": 2
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "rsa",
        "label": "rsa-private-key-example",
        "id": "",
        "check-value": "0x01fe6e",
        "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": 1217,
        "public-exponent": "0x010001",
        "modulus": "0xb1d27e857a876f4e9fd5de748a763c539b359f937eb4b4260e30d1435485a732c878cdad9c72538e2215351b1d41358c9bf80b599c73a80fdb457aa7b20cd61e486c326e2cfd5e124a7f6a996437437812b542e3caf85928aa866f0298580f7967ee6aa01440297d7308fdd9b76b70d1b67f12634df6e6296d6c116d5744c6d60d14d3bf3cb978fe6b75ac67b7089bafd50d8687213b31abc7dc1bad422780d29c851d5102b56f932551eaf52a9591fd8c43d81ecc133022653225bd129f8491101725e9ea33e1ded83fb57af35f847e532eb30cd7e726f23910d2671c6364092e834697ec3cef72cc23615a1ba7c5e100156ae0acac3160f0ca9725d38318b7",
        "modulus-size-bits": 2048
      }
    }
  }
}
```

## Argumente
<a name="key-generate-asymmetric-pair-rsa-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<MODULUS\$1SIZE\$1BITS>***  
 Gibt die Länge des Moduls in Bits an. Der minimale Wert beträgt 2048.   
Erforderlich: Ja

***<PRIVATE\$1KEY\$1ATTRIBUTES>***  
Gibt eine durch Leerzeichen getrennte Liste von Schlüsselattributen an, die für den generierten privaten RSA-Schlüssel festgelegt werden sollen, in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (z. B. `sign=true`)  
Eine Liste der unterstützten Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Nein

***<PRIVATE\$1LABEL>***  
 Gibt eine benutzerdefinierte Bezeichnung für den private-key an. Die maximal zulässige Größe für Client SDK 5.11 und höher `label` beträgt 127 Zeichen. Das Client-SDK 5.10 und früher ist auf 126 Zeichen begrenzt.  
Erforderlich: Ja

***<PUBLIC\$1EXPONENT>***  
Gibt den öffentlichen Exponenten an. Bei diesem Wert muss es sich eine ungerade Zahl gleich oder größer als 65537 handeln.  
Erforderlich: Ja

***<PUBLIC\$1KEY\$1ATTRIBUTES>***  
Gibt eine durch Leerzeichen getrennte Liste von Schlüsselattributen an, die für den generierten öffentlichen RSA-Schlüssel festgelegt werden sollen, in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (z. B. `verify=true`)  
Eine Liste der unterstützten Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Nein

***<PUBLIC\$1LABEL>***  
 Gibt eine benutzerdefinierte Bezeichnung für den öffentlichen Schlüssel an. Die maximal zulässige Größe für Client-SDK 5.11 und höher `label` beträgt 127 Zeichen. Das Client-SDK 5.10 und früher ist auf 126 Zeichen begrenzt.  
Erforderlich: Ja

***<SESSION>***  
Erstellt einen Schlüssel, der nur in der aktuellen Sitzung existiert. Der Schlüssel kann nach Ende der Sitzung nicht wiederhergestellt werden.  
Verwenden Sie diesen Parameter, wenn Sie einen Schlüssel zum Packen nur für kurze Zeit benötigen, z. B. einen Schlüssel, der einen anderen Schlüssel verschlüsselt und dann schnell entschlüsselt. Verwenden Sie keinen Sitzungsschlüssel, um Daten zu verschlüsseln, die Sie nach dem Ende der Sitzung möglicherweise entschlüsseln müssen.  
Standardmäßig handelt es sich bei den generierten Schlüsseln um persistente (Token-)Schlüssel. Das Übergeben von <SESSION> ändert dies und stellt sicher, dass es sich bei einem mit diesem Argument generierten Schlüssel um einen (kurzlebigen) Sitzungsschlüssel handelt.  
Erforderlich: Nein

***<SHARE\$1CRYPTO\$1USERS>***  
Gibt eine durch Leerzeichen getrennte Liste von Crypto-Benutzernamen an, mit denen der private RSA-Schlüssel gemeinsam genutzt werden soll  
Erforderlich: Nein

***<MANAGE\$1PRIVATE\$1KEY\$1QUORUM\$1VALUE>***  
Der Quorumwert für die Schlüsselverwaltungsvorgänge des privaten Schlüssels. Dieser Wert muss kleiner oder gleich der Anzahl der Benutzer sein, denen der Schlüssel zugeordnet ist. Dazu gehören Benutzer, mit denen der Schlüssel geteilt wird, und der Schlüsselbesitzer. Maximaler Wert von 8.  
Erforderlich: Nein

***<USE\$1PRIVATE\$1KEY\$1QUORUM\$1VALUE>***  
Der Quorumwert für die Schlüsselverwendungsvorgänge des privaten Schlüssels. Dieser Wert muss kleiner oder gleich der Anzahl der Benutzer sein, denen der Schlüssel zugeordnet ist. Dazu gehören Benutzer, mit denen der Schlüssel geteilt wird, und der Schlüsselbesitzer. Maximaler Wert von 8.  
Erforderlich: Nein

## Verwandte Themen
<a name="key-generate-asymmetric-pair-rsa-seealso"></a>
+ [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)
+ [Schlüssel mithilfe der CloudHSM-CLI filtern](manage-keys-cloudhsm-cli-filtering.md)

# Die Kategorie „Symmetrisch generieren“ in CloudHSM CLI
<a name="cloudhsm_cli-key-generate-symmetric"></a>

In der CloudHSM-CLI **key generate-symmetric** ist dies eine übergeordnete Kategorie für eine Gruppe von Befehlen, die in Kombination mit der übergeordneten Kategorie einen Befehl erstellen, der symmetrische Schlüssel generiert. Derzeit besteht diese Kategorie aus den folgenden Befehlen:
+ [key generate-symmetric aes](cloudhsm_cli-key-generate-symmetric-aes.md)
+ [key generate-symmetric generic-secret](cloudhsm_cli-key-generate-symmetric-generic-secret.md)

# Generieren Sie einen symmetrischen AES-Schlüssel mit CloudHSM CLI
<a name="cloudhsm_cli-key-generate-symmetric-aes"></a>

Verwenden Sie den **key generate-symmetric aes** Befehl in der CloudHSM-CLI, um einen symmetrischen AES-Schlüssel in Ihrem Cluster zu generieren. AWS CloudHSM 

## Benutzertyp
<a name="key-generate-symmetric-aes-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="key-generate-symmetric-aes-requirements"></a>

Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="key-generate-symmetric-aes-syntax"></a>

```
aws-cloudhsm > help key generate-symmetric aes
Generate an AES key

Usage: key generate-symmetric aes [OPTIONS] --label <LABEL> --key-length-bytes <KEY_LENGTH_BYTES>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --label <LABEL>
          Label for the key
      --session
          Creates a session key that exists only in the current session. The key cannot be recovered after the session ends
      --key-length-bytes <KEY_LENGTH_BYTES>
          Key length in bytes
      --attributes [<KEY_ATTRIBUTES>...]
          Space separated list of key attributes to set for the generated AES key in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE
      --share-crypto-users [<SHARE_CRYPTO_USERS>...]
          Space separated list of Crypto User usernames to share the AES key with
      --manage-key-quorum-value <MANAGE_KEY_QUORUM_VALUE>
          The quorum value for key management operations
      --use-key-quorum-value <USE_KEY_QUORUM_VALUE>
          The quorum value for key usage operations
  -h, --help
          Print help
```

## Beispiele
<a name="key-generate-symmetric-aes-examples"></a>

Diese Beispiele zeigen, wie Sie den **key generate-symmetric aes**-Befehl zum Erstellen eines AES-Schlüssels verwenden.

**Example Beispiel: Einen AES-Schlüssel erstellen**  

```
aws-cloudhsm > key generate-symmetric aes \
--label example-aes \
--key-length-bytes 24
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000002e06bf",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "example-aes",
        "id": "",
        "check-value": "0x9b94bd",
        "class": "secret-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": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 24
      }
    }
  }
}
```

**Example Beispiel: Erstellen eines AES-Schlüssels mit optionalen Attributen**  

```
aws-cloudhsm > key generate-symmetric aes \
--label example-aes \
--key-length-bytes 24 \
--attributes decrypt=true encrypt=true
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000002e06bf",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "example-aes",
        "id": "",
        "check-value": "0x9b94bd",
        "class": "secret-key",
        "encrypt": true,
        "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": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 24
      }
    }
  }
}
```

**Example Beispiel: Erstellen Sie einen AES-Schlüssel mit Quorumwerten**  
Beim Generieren eines Schlüssels mit Quorumsteuerungen muss der Schlüssel einer Mindestanzahl von Benutzern zugeordnet werden, die dem größten Schlüsselquorumwert entspricht. Zu den assoziierten Benutzern gehören der Schlüsselinhaber und Crypto-Benutzer, mit denen der Schlüssel geteilt wird. Um die Mindestanzahl der Benutzer zu ermitteln, mit denen der Schlüssel geteilt werden soll, ermitteln Sie den größten Quorumwert zwischen dem Quorumwert für die Schlüsselnutzung und dem Quorumwert für die Schlüsselverwaltung und subtrahieren Sie 1, um den Schlüsselbesitzer zu berücksichtigen, der standardmäßig mit dem Schlüssel verknüpft ist. Verwenden Sie den Befehl, um den Schlüssel mit mehreren Benutzern zu teilen. **[Einen Schlüssel mit CloudHSM CLI teilen](cloudhsm_cli-key-share.md)**  

```
aws-cloudhsm > key generate-symmetric aes \
--label example-aes \
--key-length-bytes 24 \
--attributes decrypt=true encrypt=true
--share-crypto-users cu2 cu3 cu4 \
--manage-key-quorum-value 4 \
--use-key-quorum-value 2
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000002e06bf",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [
          {
            "username": "cu2",
            "key-coverage": "full"
          },
          {
            "username": "cu3",
            "key-coverage": "full"
          },
          {
            "username": "cu4",
            "key-coverage": "full"
          },
        ],
        "key-quorum-values": {
          "manage-key-quorum-value": 4,
          "use-key-quorum-value": 2
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "example-aes",
        "id": "",
        "check-value": "0x9b94bd",
        "class": "secret-key",
        "encrypt": true,
        "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": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 24
      }
    }
  }
}
```

## Argumente
<a name="key-generate-symmetric-aes-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<KEY\$1ATTRIBUTES>***  
Gibt eine durch Leerzeichen getrennte Liste von Schlüsselattributen an, die für den generierten AES-Schlüssel festgelegt werden sollen, in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (z. B. `sign=true`).  
Eine Liste der unterstützten Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Nein

***<KEY-LENGTH-BYTES>***  
Gibt die Schlüssellänge in Byte an.  

Zulässige Werte:
+ 16, 24 und 32
Erforderlich: Ja

***<LABEL>***  
Gibt eine benutzerdefinierte Bezeichnung für den AES-Schlüssel an. Die maximal zulässige Größe für Client SDK 5.11 und höher `label` beträgt 127 Zeichen. Das Client-SDK 5.10 und früher ist auf 126 Zeichen begrenzt.  
Erforderlich: Ja

***<SESSION>***  
Erstellt einen Schlüssel, der nur in der aktuellen Sitzung existiert. Der Schlüssel kann nach Ende der Sitzung nicht wiederhergestellt werden.  
Verwenden Sie diesen Parameter, wenn Sie einen Schlüssel zum Packen nur für kurze Zeit benötigen, z. B. einen Schlüssel, der einen anderen Schlüssel verschlüsselt und dann schnell entschlüsselt. Verwenden Sie keinen Sitzungsschlüssel, um Daten zu verschlüsseln, die Sie nach dem Ende der Sitzung möglicherweise entschlüsseln müssen.  
Standardmäßig handelt es sich bei den generierten Schlüsseln um persistente (Token-)Schlüssel. Das Übergeben von <SESSION> ändert dies und stellt sicher, dass es sich bei einem mit diesem Argument generierten Schlüssel um einen (kurzlebigen) Sitzungsschlüssel handelt.  
Erforderlich: Nein

***<SHARE\$1CRYPTO\$1USERS>***  
Gibt eine durch Leerzeichen getrennte Liste von Crypto-Benutzernamen an, mit denen der AES-Schlüssel gemeinsam genutzt werden soll  
Erforderlich: Nein

***<MANAGE\$1KEY\$1QUORUM\$1VALUE>***  
Der Quorumwert für Schlüsselverwaltungsvorgänge. Dieser Wert muss kleiner oder gleich der Anzahl der Benutzer sein, denen der Schlüssel zugeordnet ist. Dazu gehören Benutzer, mit denen der Schlüssel geteilt wird, und der Schlüsselbesitzer. Maximaler Wert von 8.  
Erforderlich: Nein

***<USE\$1KEY\$1QUORUM\$1VALUE>***  
Der Quorumwert für Operationen zur Verwendung von Schlüsseln. Dieser Wert muss kleiner oder gleich der Anzahl der Benutzer sein, denen der Schlüssel zugeordnet ist. Dazu gehören Benutzer, mit denen der Schlüssel geteilt wird, und der Schlüsselbesitzer. Maximaler Wert von 8.  
Erforderlich: Nein

## Verwandte Themen
<a name="key-generate-symmetric-aes-seealso"></a>
+ [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)
+ [Schlüssel mithilfe der CloudHSM-CLI filtern](manage-keys-cloudhsm-cli-filtering.md)

# Generieren Sie einen symmetrischen Generic Secret Key mit CloudHSM CLI
<a name="cloudhsm_cli-key-generate-symmetric-generic-secret"></a>

Verwenden Sie den **key generate-symmetric generic-secret** Befehl in der CloudHSM-CLI, um einen symmetrischen Generic Secret-Schlüssel in Ihrem Cluster zu generieren. AWS CloudHSM 

## Benutzertyp
<a name="key-generate-symmetric-generic-secret-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="key-generate-symmetric-generic-secret-requirements"></a>

Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="key-generate-symmetric-generic-secret-syntax"></a>

```
aws-cloudhsm > key help generate-symmetric generic-secret
Generate a generic secret key

Usage: key generate-symmetric generic-secret [OPTIONS] --label <LABEL> --key-length-bytes <KEY_LENGTH_BYTES>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --label <LABEL>
          Label for the key
      --session
          Creates a session key that exists only in the current session. The key cannot be recovered after the session ends
      --key-length-bytes <KEY_LENGTH_BYTES>
          Key length in bytes
      --attributes [<KEY_ATTRIBUTES>...]
          Space separated list of key attributes to set for the generated generic secret key in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE
      --share-crypto-users [<SHARE_CRYPTO_USERS>...]
          Space separated list of Crypto User usernames to share the generic secret key with
      --manage-key-quorum-value <MANAGE_KEY_QUORUM_VALUE>
          The quorum value for key management operations
      --use-key-quorum-value <USE_KEY_QUORUM_VALUE>
          The quorum value for key usage operations
  -h, --help
          Print help
```

## Beispiele
<a name="key-generate-symmetric-generic-secret-examples"></a>

Diese Beispiele zeigen, wie Sie den **key generate-symmetric generic-secret**-Befehl verwenden, um einen generischen geheimen Schlüssel zu erstellen.

**Example Beispiel: Erstellen Sie einen generischen geheimen Schlüssel**  

```
aws-cloudhsm > key generate-symmetric generic-secret \
--label example-generic-secret \
--key-length-bytes 256
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000002e08fd",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "generic-secret",
        "label": "example-generic-secret",
        "id": "",
        "class": "secret-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": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 256
      }
    }
  }
}
```

**Example Beispiel: Erstellen Sie einen generischen geheimen Schlüssel mit optionalen Attributen**  

```
aws-cloudhsm > key generate-symmetric generic-secret \
--label example-generic-secret \
--key-length-bytes 256 \
--attributes encrypt=true
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000002e08fd",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "generic-secret",
        "label": "example-generic-secret",
        "id": "",
        "class": "secret-key",
        "encrypt": true,
        "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": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 256
      }
    }
  }
}
```

**Example Beispiel: Erstellen Sie einen generischen geheimen Schlüssel mit Quorumwerten**  
Beim Generieren eines Schlüssels mit Quorumsteuerelementen muss der Schlüssel einer Mindestanzahl von Benutzern zugeordnet werden, die dem größten Schlüsselquorumwert entspricht. Zu den assoziierten Benutzern gehören der Schlüsselinhaber und Crypto-Benutzer, mit denen der Schlüssel geteilt wird. Um die Mindestanzahl der Benutzer zu ermitteln, mit denen der Schlüssel geteilt werden soll, ermitteln Sie den größten Quorumwert zwischen dem Quorumwert für die Schlüsselnutzung und dem Quorumwert für die Schlüsselverwaltung und subtrahieren Sie 1, um den Schlüsselbesitzer zu berücksichtigen, der standardmäßig mit dem Schlüssel verknüpft ist. Verwenden Sie den Befehl, um den Schlüssel mit mehreren Benutzern zu teilen. **[Einen Schlüssel mit CloudHSM CLI teilen](cloudhsm_cli-key-share.md)**  

```
aws-cloudhsm > key generate-symmetric generic-secret \
--label example-generic-secret \
--key-length-bytes 256 \
--attributes encrypt=true
--share-crypto-users cu2 cu3 cu4 \
--manage-key-quorum-value 4 \
--use-key-quorum-value 2
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000002e08fd",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [
          {
            "username": "cu2",
            "key-coverage": "full"
          },
          {
            "username": "cu3",
            "key-coverage": "full"
          },
          {
            "username": "cu4",
            "key-coverage": "full"
          },
        ],
        "key-quorum-values": {
          "manage-key-quorum-value": 4,
          "use-key-quorum-value": 2
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "generic-secret",
        "label": "example-generic-secret",
        "id": "",
        "class": "secret-key",
        "encrypt": true,
        "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": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 256
      }
    }
  }
}
```

## Argumente
<a name="key-generate-symmetric-generic-secret-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<KEY\$1ATTRIBUTES>***  
Gibt eine durch Leerzeichen getrennte Liste von Schlüsselattributen an, die für den generierten AES-Schlüssel festgelegt werden sollen, in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (z. B. `sign=true`).  
Eine Liste der unterstützten Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Nein

***<KEY-LENGTH-BYTES>***  
Gibt die Schlüssellänge in Byte an.  

Zulässige Werte:
+ 1 bis 800
Erforderlich: Ja

***<LABEL>***  
Gibt eine benutzerdefinierte Bezeichnung für den generischen geheimen Schlüssel an. Die maximal zulässige Größe für Client SDK 5.11 und höher `label` beträgt 127 Zeichen. Das Client-SDK 5.10 und früher ist auf 126 Zeichen begrenzt.  
Erforderlich: Ja

***<SESSION>***  
Erstellt einen Schlüssel, der nur in der aktuellen Sitzung existiert. Der Schlüssel kann nach Ende der Sitzung nicht wiederhergestellt werden.  
Verwenden Sie diesen Parameter, wenn Sie einen Schlüssel zum Packen nur für kurze Zeit benötigen, z. B. einen Schlüssel, der einen anderen Schlüssel verschlüsselt und dann schnell entschlüsselt. Verwenden Sie keinen Sitzungsschlüssel, um Daten zu verschlüsseln, die Sie nach dem Ende der Sitzung möglicherweise entschlüsseln müssen.  
Standardmäßig handelt es sich bei den generierten Schlüsseln um persistente (Token-)Schlüssel. Das Übergeben von <SESSION> ändert dies und stellt sicher, dass es sich bei einem mit diesem Argument generierten Schlüssel um einen (kurzlebigen) Sitzungsschlüssel handelt.  
Erforderlich: Nein

***<SHARE\$1CRYPTO\$1USERS>***  
Durch Leerzeichen getrennte Liste von Crypto-Benutzernamen, mit denen der generische geheime Schlüssel geteilt werden soll  
Erforderlich: Nein

***<MANAGE\$1KEY\$1QUORUM\$1VALUE>***  
Der Quorumwert für Schlüsselverwaltungsvorgänge. Dieser Wert muss kleiner oder gleich der Anzahl der Benutzer sein, denen der Schlüssel zugeordnet ist. Dazu gehören Benutzer, mit denen der Schlüssel geteilt wird, und der Schlüsselbesitzer. Maximaler Wert von 8.  
Erforderlich: Nein

***<USE\$1KEY\$1QUORUM\$1VALUE>***  
Der Quorumwert für Operationen zur Verwendung von Schlüsseln. Dieser Wert muss kleiner oder gleich der Anzahl der Benutzer sein, denen der Schlüssel zugeordnet ist. Dazu gehören Benutzer, mit denen der Schlüssel geteilt wird, und der Schlüsselbesitzer. Maximaler Wert von 8.  
Erforderlich: Nein

## Verwandte Themen
<a name="key-generate-symmetric-generic-secret-seealso"></a>
+ [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)
+ [Schlüssel mithilfe der CloudHSM-CLI filtern](manage-keys-cloudhsm-cli-filtering.md)

# Importieren Sie einen Schlüssel im PEM-Format mit der CloudHSM-CLI
<a name="cloudhsm_cli-key-import-pem"></a>

Verwenden Sie den **key import pem** Befehl in AWS CloudHSM , um einen Schlüssel im PEM-Format in ein Hardware-Sicherheitsmodul (HSM) zu importieren. Sie können ihn verwenden, um öffentliche und außerhalb des HSM erstellte Schlüssel zu importieren.

**Anmerkung**  
Verwenden Sie den [Exportieren Sie einen asymmetrischen Schlüssel mit CloudHSM CLI](cloudhsm_cli-key-generate-file.md) Befehl, um eine Standard-PEM-Datei aus einem öffentlichen Schlüssel oder eine Referenz-PEM-Datei aus einem privaten Schlüssel zu erstellen.

## Benutzertyp
<a name="cloudhsm_cli-key-import-pem-user-type"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-key-import-pem-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-import-pem-syntax"></a>

```
aws-cloudhsm > help key import pem
Import key from a PEM file

Usage: key import pem [OPTIONS] --path <PATH> --label <LABEL> --key-type-class <KEY_TYPE_CLASS>
Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --path <PATH>
          Path where the key is located in PEM format
      --label <LABEL>
          Label for the imported key
      --key-type-class <KEY_TYPE_CLASS>
          Key type and class of the imported key [possible values: ec-public, rsa-public]
      --attributes [<IMPORT_KEY_ATTRIBUTES>...]
          Space separated list of key attributes in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE for the imported key
  -h, --help
          Print help
```

## Beispiele
<a name="cloudhsm_cli-key-import-pem-examples"></a>

Dieses Beispiel zeigt, wie der **key import pem** Befehl verwendet wird, um einen öffentlichen RSA-Schlüssel aus einer Datei im PEM-Format zu importieren.

**Example Beispiel: Importieren Sie einen öffentlichen RSA-Schlüssel**  

```
aws-cloudhsm > key import pem --path /home/example --label example-imported-key --key-type-class rsa-public
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001e08e3",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",                                   
            "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": "example-imported-key",
        "id": "0x",
        "check-value": "0x99fe93",
        "class": "public-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": false,
        "sign": false,
        "trusted": false,
        "unwrap": false,
        "verify": false,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 512,
        "public-exponent": "0x010001",
        "modulus": "0x8e9c172c37aa22ed1ce25f7c3a7c936dadc532201400128b044ebb4b96│··3e4930ab910df5a2896eaeb8853cfea0e341227654a8337a7864cc8a87d136f006cfba9e68d0b329│··746c1ad60941668b18699fc8169ff1ec363d0d18292845b2454d6a0b8c5d111b79c047619d460cdf│··be59debbacb66b7abeaf3f3d35dd2b9cfa6b6b7b1258b6866cb4085ac749e9d8552b3a4509e1b86c│··828cc794e22767b4f6b5bc6ff5c96f4b7e60eab305d669cfa2197e85379cb35c659bb58fcd246d48│··d9f6a7f36063b42da025459275aa8e3abedad775387086bd6c198ded868403f4b87ffda5a2d455ac│··aa6cbd00003c31d8d2f51d10cd272b31cf0c4037791f48ad51fb35",
        "modulus-size-bits": 2048
      }
    },
    "message": "Successfully imported key"
  }
}
```

**Example Beispiel: Importieren Sie einen öffentlichen RSA-Schlüssel mit optionalen Attributen**  

```
aws-cloudhsm > key import pem --path /home/example --label example-imported-key-with-attributes --key-type-class rsa-public --attributes verify=true
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001e08e3",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",                                      
            "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": "example-imported-key-with-attributes",
        "id": "0x",
        "check-value": "0x99fe93",
        "class": "public-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "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": "0x8e9c172c37aa22ed1ce25f7c3a7c936dadc532201400128b044ebb4b96│··3e4930ab910df5a2896eaeb8853cfea0e341227654a8337a7864cc8a87d136f006cfba9e68d0b329│··746c1ad60941668b18699fc8169ff1ec363d0d18292845b2454d6a0b8c5d111b79c047619d460cdf│··be59debbacb66b7abeaf3f3d35dd2b9cfa6b6b7b1258b6866cb4085ac749e9d8552b3a4509e1b86c│··828cc794e22767b4f6b5bc6ff5c96f4b7e60eab305d669cfa2197e85379cb35c659bb58fcd246d48│··d9f6a7f36063b42da025459275aa8e3abedad775387086bd6c198ded868403f4b87ffda5a2d455ac│··aa6cbd00003c31d8d2f51d10cd272b31cf0c4037791f48ad51fb35",
        "modulus-size-bits": 2048
      }
    },
    "message": "Successfully imported key"
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-import-pem-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<PATH>***  
Gibt den Dateipfad an, in dem sich die Schlüsseldatei befindet.  
Erforderlich: Ja

***<LABEL>***  
Gibt eine benutzerdefinierte Bezeichnung für den importierten Schlüssel an. Die maximal zulässige Größe für `label` beträgt 126 Zeichen.  
Erforderlich: Ja

***<KEY\$1TYPE\$1CLASS>***  
Schlüsseltyp und Klasse des umschlossenen Schlüssels.  
Mögliche Werte:  
+ ec-public
+ rsa-öffentlich
Erforderlich: Ja

***<IMPORT\$1KEY\$1ATTRIBUTES>***  
Gibt eine durch Leerzeichen getrennte Liste von Schlüsselattributen an, die für den importierten Schlüssel festgelegt werden sollen, in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (z. B.`sign=true`). Eine Liste der unterstützten Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Nein

## Verwandte Themen
<a name="cloudhsm_cli-key-import-pem-seealso"></a>
+ [Die Kategorie Kryptozeichen in CloudHSM CLI](cloudhsm_cli-crypto-sign.md)
+ [Die Kategorie Crypto Verify in CloudHSM CLI](cloudhsm_cli-crypto-verify.md)

# Schlüssel für einen Benutzer mit CloudHSM CLI auflisten
<a name="cloudhsm_cli-key-list"></a>

Verwenden Sie den **key list** Befehl in der CloudHSM-CLI, um alle Schlüssel für den aktuellen Benutzer in Ihrem AWS CloudHSM Cluster zu finden. Die Ausgabe umfasst Schlüssel, die der Benutzer besitzt und die für ihn freigegeben sind, sowie alle öffentlichen Schlüssel im CloudHSM-Cluster.

## Benutzertyp
<a name="chsm-cli-key-list-user-type"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Administratoren () COs
+ Krypto-Benutzer () CUs

## Syntax
<a name="chsm-cli-key-list-syntax"></a>

```
aws-cloudhsm > help key list
List the keys the current user owns, shares, and all public keys in the HSM cluster

Usage: key list [OPTIONS]

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select matching key(s) to list
      --max-items <MAX_ITEMS>
          The total number of items to return in the command's output. If the total number of items available is more than the value specified, a next-token is provided in the command's output. To resume pagination, provide the next-token value in the starting-token argument of a subsequent command [default: 10]
      --starting-token <STARTING_TOKEN>
          A token to specify where to start paginating. This is the next-token from a previously truncated response
  -v, --verbose
          If included, prints all attributes and key information for each matched key. By default each matched key only displays its key-reference and label attribute. This flag when used by Admins has no effect
  -h, --help
          Print help
```

## Beispiele
<a name="chsm-cli-key-list-examples"></a>

Die folgenden Beispiele zeigen die verschiedenen Möglichkeiten, wie Sie den **key list**-Befehl ausführen. Die folgenden Beispiele zeigen die Ausgaben eines Krypto-Benutzers.

**Example Beispiel: Finde alle Schlüssel — Standard**  
Dieser Befehl listet die Schlüssel des angemeldeten Benutzers auf, der sich im AWS CloudHSM Cluster befindet.  
Standardmäßig werden nur 10 Schlüssel des aktuell angemeldeten Benutzers angezeigt, und nur die Schlüssel `key-reference` und `label` werden als Ausgabe angezeigt. Verwenden Sie die entsprechenden Paginierungsoptionen, um mehr oder weniger Schlüssel als Ausgabe anzuzeigen.

```
aws-cloudhsm > key list
{
  "error_code": 0,
  "data": {
    "matched_keys": [
      {
        "key-reference": "0x00000000000003d5",
        "attributes": {
          "label": "test_label_1"
        }
      },
      {
        "key-reference": "0x0000000000000626",
        "attributes": {
          "label": "test_label_2"
        }
      },.
      ...8 keys later...
    ],
    "total_key_count": 56,
    "returned_key_count": 10,
    "next_token": "10"
  }
}
```

**Example Beispiel: Finde alle Schlüssel — ausführlich**  
Die Ausgabe enthält Schlüssel, die der Benutzer besitzt und mit anderen teilt, sowie alle öffentlichen Schlüssel in der HSMs.  
Hinweis: Standardmäßig werden nur 10 Schlüssel des aktuell angemeldeten Benutzers angezeigt. Verwenden Sie die entsprechenden Paginierungsoptionen, um mehr oder weniger Schlüssel als Ausgabe anzuzeigen.

```
aws-cloudhsm > key list --verbose
{
  "error_code": 0,
  "data": {
    "matched_keys": [
      {
        "key-reference": "0x000000000012000c",
        "key-info": {
          "key-owners": [
            {
              "username": "cu1",
              "key-coverage": "full"
            }
          ],
          "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
          "cluster-coverage": "full"
        },
        "attributes": {
          "key-type": "ec",
          "label": "ec-test-private-key",
          "id": "",
          "check-value": "0x2a737d",
          "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": false,
          "trusted": false,
          "unwrap": false,
          "verify": false,
          "wrap": false,
          "wrap-with-trusted": false,
          "key-length-bytes": 122,
          "ec-point": "0x0442d53274a6c0ec1a23c165dcb9ccdd72c64e98ae1a9594bb5284e752c746280667e11f1e983493c1c605e0a8071ede47ca280f94c6b2aa33",
          "curve": "secp224r1"
        }
      },
      {
        "key-reference": "0x000000000012000d",
        "key-info": {
          "key-owners": [
            {
              "username": "cu1",
              "key-coverage": "full"
            }
          ],
          "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
          "cluster-coverage": "full"
        },
        "attributes": {
          "key-type": "ec",
          "label": "ec-test-public-key",
          "id": "",
          "check-value": "0x2a737d",
          "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": false,
          "wrap": false,
          "wrap-with-trusted": false,
          "key-length-bytes": 57,
          "ec-point": "0x0442d53274a6c0ec1a23c165dcb9ccdd72c64e98ae1a9594bb5284e752c746280667e11f1e983493c1c605e0a8071ede47ca280f94c6b2aa33",
          "curve": "secp224r1"
        }
      }
    ],
      ...8 keys later...
    "total_key_count": 1580,
    "returned_key_count": 10
  }
}
```

**Example Beispiel: Paginated return**  
Das folgende Beispiel zeigt eine paginierte Teilmenge der Schlüssel, die nur zwei Schlüssel enthält. Das Beispiel bietet dann einen nachfolgenden Aufruf, um die nächsten beiden Schlüssel anzuzeigen.  

```
aws-cloudhsm > key list --verbose --max-items 2
{
  "error_code": 0,
  "data": {
    "matched_keys": [
      {
        "key-reference": "0x0000000000000030",
        "key-info": {
          "key-owners": [
            {
              "username": "cu1",
              "key-coverage": "full"
            }
          ],
          "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
          "cluster-coverage": "full"
        },
        "attributes": {
          "key-type": "aes",
          "label": "98a6688d1d964ed7b45b9cec5c4b1909",
          "id": "",
          "check-value": "0xb28a46",
          "class": "secret-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": true,
          "wrap": false,
          "wrap-with-trusted": false,
          "key-length-bytes": 32
        }
      },
      {
        "key-reference": "0x0000000000000042",
        "key-info": {
          "key-owners": [
            {
              "username": "cu1",
              "key-coverage": "full"
            }
          ],
          "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
          "cluster-coverage": "full"
        },
        "attributes": {
          "key-type": "aes",
          "label": "4ad6cdcbc02044e09fa954143efde233",
          "id": "",
          "check-value": "0xc98104",
          "class": "secret-key",
          "encrypt": true,
          "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": true,
          "wrap": true,
          "wrap-with-trusted": false,
          "key-length-bytes": 16
        }
      }
    ],
    "total_key_count": 1580,
    "returned_key_count": 2,
    "next_token": "2"
  }
}
```
Um die nächsten 2 Schlüssel anzuzeigen, kann ein nachfolgender Aufruf getätigt werden:  

```
aws-cloudhsm > key list --verbose --max-items 2 --starting-token 2
{
  "error_code": 0,
  "data": {
    "matched_keys": [
      {
        "key-reference": "0x0000000000000081",
        "key-info": {
          "key-owners": [
            {
              "username": "cu1",
              "key-coverage": "full"
            }
          ],
          "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
          "cluster-coverage": "full"
        },
        "attributes": {
          "key-type": "aes",
          "label": "6793b8439d044046982e5b895791e47f",
          "id": "",
          "check-value": "0x3f986f",
          "class": "secret-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": true,
          "wrap": false,
          "wrap-with-trusted": false,
          "key-length-bytes": 32
        }
      },
      {
        "key-reference": "0x0000000000000089",
        "key-info": {
          "key-owners": [
            {
              "username": "cu1",
              "key-coverage": "full"
            }
          ],
          "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
          "cluster-coverage": "full"
        },
        "attributes": {
          "key-type": "aes",
          "label": "56b30fa05c6741faab8f606d3b7fe105",
          "id": "",
          "check-value": "0xe9201a",
          "class": "secret-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": true,
          "wrap": false,
          "wrap-with-trusted": false,
          "key-length-bytes": 32
        }
      }
    ],
    "total_key_count": 1580,
    "returned_key_count": 2,
    "next_token": "4"
  }
}
```
Weitere Beispiele, die zeigen, wie der wichtige Filtrationsmechanismus in der CloudHSM-CLI funktioniert, finden Sie unter [Schlüssel mithilfe der CloudHSM-CLI filtern](manage-keys-cloudhsm-cli-filtering.md).

## Argumente
<a name="key-list-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass übereinstimmende Schlüssel für die Liste ausgewählt werden sollen.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Nein

***<MAX\$1ITEMS>***  
Die Gesamtzahl der Elemente, die in der Ausgabe des Befehls zurückgegeben werden sollen. Ist die Gesamtzahl der verfügbaren Elemente größer als der angegebene Wert, wird ein next-token in der Ausgabe des Befehls bereitgestellt. Um die Seitennummerierung fortzusetzen, geben Sie den next-token-Wert im starting-token-Argument eines nachfolgenden Befehls an.  
Erforderlich: Nein

***<STARTING\$1TOKEN>***  
Ein Token für den Beginn der Seitennummerierung. Dies ist das next-token aus einer zuvor abgeschnittenen Antwort.  
Erforderlich: Nein

***<VERBOSE>***  
Falls enthalten, werden alle Attribute und Schlüsselinformationen für jeden übereinstimmenden Schlüssel gedruckt. Standardmäßig zeigt jeder übereinstimmende Schlüssel nur seine Schlüsselreferenz und sein Labelattribut an. Wenn diese Markierung von Admins verwendet wird, hat sie keine Wirkung.  
Erforderlich: Nein

## Verwandte Themen
<a name="chsm-key-list-seealso"></a>
+ [Löschen Sie einen Schlüssel mit CloudHSM CLI](cloudhsm_cli-key-delete.md)
+ [Exportieren Sie einen asymmetrischen Schlüssel mit CloudHSM CLI](cloudhsm_cli-key-generate-file.md)
+ [Freigabe eines Schlüssels mithilfe der CloudHSM-CLI rückgängig machen](cloudhsm_cli-key-unshare.md)
+ [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)
+ [Schlüssel mithilfe der CloudHSM-CLI filtern](manage-keys-cloudhsm-cli-filtering.md)

# Einen Schlüssel mit CloudHSM CLI replizieren
<a name="cloudhsm_cli-key-replicate"></a>

Verwenden Sie den **key replicate** Befehl in der CloudHSM-CLI, um einen Schlüssel von einem AWS CloudHSM Quellcluster auf einen Zielcluster zu replizieren. AWS CloudHSM 

## Benutzertyp
<a name="chsm-cli-key-replicate-user-type"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Administratoren () COs
+ Krypto-Benutzer () CUs
**Anmerkung**  
Crypto-Benutzer müssen den Schlüssel besitzen, um diesen Befehl verwenden zu können.

## Voraussetzungen
<a name="cloudhsm_cli-key-replicate-requirements"></a>
+ Die Quell- und Zielcluster müssen Klone sein. Das bedeutet, dass einer aus einem Backup des anderen erstellt wurde oder dass beide aus einem gemeinsamen Backup erstellt wurden. Weitere Informationen finden Sie unter [Cluster aus Sicherungen erstellen](create-cluster-from-backup.md).
+ Der Besitzer des Schlüssels muss auf dem Zielcluster vorhanden sein. Wenn der Schlüssel mit anderen Benutzern geteilt wird, müssen diese Benutzer außerdem auch auf dem Zielcluster vorhanden sein.
+ Um diesen Befehl ausführen zu können, müssen Sie sowohl im Quell- als auch im Zielcluster als Crypto-Benutzer oder Administrator angemeldet sein.
  +  Im Einzelbefehlsmodus verwendet der Befehl die Umgebungsvariablen CLOUDHSM\$1PIN und CLOUDHSM\$1ROLE, um sich im Quellcluster zu authentifizieren. Weitere Informationen finden Sie unter [Einzelbefehlsmodus](cloudhsm_cli-modes.md#cloudhsm_cli-mode-single-command). Um Anmeldeinformationen für den Zielcluster bereitzustellen, müssen Sie zwei zusätzliche Umgebungsvariablen festlegen: DESTINATION\$1CLOUDHSM\$1PIN und DESTINATION\$1CLOUDHSM\$1ROLE:

    ```
    $ export DESTINATION_CLOUDHSM_ROLE=<role>
    ```

    ```
    $ export DESTINATION_CLOUDHSM_PIN=<username:password>
    ```
  +  Im interaktiven Modus müssen sich Benutzer explizit sowohl beim Quell- als auch beim Zielcluster anmelden.

## Syntax
<a name="chsm-cli-key-replicate-syntax"></a>

```
aws-cloudhsm > help key replicate
Replicate a key from a source to a destination cluster

Usage: key replicate --filter [<FILTER>...] --source-cluster-id <SOURCE_CLUSTER_ID> --destination-cluster-id <DESTINATION_CLUSTER_ID>

Options:
      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select matching key on the source cluster
      --source-cluster-id <SOURCE_CLUSTER_ID>
          Source cluster ID
      --destination-cluster-id <DESTINATION_CLUSTER_ID>
          Destination cluster ID
  -h, --help
          Print help
```

## Beispiele
<a name="chsm-cli-key-replicate-examples"></a>

**Example Beispiel: Schlüssel replizieren**  
Dieser Befehl repliziert einen Schlüssel von einem Quellcluster auf einen geklonten Zielcluster. Das folgende Beispiel zeigt die Ausgabe, wenn Sie als Crypto-Benutzer auf beiden Clustern angemeldet sind.  

```
crypto-user-1@cluster-1234abcdefg > key replicate \
      --filter attr.label=example-key \
      --source-cluster-id cluster-1234abcdefg \
      --destination-cluster-id cluster-2345bcdefgh
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x0000000000300006",
      "key-info": {
        "key-owners": [
          {
            "username": "crypto-user-1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "example-key",
        "id": "0x",
        "check-value": "0x5e118e",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": true,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": true,
        "modifiable": true,
        "never-extractable": true,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    },
    "message": "Successfully replicated key"
  }
}
```

## Argumente
<a name="key-replicate-arguments"></a>

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` zur Auswahl eines passenden Schlüssels auf dem Quellcluster.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Ja

***<SOURCE\$1CLUSTER\$1ID>***  
Die Quellcluster-ID.  
Erforderlich: Ja

***<DESTINATION\$1CLUSTER\$1ID>***  
Die Zielcluster-ID.  
Erforderlich: Ja

## Verwandte Themen
<a name="chsm-key-replicate-seealso"></a>
+ [Verbindung zu mehreren Clustern mit CloudHSM CLI herstellen](cloudhsm_cli-configs-multi-cluster.md)

# Legen Sie die Attribute von Schlüsseln mit der CloudHSM-CLI fest
<a name="cloudhsm_cli-key-set-attribute"></a>

Verwenden Sie den **key set-attribute** Befehl in der CloudHSM-CLI, um die Attribute der Schlüssel in Ihrem AWS CloudHSM Cluster festzulegen. Nur der CU, der den Schlüssel erstellt hat und folglich Eigentümer des Schlüssels ist, kann die Attribute des Schlüssels ändern.

Eine Liste der wichtigsten Attribute, die in der CloudHSM-CLI verwendet werden können, finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).

## Benutzertyp
<a name="chsm-cli-key-set-attribute-user-type"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer (CUs) können diesen Befehl ausführen.
+ Administratoren können das vertrauenswürdige Attribut festlegen.

## Voraussetzungen
<a name="chsm-cli-key-set-attribute-requirements"></a>

Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein. Um das vertrauenswürdige Attribut festzulegen, müssen Sie als Admin-Benutzer angemeldet sein.

## Syntax
<a name="chsm-cli-key-set-attribute-syntax"></a>

```
aws-cloudhsm > help key set-attribute
Set an attribute for a key in the HSM cluster

Usage: cloudhsm-cli key set-attribute [OPTIONS] --filter [<FILTER>...] --name <KEY_ATTRIBUTE> --value <KEY_ATTRIBUTE_VALUE>

Options:
      --cluster-id <CLUSTER_ID>         Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --filter [<FILTER>...]            Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key to modify
      --name <KEY_ATTRIBUTE>            Name of attribute to be set
      --value <KEY_ATTRIBUTE_VALUE>...  Attribute value to be set
      --approval <APPROVAL>            Filepath of signed quorum token file to approve operation
  -h, --help                            Print help
```

## Beispiel: Einstellung eines identifizierenden Attributs
<a name="chsm-cli-key-set-attribute-examples"></a>

Das folgende Beispiel demonstriert, wie Sie mit dem **key set-attribute**-Befehl das Label setzen.

**Example**  

1. Verwenden Sie den Schlüssel mit dem Label `my_key`, wie hier gezeigt:

   ```
   aws-cloudhsm > key set-attribute --filter attr.label=my_key --name encrypt --value false
   {
     "error_code": 0,
     "data": {
       "message": "Attribute set successfully"
     }
   }
   ```

1. Bestätigen Sie mit dem **key list**-Befehl, dass sich das `encrypt`-Attribut geändert hat:

   ```
   aws-cloudhsm > key list --filter attr.label=my_key --verbose
   {
     "error_code": 0,
     "data": {
       "matched_keys": [
         {
           "key-reference": "0x00000000006400ec",
           "key-info": {
             "key-owners": [
               {
                 "username": "bob",
                 "key-coverage": "full"
               }
             ],
             "shared-users": [],
           "key-quorum-values": {
             "manage-key-quorum-value": 0,
             "use-key-quorum-value": 0
           },
             "cluster-coverage": "full"
           },
           "attributes": {
             "key-type": "aes",
             "label": "my_key",
             "id": "",
             "check-value": "0x6bd9f7",
             "class": "secret-key",
             "encrypt": false,
             "decrypt": true,
             "token": true,
             "always-sensitive": true,
             "derive": true,
             "destroyable": true,
             "extractable": true,
             "local": true,
             "modifiable": true,
             "never-extractable": false,
             "private": true,
             "sensitive": true,
             "sign": true,
             "trusted": true,
             "unwrap": true,
             "verify": true,
             "wrap": true,
             "wrap-with-trusted": false,
             "key-length-bytes": 32
           }
         }
       ],
       "total_key_count": 1,
       "returned_key_count": 1
     }
   }
   ```

## Argumente
<a name="chsm-cli-key-set-attribute-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<KEY\$1ATTRIBUTE>***  
Gibt den Namen des Attributs des Schlüssels an.  
Erforderlich: Ja

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein passender Schlüssel zum Löschen ausgewählt werden soll.  
Eine Liste der unterstützten CloudHSM-CLI-Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Nein

***<KEY\$1ATTRIBUTE\$1VALUE>***  
Gibt den Wert des Attributs des Schlüssels an.  
Erforderlich: Ja

***<KEY\$1REFERENCE>***  
Eine hexadezimale oder dezimale Darstellung des Schlüssels. (z. B. ein Tastenkürzel).  
Erforderlich: Nein

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Schlüssels für den Schlüsselverwaltungsdienst größer als 1 ist.

## Verwandte Themen
<a name="chsm-cli-key-set-attribute-see-also"></a>
+ [Schlüssel mithilfe der CloudHSM-CLI filtern](manage-keys-cloudhsm-cli-filtering.md)
+ [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)

# Einen Schlüssel mit CloudHSM CLI teilen
<a name="cloudhsm_cli-key-share"></a>

Verwenden Sie den **key share** Befehl in der CloudHSM-CLI, um einen Schlüssel mit anderen CUs in Ihrem AWS CloudHSM Cluster zu teilen.

Nur der CU, der den Schlüssel erstellt hat und somit Eigentümer des Schlüssels ist, kann den Schlüssel teilen. Benutzer, mit denen ein Schlüssel geteilt wird, können den Schlüssel für kryptografische Operationen verwenden, aber sie können den Schlüssel nicht löschen, exportieren, teilen oder das Teilen aufheben. Darüber hinaus können diese Benutzer [Schlüsselattribute](cloudhsm_cli-key-attributes.md) nicht ändern.

## Benutzertyp
<a name="chsm-cli-key-share-user-type"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="chsm-cli-key-share-requirements"></a>

Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="chsm-cli-key-share-syntax"></a>

```
aws-cloudhsm > help key share
Share a key in the HSM cluster with another user

Usage: key share --filter [<FILTER>...] --username <USERNAME> --role <ROLE>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error

      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key for sharing

      --username <USERNAME>
          A username with which the key will be shared

      --role <ROLE>
          Role the user has in the cluster

          Possible values:
          - crypto-user: A CryptoUser has the ability to manage and use keys
          - admin:       An Admin has the ability to manage user accounts

      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation

  -h, --help
          Print help (see a summary with '-h')
```

## Beispiel: Teilen Sie sich einen Schlüssel mit einem anderen CU
<a name="chsm-cli-key-share-examples"></a>

Das folgende Beispiel zeigt, wie Sie den **key share**-Befehl verwenden, um einen Schlüssel mit CU `alice` zu teilen.

**Example**  

1. Führen Sie den **key share**-Befehl aus, um den Schlüssel mit `alice` zu teilen.

   ```
   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"
     }
   }
   ```

1. Führen Sie den Befehl **key list** aus.

   ```
   aws-cloudhsm > key list --filter attr.label="rsa_key_to_share" attr.class=private-key --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. Überprüfen Sie in der obigen Liste, ob `alice` in der Liste von `shared-users` ist.

## Argumente
<a name="chsm-cli-key-share-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein passender Schlüssel zum Löschen ausgewählt werden soll.  
Eine Liste der unterstützten Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Ja

***<USERNAME>***  
Gibt einen Anzeigenamen für den Benutzer an. Die maximale Länge beträgt 31 Zeichen. Das einzige zulässige Sonderzeichen ist ein Unterstrich (\$1). Beim Benutzernamen wird in diesem Befehl nicht zwischen Groß- und Kleinschreibung unterschieden, der Benutzername wird immer in Kleinbuchstaben angezeigt.  
Erforderlich: Ja

***<ROLE>***  
Gibt die diesem Benutzer zugewiesene Rolle an. Dieser Parameter muss angegeben werden. Um die Rolle des Benutzers zu erfahren, verwenden Sie den Befehl user list. Ausführliche Informationen zu den Benutzertypen in einem HSM finden Sie unter [HSM-Benutzertypen für CloudHSM CLI](understanding-users.md).  
Erforderlich: Ja

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Schlüssels für den Schlüsselverwaltungsdienst größer als 1 ist.

## Verwandte Themen
<a name="chsm-cli-key-share-see-also"></a>
+ [Schlüssel mithilfe der CloudHSM-CLI filtern](manage-keys-cloudhsm-cli-filtering.md)
+ [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)

# Freigabe eines Schlüssels mithilfe der CloudHSM-CLI rückgängig machen
<a name="cloudhsm_cli-key-unshare"></a>

Verwenden Sie den **key unshare** Befehl in der CloudHSM-CLI, um die gemeinsame Nutzung eines Schlüssels mit anderen CUs in Ihrem Cluster aufzuheben. AWS CloudHSM 

Nur der CU, der den Schlüssel erstellt hat und somit Eigentümer des Schlüssels ist, kann das Teilen des Schlüssels aufheben. Benutzer, mit denen ein Schlüssel geteilt wird, können den Schlüssel für kryptografische Operationen verwenden, aber sie können den Schlüssel nicht löschen, exportieren, teilen oder das Teilen aufheben. Darüber hinaus können diese Benutzer [Schlüsselattribute](cloudhsm_cli-key-attributes.md) nicht ändern.

## Benutzertyp
<a name="chsm-cli-key-unshare-user-type"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="chsm-cli-key-unshare-requirements"></a>

Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="chsm-cli-key-unshare-syntax"></a>

```
aws-cloudhsm > help key unshare
Unshare a key in the HSM cluster with another user

Usage: key unshare --filter [<FILTER>...] --username <USERNAME> --role <ROLE>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error

      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a matching key for unsharing

      --username <USERNAME>
          A username with which the key will be unshared

      --role <ROLE>
          Role the user has in the cluster

          Possible values:
          - crypto-user: A CryptoUser has the ability to manage and use keys
          - admin:       An Admin has the ability to manage user accounts

      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation

  -h, --help
          Print help (see a summary with '-h')
```

## Beispiel: Die gemeinsame Nutzung eines Schlüssels mit einer anderen CU rückgängig machen
<a name="chsm-cli-key-share-examples"></a>

Das folgende Beispiel zeigt, wie Sie den **key unshare**-Befehl verwenden, um einen Schlüssel mit CU `alice` nicht mehr zu teilen.

**Example**  

1. Führen Sie den **key list**-Befehl aus und filtern Sie nach dem bestimmten Schlüssel, mit dem Sie das Teilen mit `alice` beenden möchten.

   ```
   aws-cloudhsm > key list --filter attr.label="rsa_key_to_share" attr.class=private-key --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. Bestätigen Sie, dass `alice` in der `shared-users`-Ausgabe enthalten ist, und führen Sie den folgenden **key unshare**-Befehl aus, um das Teilen des Schlüssels mit `alice` aufzuheben.

   ```
   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"
     }
   }
   ```

1. Führen Sie den `key list`-Befehl erneut aus, um zu bestätigen, dass das Teilen des Schlüssels mit `alice` aufgehoben wurde.

   ```
   aws-cloudhsm > key list --filter attr.label="rsa_key_to_share" attr.class=private-key --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
     }
   }
   ```

## Argumente
<a name="chsm-cli-key-unshare-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein passender Schlüssel zum Löschen ausgewählt werden soll.  
Eine Liste der unterstützten Schlüsselattribute finden Sie unter [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md).  
Erforderlich: Ja

***<USERNAME>***  
Gibt einen Anzeigenamen für den Benutzer an. Die maximale Länge beträgt 31 Zeichen. Das einzige zulässige Sonderzeichen ist ein Unterstrich (\$1). Beim Benutzernamen wird in diesem Befehl nicht zwischen Groß- und Kleinschreibung unterschieden, der Benutzername wird immer in Kleinbuchstaben angezeigt.  
Erforderlich: Ja

***<ROLE>***  
Gibt die diesem Benutzer zugewiesene Rolle an. Dieser Parameter muss angegeben werden. Um die Rolle des Benutzers zu erfahren, verwenden Sie den Befehl user list. Ausführliche Informationen zu den Benutzertypen in einem HSM finden Sie unter [HSM-Benutzertypen für CloudHSM CLI](understanding-users.md).  
Erforderlich: Ja

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Schlüssels für den Schlüsselverwaltungsdienst größer als 1 ist.

## Verwandte Themen
<a name="chsm-cli-key-unshare-see-also"></a>
+ [Schlüssel mithilfe der CloudHSM-CLI filtern](manage-keys-cloudhsm-cli-filtering.md)
+ [Schlüsselattribute für CloudHSM-CLI](cloudhsm_cli-key-attributes.md)

# Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI
<a name="cloudhsm_cli-key-unwrap"></a>

Der **key unwrap** übergeordnete Befehl in der CloudHSM-CLI importiert einen verschlüsselten (verpackten) symmetrischen oder asymmetrischen privaten Schlüssel aus einer Datei in das HSM. Dieser Befehl dient zum Import verschlüsselter Schlüssel, die durch den [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md) Befehl umschlossen wurden. Er kann aber auch zum Entpacken von Schlüsseln verwendet werden, die mit anderen Tools umschlossen wurden. In diesen Situationen empfehlen wir jedoch, die Softwarebibliotheken PKCS\$111 oder JCE zu verwenden, um den Schlüssel zu entpacken.
+ [aes-gcm](cloudhsm_cli-key-unwrap-aes-gcm.md)
+ [aes-no-pad](cloudhsm_cli-key-unwrap-aes-no-pad.md)
+ [aes-pkcs5-pad](cloudhsm_cli-key-unwrap-aes-pkcs5-pad.md)
+ [aes-zero-pad](cloudhsm_cli-key-unwrap-aes-zero-pad.md)
+ [cloudhsm-aes-gcm](cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm.md)
+ [rsa-aes](cloudhsm_cli-key-unwrap-rsa-aes.md)
+ [rsa-oaep](cloudhsm_cli-key-unwrap-rsa-oaep.md)
+ [rsa-pkcs](cloudhsm_cli-key-unwrap-rsa-pkcs.md)

# Entpacken Sie einen Schlüssel mit AES-GCM mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-unwrap-aes-gcm"></a>

Verwenden Sie den **key unwrap aes-gcm** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe des AES-Wrapping-Schlüssels und des Entpackungsmechanismus in den Cluster zu entpacken. `AES-GCM`

Unverpackte Schlüssel können auf die gleiche Weise verwendet werden wie die Schlüssel, die von generiert wurden. AWS CloudHSM Um anzuzeigen, dass sie nicht lokal generiert wurden, ist ihr `local` Attribut auf `false` gesetzt.

Um den **key unwrap aes-gcm** Befehl verwenden zu können, müssen Sie den AES-Wrapping-Schlüssel in Ihrem AWS CloudHSM Cluster haben und sein `unwrap` Attribut muss auf gesetzt sein`true`.

## Benutzertyp
<a name="cloudhsm_cli-key-unwrap-aes-gcm-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer (CUs)

## Voraussetzungen
<a name="cloudhsm_cli-key-unwrap-aes-gcm-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-unwrap-aes-gcm-syntax"></a>

```
aws-cloudhsm > help key unwrap aes-gcm
Usage: key unwrap aes-gcm [OPTIONS] --filter [<FILTER>...] --tag-length-bits <TAG_LENGTH_BITS> --key-type-class <KEY_TYPE_CLASS> --label <LABEL> --iv <IV> <--data-path <DATA_PATH>|--data <DATA>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a key to unwrap with
      --data-path <DATA_PATH>
          Path to the binary file containing the wrapped key data
      --data <DATA>
          Base64 encoded wrapped key data
      --attributes [<UNWRAPPED_KEY_ATTRIBUTES>...]
          Space separated list of key attributes in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE for the unwrapped key
      --share-crypto-users [<SHARE_CRYPTO_USERS;...]
          Space separated list of Crypto User usernames to share the unwrapped key with
      --manage-key-quorum-value <MANAGE_KEY_QUORUM_VALUE;
          The quorum value for key management operations for the unwrapped key
      --use-key-quorum-value <USE_KEY_QUORUM_VALUE;
          The quorum value for key usage operations for the unwrapped key
      --aad <AAD>
          Aes GCM Additional Authenticated Data (AAD) value, in hex
      --tag-length-bits <TAG_LENGTH_BITS>
          Aes GCM tag length in bits
      --key-type-class <KEY_TYPE_CLASS>
          Key type and class of wrapped key [possible values: aes, des3, ec-private, generic-secret, rsa-private]
      --label <LABEL>
          Label for the unwrapped key
      --session
          Creates a session key that exists only in the current session. The key cannot be recovered after the session ends
      --iv <IV>
          Initial value used to wrap the key, in hex
      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
  -h, --help
          Print help
```

## Beispiele
<a name="cloudhsm_cli-key-unwrap-aes-gcm-examples"></a>

Diese Beispiele zeigen, wie der **key unwrap aes-gcm** Befehl mithilfe eines AES-Schlüssels verwendet wird, dessen `unwrap` Attributwert auf gesetzt ist`true`.

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel aus Base64-kodierten verpackten Schlüsseldaten**  

```
aws-cloudhsm > key unwrap aes-gcm --key-type-class aes --label aes-unwrapped --filter attr.label=aes-example --tag-length-bits 64  --aad 0x10 --iv 0xf90613bb8e337ec0339aad21 --data xvslgrtg8kHzrvekny97tLSIeokpPwV8
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001808e4",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel, der über einen Datenpfad bereitgestellt wird**  

```
aws-cloudhsm > key unwrap aes-gcm --key-type-class aes --label aes-unwrapped --filter attr.label=aes-example --tag-length-bits 64  --aad 0x10 --iv 0xf90613bb8e337ec0339aad21 --data-path payload-key.pem
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001808e4",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-unwrap-aes-gcm-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein Schlüssel zum Entpacken ausgewählt werden soll.  
Erforderlich: Ja

***<DATA\$1PATH>***  
Pfad zur Binärdatei, die die umschlossenen Schlüsseldaten enthält.  
Erforderlich: Ja (sofern nicht über Base64-kodierte Daten bereitgestellt)

***<DATA>***  
Base64-kodierte umhüllte Schlüsseldaten.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<ATTRIBUTES>***  
Durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` für den umschlossenen Schlüssel.  
Erforderlich: Nein

***<AAD>***  
AES GCM-Wert für zusätzliche authentifizierte Daten (AAD) in Hexadezimalzahl.  
Erforderlich: Nein

***<TAG\$1LENGTH\$1BITS>***  
Länge des Aes GCM-Tags in Bit.  
Erforderlich: Ja

***<KEY\$1TYPE\$1CLASS>***  
Schlüsseltyp und Klasse des umschlossenen Schlüssels [mögliche Werte:`aes`,`des3`,`ec-private`,`generic-secret`,`rsa-private`].  
Erforderlich: Ja

***<LABEL>***  
Bezeichnung für den entpackten Schlüssel.  
Erforderlich: Ja

***<SESSION>***  
Erstellt einen Sitzungsschlüssel, der nur in der aktuellen Sitzung existiert. Der Schlüssel kann nach Ende der Sitzung nicht wiederhergestellt werden.  
Erforderlich: Nein

***<IV>***  
Anfangswert, der zum Umschließen des Schlüssels verwendet wird, in Hexadezimalform.  
Erforderlich: Nein

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst des Entpackungsschlüssels größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-unwrap-aes-gcm-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Entpacken Sie einen Schlüssel AES-NO-PAD mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-unwrap-aes-no-pad"></a>

Verwenden Sie den **key unwrap aes-no-pad** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe des AES-Wrapping-Schlüssels und des Entpackungsmechanismus in den AWS CloudHSM Cluster zu entpacken. `AES-NO-PAD`

Unverpackte Schlüssel können auf die gleiche Weise verwendet werden wie die Schlüssel, die von generiert wurden. AWS CloudHSM Um anzuzeigen, dass sie nicht lokal generiert wurden, ist ihr `local` Attribut auf `false` gesetzt.

Um den **key unwrap aes-no-pad** Befehl verwenden zu können, müssen Sie den AES-Wrapping-Schlüssel in Ihrem AWS CloudHSM Cluster haben und sein `unwrap` Attribut muss auf gesetzt sein`true`.

## Benutzertyp
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer (CUs)

## Voraussetzungen
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-syntax"></a>

```
aws-cloudhsm > help key unwrap aes-no-pad
Usage: key unwrap aes-no-pad [OPTIONS] --filter [<FILTER>...] --key-type-class <KEY_TYPE_CLASS> --label <LABEL> <--data-path <DATA_PATH>|--data <DATA>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a key to unwrap with
      --data-path <DATA_PATH>
          Path to the binary file containing the wrapped key data
      --data <DATA>
          Base64 encoded wrapped key data
      --attributes [<UNWRAPPED_KEY_ATTRIBUTES>...]
          Space separated list of key attributes in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE for the unwrapped key
      --share-crypto-users [<SHARE_CRYPTO_USERS;...]
          Space separated list of Crypto User usernames to share the unwrapped key with
      --manage-key-quorum-value <MANAGE_KEY_QUORUM_VALUE;
          The quorum value for key management operations for the unwrapped key
      --use-key-quorum-value <USE_KEY_QUORUM_VALUE;
          The quorum value for key usage operations for the unwrapped key
      --key-type-class <KEY_TYPE_CLASS>
          Key type and class of wrapped key [possible values: aes, des3, ec-private, generic-secret, rsa-private]
      --label <LABEL>
          Label for the unwrapped key
      --session
          Creates a session key that exists only in the current session. The key cannot be recovered after the session ends
      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
  -h, --help
          Print help
```

## Beispiele
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-examples"></a>

Diese Beispiele zeigen, wie der **key unwrap aes-no-pad** Befehl mithilfe eines AES-Schlüssels verwendet wird, dessen `unwrap` Attributwert auf gesetzt ist`true`.

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel aus Base64-kodierten umschlossenen Schlüsseldaten**  

```
aws-cloudhsm > key unwrap aes-no-pad --key-type-class aes --label aes-unwrapped --filter attr.label=aes-example --data eXK3PMAOnKM9y3YX6brbhtMoC060EOH9
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001c08ec",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel, der über einen Datenpfad bereitgestellt wird**  

```
aws-cloudhsm > key unwrap aes-no-pad --key-type-class aes --label aes-unwrapped --filter attr.label=aes-example --data-path payload-key.pem
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001c08ec",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein Schlüssel zum Entpacken ausgewählt werden soll.  
Erforderlich: Ja

***<DATA\$1PATH>***  
Pfad zur Binärdatei, die die umschlossenen Schlüsseldaten enthält.  
Erforderlich: Ja (sofern nicht über Base64-kodierte Daten bereitgestellt)

***<DATA>***  
Base64-kodierte umhüllte Schlüsseldaten.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<ATTRIBUTES>***  
Durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` für den umschlossenen Schlüssel.  
Erforderlich: Nein

***<KEY\$1TYPE\$1CLASS>***  
Schlüsseltyp und Klasse des umschlossenen Schlüssels [mögliche Werte: `aes``des3`,`ec-private`,`generic-secret`,,`rsa-private`].  
Erforderlich: Ja

***<LABEL>***  
Bezeichnung für den entpackten Schlüssel.  
Erforderlich: Ja

***<SESSION>***  
Erstellt einen Sitzungsschlüssel, der nur in der aktuellen Sitzung existiert. Der Schlüssel kann nach Ende der Sitzung nicht wiederhergestellt werden.  
Erforderlich: Nein

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Entpackungsschlüssels für den Schlüsselverwaltungsdienst größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Entpacken Sie einen Schlüssel mit AES- PKCS5 -PAD mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad"></a>

Verwenden Sie den **key unwrap aes-pkcs5-pad** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe des AES-Wrapping-Schlüssels und des Entpackungsmechanismus zu entpacken. `AES-PKCS5-PAD`

Unverpackte Schlüssel können auf die gleiche Weise verwendet werden wie die Schlüssel, die von generiert wurden. AWS CloudHSM Um anzuzeigen, dass sie nicht lokal generiert wurden, ist ihr `local` Attribut auf `false` gesetzt.

Um den **key unwrap aes-pkcs5-pad** Befehl verwenden zu können, müssen Sie den AES-Wrapping-Schlüssel in Ihrem AWS CloudHSM Cluster haben und sein `unwrap` Attribut muss auf gesetzt sein`true`.

## Benutzertyp
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer (CUs)

## Voraussetzungen
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-syntax"></a>

```
aws-cloudhsm > help key unwrap aes-pkcs5-pad
Usage: key unwrap aes-pkcs5-pad [OPTIONS] --filter [<FILTER>...] --key-type-class <KEY_TYPE_CLASS> --label <LABEL> <--data-path <DATA_PATH>|--data <DATA>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a key to unwrap with
      --data-path <DATA_PATH>
          Path to the binary file containing the wrapped key data
      --data <DATA>
          Base64 encoded wrapped key data
      --attributes [<UNWRAPPED_KEY_ATTRIBUTES>...]
          Space separated list of key attributes in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE for the unwrapped key
      --share-crypto-users [<SHARE_CRYPTO_USERS;...]
          Space separated list of Crypto User usernames to share the unwrapped key with
      --manage-key-quorum-value <MANAGE_KEY_QUORUM_VALUE;
          The quorum value for key management operations for the unwrapped key
      --use-key-quorum-value <USE_KEY_QUORUM_VALUE;
          The quorum value for key usage operations for the unwrapped key
      --key-type-class <KEY_TYPE_CLASS>
          Key type and class of wrapped key [possible values: aes, des3, ec-private, generic-secret, rsa-private]
      --label <LABEL>
          Label for the unwrapped key
      --session
          Creates a session key that exists only in the current session. The key cannot be recovered after the session ends
      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
  -h, --help
          Print help
```

## Beispiele
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-examples"></a>

Diese Beispiele zeigen, wie der **key unwrap aes-pkcs5-pad** Befehl mithilfe eines AES-Schlüssels verwendet wird, dessen `unwrap` Attributwert auf gesetzt ist`true`.

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel aus Base64-kodierten umschlossenen Schlüsseldaten**  

```
aws-cloudhsm > key unwrap aes-pkcs5-pad --key-type-class aes --label aes-unwrapped --filter attr.label=aes-example --data MbuYNresfOKyGNnxKWen88nSfX+uUE/0qmGofSisicY=
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001c08e3",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel, der über einen Datenpfad bereitgestellt wird**  

```
aws-cloudhsm > key unwrap aes-pkcs5-pad --key-type-class aes --label aes-unwrapped --filter attr.label=aes-example --data-path payload-key.pem
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001c08e3",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein Schlüssel zum Entpacken ausgewählt werden soll.  
Erforderlich: Ja

***<DATA\$1PATH>***  
Pfad zur Binärdatei, die die umschlossenen Schlüsseldaten enthält.  
Erforderlich: Ja (sofern nicht über Base64-kodierte Daten bereitgestellt)

***<DATA>***  
Base64-kodierte umhüllte Schlüsseldaten.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<ATTRIBUTES>***  
Durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` für den umschlossenen Schlüssel.  
Erforderlich: Nein

***<KEY\$1TYPE\$1CLASS>***  
Schlüsseltyp und Klasse des umschlossenen Schlüssels [mögliche Werte: `aes``des3`,`ec-private`,`generic-secret`,,`rsa-private`].  
Erforderlich: Ja

***<LABEL>***  
Bezeichnung für den entpackten Schlüssel.  
Erforderlich: Ja

***<SESSION>***  
Erstellt einen Sitzungsschlüssel, der nur in der aktuellen Sitzung existiert. Der Schlüssel kann nach Ende der Sitzung nicht wiederhergestellt werden.  
Erforderlich: Nein

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Entpackungsschlüssels für den Schlüsselverwaltungsdienst größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Entpacken Sie einen Schlüssel AES-ZERO-PAD mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad"></a>

Verwenden Sie den **key unwrap aes-zero-pad** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe des AES-Wrapping-Schlüssels und des Entpackungsmechanismus in den AWS CloudHSM Cluster zu entpacken. `AES-ZERO-PAD`

Unverpackte Schlüssel können auf die gleiche Weise verwendet werden wie die Schlüssel, die von generiert wurden. AWS CloudHSM Um anzuzeigen, dass sie nicht lokal generiert wurden, ist ihr `local` Attribut auf `false` gesetzt.

Um den **key unwrap aes-no-pad** Befehl verwenden zu können, müssen Sie den AES-Wrapping-Schlüssel in Ihrem AWS CloudHSM Cluster haben und sein `unwrap` Attribut muss auf gesetzt sein`true`.

## Benutzertyp
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer (CUs)

## Voraussetzungen
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-syntax"></a>

```
aws-cloudhsm > help key unwrap aes-zero-pad
Usage: key unwrap aes-zero-pad [OPTIONS] --filter [<FILTER>...] --key-type-class <KEY_TYPE_CLASS> --label <LABEL> <--data-path <DATA_PATH>|--data <DATA>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a key to unwrap with
      --data-path <DATA_PATH>
          Path to the binary file containing the wrapped key data
      --data <DATA>
          Base64 encoded wrapped key data
      --attributes [<UNWRAPPED_KEY_ATTRIBUTES>...]
          Space separated list of key attributes in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE for the unwrapped key
      --share-crypto-users [<SHARE_CRYPTO_USERS;...]
          Space separated list of Crypto User usernames to share the unwrapped key with
      --manage-key-quorum-value <MANAGE_KEY_QUORUM_VALUE;
          The quorum value for key management operations for the unwrapped key
      --use-key-quorum-value <USE_KEY_QUORUM_VALUE;
          The quorum value for key usage operations for the unwrapped key
      --key-type-class <KEY_TYPE_CLASS>
          Key type and class of wrapped key [possible values: aes, des3, ec-private, generic-secret, rsa-private]
      --label <LABEL>
          Label for the unwrapped key
      --session
          Creates a session key that exists only in the current session. The key cannot be recovered after the session ends
      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
  -h, --help
          Print help
```

## Beispiele
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-examples"></a>

Diese Beispiele zeigen, wie der **key unwrap aes-zero-pad** Befehl mithilfe eines AES-Schlüssels verwendet wird, dessen `unwrap` Attributwert auf gesetzt ist`true`.

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel aus Base64-kodierten umschlossenen Schlüsseldaten**  

```
aws-cloudhsm > key unwrap aes-zero-pad --key-type-class aes --label aes-unwrapped --filter attr.label=aes-example --data L1wVlL/YeBNVAw6Mpk3owFJZXBzDLONt
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001c08e7",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel, der über einen Datenpfad bereitgestellt wird**  

```
aws-cloudhsm > key unwrap aes-zero-pad --key-type-class aes --label aes-unwrapped --filter attr.label=aes-example --data-path payload-key.pem
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001c08e7",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein Schlüssel zum Entpacken ausgewählt werden soll.  
Erforderlich: Ja

***<DATA\$1PATH>***  
Pfad zur Binärdatei, die die umschlossenen Schlüsseldaten enthält.  
Erforderlich: Ja (sofern nicht über Base64-kodierte Daten bereitgestellt)

***<DATA>***  
Base64-kodierte umhüllte Schlüsseldaten.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<ATTRIBUTES>***  
Durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` für den umschlossenen Schlüssel.  
Erforderlich: Nein

***<KEY\$1TYPE\$1CLASS>***  
Schlüsseltyp und Klasse des umschlossenen Schlüssels [mögliche Werte: `aes``des3`,`ec-private`,`generic-secret`,,`rsa-private`].  
Erforderlich: Ja

***<LABEL>***  
Bezeichnung für den entpackten Schlüssel.  
Erforderlich: Ja

***<SESSION>***  
Erstellt einen Sitzungsschlüssel, der nur in der aktuellen Sitzung existiert. Der Schlüssel kann nach Ende der Sitzung nicht wiederhergestellt werden.  
Erforderlich: Nein

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Entpackungsschlüssels für den Schlüsselverwaltungsdienst größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Entpacken Sie einen Schlüssel CLOUDHSM-AES-GCM mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm"></a>

Verwenden Sie den **key unwrap cloudhsm-aes-gcm** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe des AES-Wrapping-Schlüssels und des Entpackungsmechanismus in den AWS CloudHSM Cluster zu entpacken. `CLOUDHSM-AES-GCM`

Unverpackte Schlüssel können auf die gleiche Weise verwendet werden wie die Schlüssel, die von generiert wurden. AWS CloudHSM Um anzuzeigen, dass sie nicht lokal generiert wurden, ist ihr `local` Attribut auf `false` gesetzt.

Um den **key unwrap cloudhsm-aes-gcm** Befehl verwenden zu können, müssen Sie den AES-Wrapping-Schlüssel in Ihrem AWS CloudHSM Cluster haben und sein `unwrap` Attribut muss auf gesetzt sein`true`.

## Benutzertyp
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Krypto-Benutzer (CUs)

## Voraussetzungen
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-syntax"></a>

```
aws-cloudhsm > help key unwrap cloudhsm-aes-gcm
Usage: key unwrap cloudhsm-aes-gcm [OPTIONS] --filter [<FILTER>...] --tag-length-bits <TAG_LENGTH_BITS> --key-type-class <KEY_TYPE_CLASS> --label <LABEL> <--data-path <DATA_PATH>|--data <DATA>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a key to unwrap with
      --data-path <DATA_PATH>
          Path to the binary file containing the wrapped key data
      --data <DATA>
          Base64 encoded wrapped key data
      --attributes [<UNWRAPPED_KEY_ATTRIBUTES>...]
          Space separated list of key attributes in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE for the unwrapped key
      --share-crypto-users [<SHARE_CRYPTO_USERS;...]
          Space separated list of Crypto User usernames to share the unwrapped key with
      --manage-key-quorum-value <MANAGE_KEY_QUORUM_VALUE;
          The quorum value for key management operations for the unwrapped key
      --use-key-quorum-value <USE_KEY_QUORUM_VALUE;
          The quorum value for key usage operations for the unwrapped key
      --aad <AAD>
          Aes GCM Additional Authenticated Data (AAD) value, in hex
      --tag-length-bits <TAG_LENGTH_BITS>
          Aes GCM tag length in bits
      --key-type-class <KEY_TYPE_CLASS>
          Key type and class of wrapped key [possible values: aes, des3, ec-private, generic-secret, rsa-private]
      --label <LABEL>
          Label for the unwrapped key
      --session
          Creates a session key that exists only in the current session. The key cannot be recovered after the session ends
      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
  -h, --help
          Print help
```

## Beispiele
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-examples"></a>

Diese Beispiele zeigen, wie der **key unwrap cloudhsm-aes-gcm** Befehl mithilfe eines AES-Schlüssels verwendet wird, dessen `unwrap` Attributwert auf gesetzt ist`true`.

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel aus Base64-kodierten umschlossenen Schlüsseldaten**  

```
aws-cloudhsm > key unwrap cloudhsm-aes-gcm --key-type-class aes --label aes-unwrapped --filter attr.label=aes-example --tag-length-bits 64  --aad 0x10 --data 6Rn8nkjEriDYlnP3P8nPkYQ8hplOEJ899zsrF+aTB0i/fIlZ
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001408e8",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel, der über einen Datenpfad bereitgestellt wird**  

```
aws-cloudhsm > key unwrap cloudhsm-aes-gcm --key-type-class aes --label aes-unwrapped --filter attr.label=aes-example --tag-length-bits 64  --aad 0x10 --data-path payload-key.pem
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001408e8",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein Schlüssel zum Entpacken ausgewählt werden soll.  
Erforderlich: Ja

***<DATA\$1PATH>***  
Pfad zur Binärdatei, die die umschlossenen Schlüsseldaten enthält.  
Erforderlich: Ja (sofern nicht über Base64-kodierte Daten bereitgestellt)

***<DATA>***  
Base64-kodierte umhüllte Schlüsseldaten.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<ATTRIBUTES>***  
Durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` für den umschlossenen Schlüssel.  
Erforderlich: Nein

***<AAD>***  
AES GCM-Wert für zusätzliche authentifizierte Daten (AAD) in Hexadezimalzahl.  
Erforderlich: Nein

***<TAG\$1LENGTH\$1BITS>***  
Länge des Aes GCM-Tags in Bit.  
Erforderlich: Ja

***<KEY\$1TYPE\$1CLASS>***  
Schlüsseltyp und Klasse des umschlossenen Schlüssels [mögliche Werte:`aes`,`des3`,`ec-private`,`generic-secret`,`rsa-private`].  
Erforderlich: Ja

***<LABEL>***  
Bezeichnung für den entpackten Schlüssel.  
Erforderlich: Ja

***<SESSION>***  
Erstellt einen Sitzungsschlüssel, der nur in der aktuellen Sitzung existiert. Der Schlüssel kann nach Ende der Sitzung nicht wiederhergestellt werden.  
Erforderlich: Nein

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Entpackungsschlüssels für den Schlüsselverwaltungsdienst größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Entpacken Sie einen Schlüssel mit RSA-AES mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-unwrap-rsa-aes"></a>

Verwenden Sie den **key unwrap rsa-aes** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe eines privaten RSA-Schlüssels und des Entpackungsmechanismus zu entpacken. `RSA-AES`

Unverpackte Schlüssel können auf die gleiche Weise verwendet werden wie die Schlüssel, die von generiert wurden. AWS CloudHSM Um anzuzeigen, dass sie nicht lokal generiert wurden, ist ihr `local` Attribut auf `false` gesetzt.

Um den verwenden zu können**key unwrap rsa-aes**, müssen Sie den privaten RSA-Schlüssel oder den öffentlichen RSA-Wrapping-Schlüssel in Ihrem AWS CloudHSM Cluster haben, und sein `unwrap` Attribut muss auf gesetzt sein. `true` 

**Anmerkung**  
Dieser Befehl ist nur mit CloudHSM CLI 5.11\$1 verfügbar.

## Benutzertyp
<a name="cloudhsm_cli-key-unwrap-rsa-aes-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-key-unwrap-rsa-aes-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-unwrap-rsa-aes-syntax"></a>

```
aws-cloudhsm > help key unwrap rsa-aes
Usage: key unwrap rsa-aes [OPTIONS] --filter [<FILTER>...] --hash-function <HASH_FUNCTION> --mgf <MGF> --key-type-class <KEY_TYPE_CLASS> --label <LABEL> <--data-path <DATA_PATH>|--data <DATA>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a key to unwrap with
      --data-path <DATA_PATH>
          Path to the binary file containing the wrapped key data
      --data <DATA>
          Base64 encoded wrapped key data
      --attributes [<UNWRAPPED_KEY_ATTRIBUTES>...]
          Space separated list of key attributes in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE for the unwrapped key
      --share-crypto-users [<SHARE_CRYPTO_USERS;...]
          Space separated list of Crypto User usernames to share the unwrapped key with
      --manage-key-quorum-value <MANAGE_KEY_QUORUM_VALUE;
          The quorum value for key management operations for the unwrapped key
      --use-key-quorum-value <USE_KEY_QUORUM_VALUE;
          The quorum value for key usage operations for the unwrapped key
      --hash-function <HASH_FUNCTION>
          Hash algorithm [possible values: sha1, sha224, sha256, sha384, sha512]
      --mgf <MGF>
          Mask Generation Function algorithm [possible values: mgf1-sha1, mgf1-sha224, mgf1-sha256, mgf1-sha384, mgf1-sha512]
      --key-type-class <KEY_TYPE_CLASS>
          Key type and class of wrapped key [possible values: aes, des3, ec-private, generic-secret, rsa-private]
      --label <LABEL>
          Label for the unwrapped key
      --session
          Creates a session key that exists only in the current session. The key cannot be recovered after the session ends
      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-key-unwrap-rsa-aes-examples"></a>

Diese Beispiele zeigen, wie der **key unwrap rsa-aes** Befehl unter Verwendung des privaten RSA-Schlüssels mit dem `unwrap` Attributwert auf `true` verwendet wird.

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel aus Base64-kodierten verpackten Schlüsseldaten**  

```
aws-cloudhsm > key unwrap rsa-aes --key-type-class aes --label aes-unwrapped --filter attr.label=rsa-private-key-example --hash-function sha256 --mgf mgf1-sha256 --data HrSE1DEyLjIeyGdPa9R+ebiqB5TIJGyamPker31ZebPwRA+NcerbAJO8DJ1lXPygZcI21vIFSZJuWMEiWpe1R9D/5WSYgxLVKex30xCFqebtEzxbKuv4DOmU4meSofqREYvtb3EoIKwjyxCMRQFgoyUCuP4y0f0eSv0k6rSJh4NuCsHptXZbtgNeRcR4botN7LlzkEIUcq4fVHaatCwd0J1QGKHKyRhkol+RL5WGXKe4nAboAkC5GO7veI5yHL1SaKlssSJtTL/CFpbSLsAFuYbv/NUCWwMY5mwyVTCSlw+HlgKK+5TH1MzBaSi8fpfyepLT8sHy2Q/VRl6ifb49p6m0KQFbRVvz/OWUd6l4d97BdgtaEz6ueg==
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001808e2",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel, der über einen Datenpfad bereitgestellt wird**  

```
aws-cloudhsm > key unwrap rsa-aes --key-type-class aes --label aes-unwrapped --filter attr.label=rsa-private-key-example --hash-function sha256 --mgf mgf1-sha256 --data-path payload-key.pem
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001808e2",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-unwrap-rsa-aes-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein Schlüssel zum Entpacken ausgewählt werden soll.  
Erforderlich: Ja

***<DATA\$1PATH>***  
Pfad zur Binärdatei, die die umschlossenen Schlüsseldaten enthält.  
Erforderlich: Ja (sofern nicht über Base64-kodierte Daten bereitgestellt)

***<DATA>***  
Base64-kodierte umhüllte Schlüsseldaten.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<ATTRIBUTES>***  
Durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` für den umschlossenen Schlüssel.  
Erforderlich: Nein

***<KEY\$1TYPE\$1CLASS>***  
Schlüsseltyp und Klasse des umschlossenen Schlüssels [mögliche Werte: `aes``des3`,`ec-private`,`generic-secret`,,`rsa-private`].  
Erforderlich: Ja

***<HASH\$1FUNCTION>***  
Spezifiziert die Hash-Funktion.  
Zulässige Werte:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Erforderlich: Ja

***<MGF>***  
Gibt die Funktion zur Maskengenerierung an.   
Die Hash-Funktion der Maskengenerierungsfunktion muss mit der Hash-Funktion des Signaturmechanismus übereinstimmen.
Zulässige Werte:  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Erforderlich: Ja

***<LABEL>***  
Etikett für den unverpackten Schlüssel.  
Erforderlich: Ja

***<SESSION>***  
Erstellt einen Sitzungsschlüssel, der nur in der aktuellen Sitzung existiert. Der Schlüssel kann nach Ende der Sitzung nicht wiederhergestellt werden.  
Erforderlich: Nein

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Entpackungsschlüssels für den Schlüsselverwaltungsdienst größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-unwrap-rsa-aes-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Entpacken Sie einen Schlüssel mit RSA-OAEP mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-unwrap-rsa-oaep"></a>

Verwenden Sie den **key unwrap rsa-oaep** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe des privaten RSA-Schlüssels und des Entpackungsmechanismus zu entpacken. `RSA-OAEP`

Unverpackte Schlüssel können auf die gleiche Weise verwendet werden wie die Schlüssel, die von generiert wurden. AWS CloudHSM Um anzuzeigen, dass sie nicht lokal generiert wurden, ist ihr `local` Attribut auf `false` gesetzt.

Um den **key unwrap rsa-oaep** Befehl verwenden zu können, müssen Sie den privaten RSA-Schlüssel oder den öffentlichen RSA-Wrapping-Schlüssel in Ihrem AWS CloudHSM Cluster haben, und sein `unwrap` Attribut muss auf gesetzt sein. `true`

## Benutzertyp
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-syntax"></a>

```
aws-cloudhsm > help key unwrap rsa-oaep
Usage: key unwrap rsa-oaep [OPTIONS] --filter [<FILTER>...] --hash-function <HASH_FUNCTION> --mgf <MGF> --key-type-class <KEY_TYPE_CLASS> --label <LABEL> <--data-path <DATA_PATH>|--data <DATA>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a key to unwrap with
      --data-path <DATA_PATH>
          Path to the binary file containing the wrapped key data
      --data <DATA>
          Base64 encoded wrapped key data
      --attributes [<UNWRAPPED_KEY_ATTRIBUTES>...]
          Space separated list of key attributes in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE for the unwrapped key
      --share-crypto-users [<SHARE_CRYPTO_USERS;...]
          Space separated list of Crypto User usernames to share the unwrapped key with
      --manage-key-quorum-value <MANAGE_KEY_QUORUM_VALUE;
          The quorum value for key management operations for the unwrapped key
      --use-key-quorum-value <USE_KEY_QUORUM_VALUE;
          The quorum value for key usage operations for the unwrapped key
      --hash-function <HASH_FUNCTION>
          Hash algorithm [possible values: sha1, sha224, sha256, sha384, sha512]
      --mgf <MGF>
          Mask Generation Function algorithm [possible values: mgf1-sha1, mgf1-sha224, mgf1-sha256, mgf1-sha384, mgf1-sha512]
      --key-type-class <KEY_TYPE_CLASS>
          Key type and class of wrapped key [possible values: aes, des3, ec-private, generic-secret, rsa-private]
      --label <LABEL>
          Label for the unwrapped key
      --session
          Creates a session key that exists only in the current session. The key cannot be recovered after the session ends
      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
  -h, --help
          Print help
```

## Beispiele
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-examples"></a>

Diese Beispiele zeigen, wie der **key unwrap rsa-oaep** Befehl unter Verwendung des privaten RSA-Schlüssels mit dem `unwrap` Attributwert auf `true` verwendet wird.

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel aus Base64-kodierten verpackten Schlüsseldaten**  

```
aws-cloudhsm > key unwrap rsa-oaep --key-type-class aes --label aes-unwrapped --filter attr.label=rsa-private-example-key --hash-function sha256 --mgf mgf1-sha256 --data OjJe4msobPLz9TuSAdULEu17T5rMDWtSlLyBSkLbaZnYzzpdrhsbGLbwZJCtB/jGkDNdB4qyTAOQwEpggGf6v+Yx6JcesNeKKNU8XZal/YBoHC8noTGUSDI2qr+u2tDc84NPv6d+F2KOONXsSxMhmxzzNG/gzTVIJhOuy/B1yHjGP4mOXoDZf5+7f5M1CjxBmz4Vva/wrWHGCSG0yOaWblEvOiHAIt3UBdyKmU+/My4xjfJv7WGGu3DFUUIZ06TihRtKQhUYU1M9u6NPf9riJJfHsk6QCuSZ9yWThDT9as6i7e3htnyDhIhGWaoK8JU855cN/YNKAUqkNpC4FPL3iw==
{
  "data": {
    "key": {
      "key-reference": "0x00000000001808e9",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel, der über einen Datenpfad bereitgestellt wird**  

```
aws-cloudhsm > key unwrap rsa-oaep --key-type-class aes --label aes-unwrapped --filter attr.label=rsa-private-example-key --hash-function sha256 --mgf mgf1-sha256 --data-path payload-key.pem
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001808e9",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein Schlüssel zum Entpacken ausgewählt werden soll.  
Erforderlich: Ja

***<DATA\$1PATH>***  
Pfad zur Binärdatei, die die umschlossenen Schlüsseldaten enthält.  
Erforderlich: Ja (sofern nicht über Base64-kodierte Daten bereitgestellt)

***<DATA>***  
Base64-kodierte umhüllte Schlüsseldaten.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<ATTRIBUTES>***  
Durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` für den umschlossenen Schlüssel.  
Erforderlich: Nein

***<KEY\$1TYPE\$1CLASS>***  
Schlüsseltyp und Klasse des umschlossenen Schlüssels [mögliche Werte: `aes``des3`,`ec-private`,`generic-secret`,,`rsa-private`].  
Erforderlich: Ja

***<HASH\$1FUNCTION>***  
Spezifiziert die Hash-Funktion.  
Zulässige Werte:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Erforderlich: Ja

***<MGF>***  
Gibt die Funktion zur Maskengenerierung an.   
Die Hash-Funktion der Maskengenerierungsfunktion muss mit der Hash-Funktion des Signaturmechanismus übereinstimmen.
Zulässige Werte:  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Erforderlich: Ja

***<LABEL>***  
Etikett für den unverpackten Schlüssel.  
Erforderlich: Ja

***<SESSION>***  
Erstellt einen Sitzungsschlüssel, der nur in der aktuellen Sitzung existiert. Der Schlüssel kann nach Ende der Sitzung nicht wiederhergestellt werden.  
Erforderlich: Nein

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Entpackungsschlüssels für den Schlüsselverwaltungsdienst größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Entpacken Sie einen Schlüssel mit RSA-PKCS mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs"></a>

Verwenden Sie den **key unwrap rsa-pkcs** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe des privaten RSA-Schlüssels und des Entpackungsmechanismus zu entpacken. `RSA-PKCS`

Unverpackte Schlüssel können auf die gleiche Weise verwendet werden wie die Schlüssel, die von generiert wurden. AWS CloudHSM Um anzuzeigen, dass sie nicht lokal generiert wurden, ist ihr `local` Attribut auf `false` gesetzt.

Um den **unwrap rsa-pkcs** Befehl key verwenden zu können, müssen Sie den privaten RSA-Schlüssel oder den öffentlichen RSA-Wrapping-Schlüssel in Ihrem AWS CloudHSM Cluster haben, und sein `unwrap` Attribut muss auf gesetzt sein. `true`

## Benutzertyp
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-syntax"></a>

```
aws-cloudhsm > help key unwrap rsa-pkcs
Usage: key unwrap rsa-pkcs [OPTIONS] --filter [<FILTER>...] --key-type-class <KEY_TYPE_CLASS> --label <LABEL> <--data-path <DATA_PATH>|--data <DATA>>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --filter [<FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a key to unwrap with
      --data-path <DATA_PATH>
          Path to the binary file containing the wrapped key data
      --data <DATA>
          Base64 encoded wrapped key data
      --attributes [<UNWRAPPED_KEY_ATTRIBUTES>...]
          Space separated list of key attributes in the form of KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE for the unwrapped key
      --share-crypto-users [<SHARE_CRYPTO_USERS;...]
          Space separated list of Crypto User usernames to share the unwrapped key with
      --manage-key-quorum-value <MANAGE_KEY_QUORUM_VALUE;
          The quorum value for key management operations for the unwrapped key
      --use-key-quorum-value <USE_KEY_QUORUM_VALUE;
          The quorum value for key usage operations for the unwrapped key
      --key-type-class <KEY_TYPE_CLASS>
          Key type and class of wrapped key [possible values: aes, des3, ec-private, generic-secret, rsa-private]
      --label <LABEL>
          Label for the unwrapped key
      --session
          Creates a session key that exists only in the current session. The key cannot be recovered after the session ends
      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
  -h, --help
          Print help
```

## Beispiele
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-examples"></a>

Diese Beispiele zeigen, wie der **key unwrap rsa-oaep** Befehl mithilfe eines AES-Schlüssels verwendet wird, dessen `unwrap` Attributwert auf gesetzt ist`true`.

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel aus Base64-kodierten umschlossenen Schlüsseldaten**  

```
aws-cloudhsm > key unwrap rsa-pkcs --key-type-class aes --label aes-unwrapped --filter attr.label=rsa-private-key-example --data am0Nc7+YE8FWs+5HvU7sIBcXVb24QA0l65nbNAD+1bK+e18BpSfnaI3P+r8Dp+pLu1ofoUy/vtzRjZoCiDofcz4EqCFnGl4GdcJ1/3W/5WRvMatCa2d7cx02swaeZcjKsermPXYRO1lGlfq6NskwMeeTkV8R7Rx9artFrs1y0DdIgIKVaiFHwnBIUMnlQrR2zRmMkfwU1jxMYmOYyD031F5VbnjSrhfMwkww2la7uf/c3XdFJ2+0Bo94c6og/yfPcpOOobJlITCoXhtMRepSdO4OggYq/6nUDuHCtJ86pPGnNahyr7+sAaSI3a5ECQLUjwaIARUCyoRh7EFK3qPXcg==
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001c08ef",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

**Example Beispiel: Entpacken Sie einen Payload-Schlüssel, der über einen Datenpfad bereitgestellt wird**  

```
aws-cloudhsm > key unwrap rsa-pkcs --key-type-class aes --label aes-unwrapped --filter attr.label=rsa-private-key-example --data-path payload-key.pem
{
  "error_code": 0,
  "data": {
    "key": {
      "key-reference": "0x00000000001c08ef",
      "key-info": {
        "key-owners": [
          {
            "username": "cu1",
            "key-coverage": "full"
          }
        ],
        "shared-users": [],
        "key-quorum-values": {
          "manage-key-quorum-value": 0,
          "use-key-quorum-value": 0
        },
        "cluster-coverage": "full"
      },
      "attributes": {
        "key-type": "aes",
        "label": "aes-unwrapped",
        "id": "0x",
        "check-value": "0x8d9099",
        "class": "secret-key",
        "encrypt": false,
        "decrypt": false,
        "token": true,
        "always-sensitive": false,
        "derive": false,
        "destroyable": true,
        "extractable": true,
        "local": false,
        "modifiable": true,
        "never-extractable": false,
        "private": true,
        "sensitive": true,
        "sign": true,
        "trusted": false,
        "unwrap": false,
        "verify": true,
        "wrap": false,
        "wrap-with-trusted": false,
        "key-length-bytes": 16
      }
    }
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`, dass ein Schlüssel zum Entpacken ausgewählt werden soll.  
Erforderlich: Ja

***<DATA\$1PATH>***  
Pfad zur Binärdatei, die die umschlossenen Schlüsseldaten enthält.  
Erforderlich: Ja (sofern nicht über Base64-kodierte Daten bereitgestellt)

***<DATA>***  
Base64-kodierte umhüllte Schlüsseldaten.  
Erforderlich: Ja (sofern nicht über den Datenpfad angegeben)

***<ATTRIBUTES>***  
Durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form von `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` für den umschlossenen Schlüssel.  
Erforderlich: Nein

***<KEY\$1TYPE\$1CLASS>***  
Schlüsseltyp und Klasse des umschlossenen Schlüssels [mögliche Werte: `aes``des3`,`ec-private`,`generic-secret`,,`rsa-private`].  
Erforderlich: Ja

***<LABEL>***  
Bezeichnung für den entpackten Schlüssel.  
Erforderlich: Ja

***<SESSION>***  
Erstellt einen Sitzungsschlüssel, der nur in der aktuellen Sitzung existiert. Der Schlüssel kann nach Ende der Sitzung nicht wiederhergestellt werden.  
Erforderlich: Nein

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Entpackungsschlüssels für den Schlüsselverwaltungsdienst größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Der Key Wrap-Befehl in der CloudHSM-CLI
<a name="cloudhsm_cli-key-wrap"></a>

Der **key wrap** Befehl in der CloudHSM-CLI exportiert eine verschlüsselte Kopie eines symmetrischen oder asymmetrischen privaten Schlüssels aus dem Hardware-Sicherheitsmodul (HSM) in eine Datei. Bei der Ausführung **key wrap** geben Sie zwei Dinge an: den zu exportierenden Schlüssel und die Ausgabedatei. Der zu exportierende Schlüssel ist ein Schlüssel auf dem HSM, der den Schlüssel, den Sie exportieren möchten, verschlüsselt (umhüllt).

Der **key wrap** Befehl entfernt den Schlüssel nicht aus dem HSM und verhindert auch nicht, dass Sie ihn für kryptografische Operationen verwenden. Sie können den gleichen Schlüssel mehrmals exportieren. Um den verschlüsselten Schlüssel wieder in das HSM zu importieren, verwenden Sie. [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md) Nur der Besitzer eines Schlüssels, d. h. der Crypto-Benutzer (CU), der den Schlüssel erstellt hat, kann den Schlüssel umschließen. Benutzer, mit denen der Schlüssel gemeinsam genutzt wird, können den Schlüssel nur für kryptografische Operationen verwenden.

Der **key wrap** Befehl besteht aus den folgenden Unterbefehlen:
+ [aes-gcm](cloudhsm_cli-key-wrap-aes-gcm.md)
+ [aes-no-pad](cloudhsm_cli-key-wrap-aes-no-pad.md)
+ [aes-pkcs5-pad](cloudhsm_cli-key-wrap-aes-pkcs5-pad.md)
+ [aes-zero-pad](cloudhsm_cli-key-wrap-aes-zero-pad.md)
+ [cloudhsm-aes-gcm](cloudhsm_cli-key-wrap-cloudhsm-aes-gcm.md)
+ [rsa-aes](cloudhsm_cli-key-wrap-rsa-aes.md)
+ [rsa-oaep](cloudhsm_cli-key-wrap-rsa-oaep.md)
+ [rsa-pkcs](cloudhsm_cli-key-wrap-rsa-pkcs.md)

# Umschließen eines Schlüssels mit AES-GCM mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-wrap-aes-gcm"></a>

Verwenden Sie den **key wrap aes-gcm** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe eines AES-Schlüssels auf dem Hardware-Sicherheitsmodul (HSM) und dem Wrapping-Mechanismus zu umschließen. `AES-GCM` Das `extractable` Attribut des Payload-Schlüssels muss auf gesetzt sein. `true`

Nur der Besitzer eines Schlüssels, d. h. der Crypto-Benutzer (CU), der den Schlüssel erstellt hat, kann den Schlüssel umschließen. Benutzer, die den Schlüssel gemeinsam nutzen, können den Schlüssel für kryptografische Operationen verwenden.

Um den **key wrap aes-gcm** Befehl verwenden zu können, benötigen Sie zunächst einen AES-Schlüssel in Ihrem AWS CloudHSM Cluster. Sie können einen AES-Schlüssel zum Umschließen generieren, indem Sie den [Generieren Sie einen symmetrischen AES-Schlüssel mit CloudHSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) Befehl verwenden und das `wrap` Attribut auf gesetzt haben`true`.

## Benutzertyp
<a name="cloudhsm_cli-key-wrap-aes-gcm-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer (CUs)

## Voraussetzungen
<a name="cloudhsm_cli-key-wrap-aes-gcm-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-wrap-aes-gcm-syntax"></a>

```
aws-cloudhsm > help key wrap aes-gcm
Usage: key wrap aes-gcm [OPTIONS] --payload-filter [<PAYLOAD_FILTER>...] --wrapping-filter [<WRAPPING_FILTER>...] --tag-length-bits <TAG_LENGTH_BITS>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --payload-filter [<PAYLOAD_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a payload key
      --wrapping-filter [<WRAPPING_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a wrapping key
      --path <PATH>
          Path to the binary file where the wrapped key data will be saved
      --wrapping-approval <WRAPPING_APPROVALR>
          File path of signed quorum token file to approve operation for wrapping key
      --payload-approval <PAYLOAD_APPROVALR>
          File path of signed quorum token file to approve operation for payload key
      --aad <AAD>
          Aes GCM Additional Authenticated Data (AAD) value, in hex
      --tag-length-bits <TAG_LENGTH_BITS>
          Aes GCM tag length in bits
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-key-wrap-aes-gcm-examples"></a>

Dieses Beispiel zeigt, wie der **key wrap aes-gcm** Befehl mit einem AES-Schlüssel verwendet wird.

**Example**  

```
aws-cloudhsm > key wrap aes-gcm --payload-filter attr.label=payload-key --wrapping-filter attr.label=aes-example --tag-length-bits 64  --aad 0x10
{
  "error_code": 0,
  "data": {
    "payload_key_reference": "0x00000000001c08f1",
    "wrapping_key_reference": "0x00000000001c08ea",
    "iv": "0xf90613bb8e337ec0339aad21",
    "wrapped_key_data": "xvslgrtg8kHzrvekny97tLSIeokpPwV8"
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-wrap-aes-gcm-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Payload-Schlüssels“.  
Erforderlich: Ja

***<PATH>***  
Pfad zur Binärdatei, in der die verpackten Schlüsseldaten gespeichert werden.  
Erforderlich: Nein

***<WRAPPING\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Umbruchschlüssels“.   
Erforderlich: Ja

***<AAD>***  
AES-GCM-Wert für zusätzliche authentifizierte Daten (AAD) in Hexadezimalzahl.   
Erforderlich: Nein

***<TAG\$1LENGTH\$1BITS>***  
Länge des AES-GCM-Tags in Bit.  
Erforderlich: Ja

***<WRAPPING\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zum Umschließen des Schlüssels zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst beim Umschließen des Schlüssels größer als 1 ist.

***<PAYLOAD\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang für den Payload-Schlüssel zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst des Payload-Schlüssels größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-wrap-aes-gcm-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Einen Schlüssel AES-NO-PAD mithilfe der CloudHSM-CLI umschließen
<a name="cloudhsm_cli-key-wrap-aes-no-pad"></a>

Verwenden Sie den **key wrap aes-no-pad** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe eines AES-Schlüssels auf dem Hardware-Sicherheitsmodul (HSM) und dem Wrapping-Mechanismus zu umschließen. `AES-NO-PAD` Das `extractable` Attribut des Payload-Schlüssels muss auf gesetzt sein. `true`

Nur der Besitzer eines Schlüssels, d. h. der Crypto-Benutzer (CU), der den Schlüssel erstellt hat, kann den Schlüssel umschließen. Benutzer, die den Schlüssel gemeinsam nutzen, können den Schlüssel für kryptografische Operationen verwenden.

Um den **key wrap aes-no-pad** Befehl verwenden zu können, benötigen Sie zunächst einen AES-Schlüssel in Ihrem AWS CloudHSM Cluster. Sie können mithilfe des [Generieren Sie einen symmetrischen AES-Schlüssel mit CloudHSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) Befehls einen AES-Schlüssel für das Umschließen generieren, und das `wrap` Attribut ist auf gesetzt`true`.

## Benutzertyp
<a name="cloudhsm_cli-key-wrap-aes-no-pad-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer (CUs)

## Voraussetzungen
<a name="cloudhsm_cli-key-wrap-aes-no-pad-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-wrap-aes-no-pad-syntax"></a>

```
aws-cloudhsm > help key wrap aes-no-pad
Usage: key wrap aes-no-pad [OPTIONS] --payload-filter [<PAYLOAD_FILTER>...] --wrapping-filter [<WRAPPING_FILTER>...]

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --payload-filter [<PAYLOAD_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a payload key
      --wrapping-filter [<WRAPPING_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a wrapping key
      --path <PATH>
          Path to the binary file where the wrapped key data will be saved
      --wrapping-approval <WRAPPING_APPROVALR>
          File path of signed quorum token file to approve operation for wrapping key
      --payload-approval <PAYLOAD_APPROVALR>
          File path of signed quorum token file to approve operation for payload key
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-key-wrap-aes-no-pad-examples"></a>

Dieses Beispiel zeigt, wie der **key wrap aes-no-pad** Befehl mit einem AES-Schlüssel verwendet wird, dessen `wrap` Attributwert auf gesetzt ist`true`.

**Example**  

```
aws-cloudhsm > key wrap aes-no-pad --payload-filter attr.label=payload-key --wrapping-filter attr.label=aes-example
{
  "error_code": 0,
  "data": {
    "payload_key_reference": "0x00000000001c08f1",
    "wrapping_key_reference": "0x00000000001c08ea",
    "wrapped_key_data": "eXK3PMAOnKM9y3YX6brbhtMoC060EOH9"
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-wrap-aes-no-pad-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Payload-Schlüssels“.  
Erforderlich: Ja

***<PATH>***  
Pfad zur Binärdatei, in der die verpackten Schlüsseldaten gespeichert werden.  
Erforderlich: Nein

***<WRAPPING\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Umbruchschlüssels“.   
Erforderlich: Ja

***<WRAPPING\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zum Umschließen des Schlüssels zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst beim Umschließen des Schlüssels größer als 1 ist.

***<PAYLOAD\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang für den Payload-Schlüssel zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst des Payload-Schlüssels größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-wrap-aes-no-pad-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Umschließen Sie einen Schlüssel mit AES- PKCS5 -PAD mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad"></a>

Verwenden Sie den **key wrap aes-pkcs5-pad** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe eines AES-Schlüssels auf dem Hardware-Sicherheitsmodul (HSM) und dem Wrapping-Mechanismus zu umschließen. `AES-PKCS5-PAD` Das `extractable` Attribut des Payload-Schlüssels muss auf gesetzt sein. `true`

Nur der Besitzer eines Schlüssels, d. h. der Crypto-Benutzer (CU), der den Schlüssel erstellt hat, kann den Schlüssel umschließen. Benutzer, die den Schlüssel gemeinsam nutzen, können den Schlüssel für kryptografische Operationen verwenden.

Um den **key wrap aes-pkcs5-pad** Befehl verwenden zu können, benötigen Sie zunächst einen AES-Schlüssel in Ihrem AWS CloudHSM Cluster. Sie können mithilfe des [Generieren Sie einen symmetrischen AES-Schlüssel mit CloudHSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) Befehls einen AES-Schlüssel für das Umschließen generieren, und das `wrap` Attribut ist auf gesetzt`true`.

## Benutzertyp
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer (CUs)

## Voraussetzungen
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-syntax"></a>

```
aws-cloudhsm > help key wrap aes-pkcs5-pad
Usage: key wrap aes-pkcs5-pad [OPTIONS] --payload-filter [<PAYLOAD_FILTER>...] --wrapping-filter [<WRAPPING_FILTER>...]

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --payload-filter [<PAYLOAD_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a payload key
      --wrapping-filter [<WRAPPING_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a wrapping key
      --path <PATH>
          Path to the binary file where the wrapped key data will be saved
      --wrapping-approval <WRAPPING_APPROVALR>
          File path of signed quorum token file to approve operation for wrapping key
      --payload-approval <PAYLOAD_APPROVALR>
          File path of signed quorum token file to approve operation for payload key
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-examples"></a>

Dieses Beispiel zeigt, wie der **key wrap aes-pkcs5-pad** Befehl mit einem AES-Schlüssel verwendet wird, dessen `wrap` Attributwert auf gesetzt ist`true`.

**Example**  

```
aws-cloudhsm > key wrap aes-pkcs5-pad --payload-filter attr.label=payload-key --wrapping-filter attr.label=aes-example
{
  "error_code": 0,
  "data": {
    "payload_key_reference": "0x00000000001c08f1",
    "wrapping_key_reference": "0x00000000001c08ea",
    "wrapped_key_data": "MbuYNresfOKyGNnxKWen88nSfX+uUE/0qmGofSisicY="
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Payload-Schlüssels“.  
Erforderlich: Ja

***<PATH>***  
Pfad zur Binärdatei, in der die verpackten Schlüsseldaten gespeichert werden.  
Erforderlich: Nein

***<WRAPPING\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Umbruchschlüssels“.   
Erforderlich: Ja

***<WRAPPING\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zum Umschließen des Schlüssels zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst beim Umschließen des Schlüssels größer als 1 ist.

***<PAYLOAD\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang für den Payload-Schlüssel zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst des Payload-Schlüssels größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Einen Schlüssel AES-ZERO-PAD mithilfe der CloudHSM-CLI umschließen
<a name="cloudhsm_cli-key-wrap-aes-zero-pad"></a>

Verwenden Sie den **key wrap aes-zero-pad** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe eines AES-Schlüssels auf dem Hardware-Sicherheitsmodul (HSM) und dem Wrapping-Mechanismus zu umschließen. `AES-ZERO-PAD` Das `extractable` Attribut des Payload-Schlüssels muss auf gesetzt sein. `true`

Nur der Besitzer eines Schlüssels, d. h. der Crypto-Benutzer (CU), der den Schlüssel erstellt hat, kann den Schlüssel umschließen. Benutzer, die den Schlüssel gemeinsam nutzen, können den Schlüssel für kryptografische Operationen verwenden.

Um den **key wrap aes-zero-pad** Befehl verwenden zu können, benötigen Sie zunächst einen AES-Schlüssel in Ihrem AWS CloudHSM Cluster. Mit dem [Generieren Sie einen symmetrischen AES-Schlüssel mit CloudHSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) Befehl, dessen `wrap` Attribut auf gesetzt ist, können Sie einen AES-Schlüssel für das Umschließen generieren`true`.

## Benutzertyp
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer (CUs)

## Voraussetzungen
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-syntax"></a>

```
aws-cloudhsm > help key wrap aes-zero-pad
Usage: key wrap aes-zero-pad [OPTIONS] --payload-filter [<PAYLOAD_FILTER>...] --wrapping-filter [<WRAPPING_FILTER>...]

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --payload-filter [<PAYLOAD_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a payload key
      --wrapping-filter [<WRAPPING_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a wrapping key
      --path <PATH>
          Path to the binary file where the wrapped key data will be saved
      --wrapping-approval <WRAPPING_APPROVALR>
          File path of signed quorum token file to approve operation for wrapping key
      --payload-approval <PAYLOAD_APPROVALR>
          File path of signed quorum token file to approve operation for payload key
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-examples"></a>

Dieses Beispiel zeigt, wie der **key wrap aes-zero-pad ** Befehl mit einem AES-Schlüssel verwendet wird, dessen `wrap` Attributwert auf gesetzt ist`true`.

**Example**  

```
aws-cloudhsm > key wrap aes-zero-pad --payload-filter attr.label=payload-key --wrapping-filter attr.label=aes-example
{
  "error_code": 0,
  "data": {
    "payload_key_reference": "0x00000000001c08f1",
    "wrapping_key_reference": "0x00000000001c08ea",
    "wrapped_key_data": "L1wVlL/YeBNVAw6Mpk3owFJZXBzDLONt"
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Payload-Schlüssels“.  
Erforderlich: Ja

***<PATH>***  
Pfad zur Binärdatei, in der die verpackten Schlüsseldaten gespeichert werden.  
Erforderlich: Nein

***<WRAPPING\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Umbruchschlüssels“.   
Erforderlich: Ja

***<WRAPPING\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zum Umschließen des Schlüssels zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst beim Umschließen des Schlüssels größer als 1 ist.

***<PAYLOAD\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang für den Payload-Schlüssel zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst des Payload-Schlüssels größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Einen Schlüssel CLOUDHSM-AES-GCM mithilfe der CloudHSM-CLI umschließen
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm"></a>

Verwenden Sie den **key wrap cloudhsm-aes-gcm** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe eines AES-Schlüssels auf dem Hardware-Sicherheitsmodul (HSM) und dem Wrapping-Mechanismus zu umschließen. `CLOUDHSM-AES-GCM` Das `extractable` Attribut des Payload-Schlüssels muss auf gesetzt sein. `true`

Nur der Besitzer eines Schlüssels, d. h. der Crypto-Benutzer (CU), der den Schlüssel erstellt hat, kann den Schlüssel umschließen. Benutzer, die den Schlüssel gemeinsam nutzen, können den Schlüssel für kryptografische Operationen verwenden.

Um den **key wrap cloudhsm-aes-gcm** Befehl verwenden zu können, benötigen Sie zunächst einen AES-Schlüssel in Ihrem AWS CloudHSM Cluster. Sie können einen AES-Schlüssel zum Umschließen generieren, indem Sie den [Generieren Sie einen symmetrischen AES-Schlüssel mit CloudHSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) Befehl verwenden und das `wrap` Attribut auf gesetzt haben`true`.

## Benutzertyp
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer (CUs)

## Voraussetzungen
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-syntax"></a>

```
aws-cloudhsm > help key wrap cloudhsm-aes-gcm
Usage: key wrap cloudhsm-aes-gcm [OPTIONS] --payload-filter [<PAYLOAD_FILTER>...] --wrapping-filter [<WRAPPING_FILTER>...] --tag-length-bits <TAG_LENGTH_BITS>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --payload-filter [<PAYLOAD_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a payload key
      --wrapping-filter [<WRAPPING_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a wrapping key
      --path <PATH>
          Path to the binary file where the wrapped key data will be saved
      --wrapping-approval <WRAPPING_APPROVALR>
          File path of signed quorum token file to approve operation for wrapping key
      --payload-approval <PAYLOAD_APPROVALR>
          File path of signed quorum token file to approve operation for payload key
      --aad <AAD>
          Aes GCM Additional Authenticated Data (AAD) value, in hex
      --tag-length-bits <TAG_LENGTH_BITS>
          Aes GCM tag length in bits
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-examples"></a>

Dieses Beispiel zeigt, wie der **key wrap cloudhsm-aes-gcm** Befehl mit einem AES-Schlüssel verwendet wird.

**Example**  

```
aws-cloudhsm > key wrap cloudhsm-aes-gcm --payload-filter attr.label=payload-key --wrapping-filter attr.label=aes-example --tag-length-bits 64 --aad 0x10
{
  "error_code": 0,
  "data": {
    "payload_key_reference": "0x00000000001c08f1",
    "wrapping_key_reference": "0x00000000001c08ea",
    "wrapped_key_data": "6Rn8nkjEriDYlnP3P8nPkYQ8hplOEJ899zsrF+aTB0i/fIlZ"
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Payload-Schlüssels“.  
Erforderlich: Ja

***<PATH>***  
Pfad zur Binärdatei, in der die verpackten Schlüsseldaten gespeichert werden.  
Erforderlich: Nein

***<WRAPPING\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Umbruchschlüssels“.   
Erforderlich: Ja

***<AAD>***  
AES-GCM-Wert für zusätzliche authentifizierte Daten (AAD) in Hexadezimalzahl.   
Erforderlich: Nein

***<TAG\$1LENGTH\$1BITS>***  
Länge des AES-GCM-Tags in Bit.  
Erforderlich: Ja

***<WRAPPING\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zum Umschließen des Schlüssels zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst beim Umschließen des Schlüssels größer als 1 ist.

***<PAYLOAD\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang für den Payload-Schlüssel zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst des Payload-Schlüssels größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Umschließen eines Schlüssels mit RSA-AES mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-wrap-rsa-aes"></a>

Verwenden Sie den **key wrap rsa-aes** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe eines öffentlichen RSA-Schlüssels auf dem Hardware-Sicherheitsmodul (HSM) und dem RSA-AES-Wrapping-Mechanismus zu verpacken. Das Attribut des Payload-Schlüssels muss auf gesetzt sein. `extractable` `true`

Nur der Besitzer eines Schlüssels, d. h. der Crypto-Benutzer (CU), der den Schlüssel erstellt hat, kann den Schlüssel umschließen. Benutzer, die den Schlüssel gemeinsam nutzen, können den Schlüssel für kryptografische Operationen verwenden.

Um den **key wrap rsa-aes** Befehl verwenden zu können, benötigen Sie zunächst einen RSA-Schlüssel in Ihrem AWS CloudHSM Cluster. Sie können ein RSA-Schlüsselpaar mit dem [Die generate-asymmetric-pair Kategorie in CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair.md) Befehl und dem auf `true` gesetzten `wrap` Attribut generieren.

## Benutzertyp
<a name="cloudhsm_cli-key-wrap-rsa-aes-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-key-wrap-rsa-aes-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-wrap-rsa-aes-syntax"></a>

```
aws-cloudhsm > help key wrap rsa-aes
Usage: key wrap rsa-aes [OPTIONS] --payload-filter [<PAYLOAD_FILTER>...] --wrapping-filter [<WRAPPING_FILTER>...] --hash-function <HASH_FUNCTION> --mgf <MGF>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --payload-filter [<PAYLOAD_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a payload key
      --wrapping-filter [<WRAPPING_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a wrapping key
      --path <PATH>
          Path to the binary file where the wrapped key data will be saved
      --wrapping-approval <WRAPPING_APPROVALR>
          File path of signed quorum token file to approve operation for wrapping key
      --payload-approval <PAYLOAD_APPROVALR>
          File path of signed quorum token file to approve operation for payload key
      --hash-function <HASH_FUNCTION>
          Hash algorithm [possible values: sha1, sha224, sha256, sha384, sha512]
      --mgf <MGF>
          Mask Generation Function algorithm [possible values: mgf1-sha1, mgf1-sha224, mgf1-sha256, mgf1-sha384, mgf1-sha512]
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-key-wrap-rsa-aes-examples"></a>

Dieses Beispiel zeigt, wie der **key wrap rsa-ae** Befehl unter Verwendung eines öffentlichen RSA-Schlüssels mit dem `wrap` Attributwert auf `true` verwendet wird.

**Example**  

```
aws-cloudhsm > key wrap rsa-aes --payload-filter attr.label=payload-key --wrapping-filter attr.label=rsa-public-key-example --hash-function sha256 --mgf mgf1-sha256
{
  "error_code": 0,
  "data": {
    "payload-key-reference": "0x00000000001c08f1",
    "wrapping-key-reference": "0x00000000007008da",
    "wrapped-key-data": "HrSE1DEyLjIeyGdPa9R+ebiqB5TIJGyamPker31ZebPwRA+NcerbAJO8DJ1lXPygZcI21vIFSZJuWMEiWpe1R9D/5WSYgxLVKex30xCFqebtEzxbKuv4DOmU4meSofqREYvtb3EoIKwjyxCMRQFgoyUCuP4y0f0eSv0k6rSJh4NuCsHptXZbtgNeRcR4botN7LlzkEIUcq4fVHaatCwd0J1QGKHKyRhkol+RL5WGXKe4nAboAkC5GO7veI5yHL1SaKlssSJtTL/CFpbSLsAFuYbv/NUCWwMY5mwyVTCSlw+HlgKK+5TH1MzBaSi8fpfyepLT8sHy2Q/VRl6ifb49p6m0KQFbRVvz/OWUd6l4d97BdgtaEz6ueg=="
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-wrap-rsa-aes-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Payload-Schlüssels“.  
Erforderlich: Ja

***<PATH>***  
Pfad zur Binärdatei, in der die verpackten Schlüsseldaten gespeichert werden.  
Erforderlich: Nein

***<WRAPPING\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Umbruchschlüssels“.   
Erforderlich: Ja

***<MGF>***  
Gibt die Funktion zur Maskengenerierung an.  
Die Hash-Funktion der Maskengenerierungsfunktion muss mit der Hash-Funktion des Signaturmechanismus übereinstimmen.
Zulässige Werte  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Erforderlich: Ja

***<WRAPPING\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zum Umschließen des Schlüssels zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst beim Umschließen des Schlüssels größer als 1 ist.

***<PAYLOAD\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang für den Payload-Schlüssel zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst des Payload-Schlüssels größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-wrap-rsa-aes-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Umschließen eines Schlüssels mit RSA-OAEP mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-wrap-rsa-oaep"></a>

Verwenden Sie den **key wrap rsa-oaep** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe eines öffentlichen RSA-Schlüssels auf dem Hardware-Sicherheitsmodul (HSM) und dem Wrapping-Mechanismus zu verpacken. `RSA-OAEP` Das Attribut des Payload-Schlüssels `extractable` muss auf gesetzt sein. `true`

Nur der Besitzer eines Schlüssels, d. h. der Crypto-Benutzer (CU), der den Schlüssel erstellt hat, kann den Schlüssel umschließen. Benutzer, die den Schlüssel gemeinsam nutzen, können den Schlüssel für kryptografische Operationen verwenden.

Um den **key wrap rsa-oaep** Befehl verwenden zu können, benötigen Sie zunächst einen RSA-Schlüssel in Ihrem AWS CloudHSM Cluster. Sie können ein RSA-Schlüsselpaar generieren, indem Sie den [Die generate-asymmetric-pair Kategorie in CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair.md) Befehl verwenden und das `wrap` Attribut auf `true` setzen.

## Benutzertyp
<a name="cloudhsm_cli-key-unwrap-rsa-aes-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-key-unwrap-rsa-aes-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-unwrap-rsa-aes-syntax"></a>

```
aws-cloudhsm > help key wrap rsa-oaep
Usage: key wrap rsa-oaep [OPTIONS] --payload-filter [<PAYLOAD_FILTER>...] --wrapping-filter [<WRAPPING_FILTER>...] --hash-function <HASH_FUNCTION> --mgf <MGF>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --payload-filter [<PAYLOAD_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a payload key
      --wrapping-filter [<WRAPPING_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a wrapping key
      --path <PATH>
          Path to the binary file where the wrapped key data will be saved
      --wrapping-approval <WRAPPING_APPROVALR>
          File path of signed quorum token file to approve operation for wrapping key
      --payload-approval <PAYLOAD_APPROVALR>
          File path of signed quorum token file to approve operation for payload key
      --hash-function <HASH_FUNCTION>
          Hash algorithm [possible values: sha1, sha224, sha256, sha384, sha512]
      --mgf <MGF>
          Mask Generation Function algorithm [possible values: mgf1-sha1, mgf1-sha224, mgf1-sha256, mgf1-sha384, mgf1-sha512]
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-key-unwrap-rsa-aes-examples"></a>

Dieses Beispiel zeigt, wie der **key wrap rsa-oaep** Befehl unter Verwendung eines öffentlichen RSA-Schlüssels mit dem `wrap` Attributwert auf `true` verwendet wird.

**Example**  

```
aws-cloudhsm > key wrap rsa-oaep --payload-filter attr.label=payload-key --wrapping-filter attr.label=rsa-public-key-example --hash-function sha256 --mgf mgf1-sha256
{
  "error_code": 0,
  "data": {
    "payload-key-reference": "0x00000000001c08f1",
    "wrapping-key-reference": "0x00000000007008da",
    "wrapped-key-data": "OjJe4msobPLz9TuSAdULEu17T5rMDWtSlLyBSkLbaZnYzzpdrhsbGLbwZJCtB/jGkDNdB4qyTAOQwEpggGf6v+Yx6JcesNeKKNU8XZal/YBoHC8noTGUSDI2qr+u2tDc84NPv6d+F2KOONXsSxMhmxzzNG/gzTVIJhOuy/B1yHjGP4mOXoDZf5+7f5M1CjxBmz4Vva/wrWHGCSG0yOaWblEvOiHAIt3UBdyKmU+/My4xjfJv7WGGu3DFUUIZ06TihRtKQhUYU1M9u6NPf9riJJfHsk6QCuSZ9yWThDT9as6i7e3htnyDhIhGWaoK8JU855cN/YNKAUqkNpC4FPL3iw=="
  }
}
```

## Argumente
<a name="cloudhsm_cli-key-unwrap-rsa-aes-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Payload-Schlüssels“.  
Erforderlich: Ja

***<PATH>***  
Pfad zur Binärdatei, in der die verpackten Schlüsseldaten gespeichert werden.  
Erforderlich: Nein

***<WRAPPING\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Umbruchschlüssels“.   
Erforderlich: Ja

***<MGF>***  
Gibt die Funktion zur Maskengenerierung an.  
Die Hash-Funktion der Maskengenerierungsfunktion muss mit der Hash-Funktion des Signaturmechanismus übereinstimmen.
Zulässige Werte  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Erforderlich: Ja

***<WRAPPING\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zum Umschließen des Schlüssels zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst beim Umschließen des Schlüssels größer als 1 ist.

***<PAYLOAD\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang für den Payload-Schlüssel zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst des Payload-Schlüssels größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-unwrap-rsa-aes-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Umschließen eines Schlüssels mit RSA-PKCS mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-key-wrap-rsa-pkcs"></a>

Verwenden Sie den **key wrap rsa-pkcs** Befehl in der CloudHSM-CLI, um einen Payload-Schlüssel mithilfe eines öffentlichen RSA-Schlüssels auf dem Hardware-Sicherheitsmodul (HSM) und dem Wrapping-Mechanismus zu verpacken. `RSA-PKCS` Das Attribut des Payload-Schlüssels `extractable` muss auf gesetzt sein. `true`

Nur der Besitzer eines Schlüssels, d. h. der Crypto-Benutzer (CU), der den Schlüssel erstellt hat, kann den Schlüssel umschließen. Benutzer, die den Schlüssel gemeinsam nutzen, können den Schlüssel für kryptografische Operationen verwenden.

Um den **key wrap rsa-pkcs** Befehl verwenden zu können, benötigen Sie zunächst einen RSA-Schlüssel in Ihrem AWS CloudHSM Cluster. Sie können ein RSA-Schlüsselpaar mit dem [Die generate-asymmetric-pair Kategorie in CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair.md) Befehl und dem auf `true` gesetzten `wrap` Attribut generieren.

## Benutzertyp
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Crypto-Benutzer () CUs

## Voraussetzungen
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-requirements"></a>
+ Um diesen Befehl auszuführen, müssen Sie als CU angemeldet sein.

## Syntax
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-syntax"></a>

```
aws-cloudhsm > help key wrap rsa-pkcs
Usage: key wrap rsa-pkcs [OPTIONS] --payload-filter [<PAYLOAD_FILTER>...] --wrapping-filter [<WRAPPING_FILTER>...]

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --payload-filter [<PAYLOAD_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a payload key
      --wrapping-filter [<WRAPPING_FILTER>...]
          Key reference (e.g. key-reference=0xabc) or space separated list of key attributes in the form of attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE to select a wrapping key
      --path <PATH>
          Path to the binary file where the wrapped key data will be saved
      --wrapping-approval <WRAPPING_APPROVALR>
          File path of signed quorum token file to approve operation for wrapping key
      --payload-approval <PAYLOAD_APPROVALR>
          File path of signed quorum token file to approve operation for payload key
  -h, --help
          Print help
```

## Beispiel
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-examples"></a>

Dieses Beispiel zeigt, wie der **key wrap rsa-pkcs** Befehl mit einem öffentlichen RSA-Schlüssel verwendet wird.

**Example**  

```
aws-cloudhsm > key wrap rsa-pkcs --payload-filter attr.label=payload-key --wrapping-filter attr.label=rsa-public-key-example
{
  "error_code": 0,
  "data": {
    "payload_key_reference": "0x00000000001c08f1",
    "wrapping_key_reference": "0x00000000007008da",
    "wrapped_key_data": "am0Nc7+YE8FWs+5HvU7sIBcXVb24QA0l65nbNAD+1bK+e18BpSfnaI3P+r8Dp+pLu1ofoUy/vtzRjZoCiDofcz4EqCFnGl4GdcJ1/3W/5WRvMatCa2d7cx02swaeZcjKsermPXYRO1lGlfq6NskwMeeTkV8R7Rx9artFrs1y0DdIgIKVaiFHwnBIUMnlQrR2zRmMkfwU1jxMYmOYyD031F5VbnjSrhfMwkww2la7uf/c3XdFJ2+0Bo94c6og/yfPcpOOobJlITCoXhtMRepSdO4OggYq/6nUDuHCtJ86pPGnNahyr7+sAaSI3a5ECQLUjwaIARUCyoRh7EFK3qPXcg=="
  }
```

## Argumente
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Payload-Schlüssels“.  
Erforderlich: Ja

***<PATH>***  
Pfad zur Binärdatei, in der die verpackten Schlüsseldaten gespeichert werden.  
Erforderlich: Nein

***<WRAPPING\$1FILTER>***  
Schlüsselreferenz (z. B.`key-reference=0xabc`) oder durch Leerzeichen getrennte Liste von Schlüsselattributen in der Form „`attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE`Zur Auswahl eines Umbruchschlüssels“.   
Erforderlich: Ja

***<WRAPPING\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zum Umschließen des Schlüssels zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst beim Umschließen des Schlüssels größer als 1 ist.

***<PAYLOAD\$1APPROVALR>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang für den Payload-Schlüssel zu genehmigen. Nur erforderlich, wenn der Quorumwert für den Schlüsselverwaltungsdienst des Payload-Schlüssels größer als 1 ist.

## Verwandte Themen
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-seealso"></a>
+ [Der Key Wrap-Befehl in der CloudHSM-CLI](cloudhsm_cli-key-wrap.md)
+ [Der Befehl zum Entpacken von Schlüsseln in der CloudHSM-CLI](cloudhsm_cli-key-unwrap.md)

# Melden Sie sich mit der CloudHSM-CLI bei einem HSM an
<a name="cloudhsm_cli-login"></a>

Sie können den **login** Befehl in der CloudHSM-CLI verwenden, um sich bei jedem Hardware Security (HSM) in einem Cluster an- und abzumelden. AWS CloudHSM Dieser Befehl hat den folgenden Unterbefehl:
+ [mfa-token-sign](cloudhsm_cli-login-mfa-token-sign.md)

**Anmerkung**  
Wenn Sie mehr als fünf falsche Anmeldeversuche tätigen, wird Ihr Konto gesperrt. Um das Konto zu entsperren, muss ein Administrator Ihr Passwort mit dem Befehl [user change-password](cloudhsm_cli-user-change-password.md) in cloudhsm\$1cli zurücksetzen.

## Um Probleme bei der An- und Abmeldung zu beheben
<a name="troubleshoot-login-logout"></a>

Wenn Sie mehr als ein HSM in Ihrem Cluster haben, sind Ihnen möglicherweise weitere falsche Anmeldeversuche gestattet, bevor Ihr Konto gesperrt wird. Dies liegt daran, dass der CloudHSM-Client die Last auf verschiedene verteilt. HSMs Aus diesem Grund beginnt der Anmeldeversuch möglicherweise nicht jedes Mal auf demselben HSM. Wenn Sie diese Funktion testen, empfehlen wir Ihnen, dies auf einem Cluster mit nur einem aktiven HSM zu tun. 

Wenn Sie Ihren Cluster vor Februar 2018 erstellt haben, wird Ihr Konto nach 20 falschen Anmeldeversuchen gesperrt. 

## Benutzertyp
<a name="chsm-cli-login-logout-userType"></a>

Die folgenden Benutzer können diese Befehle ausführen.
+ Nicht aktivierter Admin
+ Admin.
+ Crypto-Benutzer (Crypto User, CU)

## Syntax
<a name="chsm-cli-login-syntax"></a>

```
aws-cloudhsm > help login
Login to your cluster  
        
USAGE:
    cloudhsm-cli login [OPTIONS] --username <USERNAME> --role <ROLE> [COMMAND]
    
Commands:
  mfa-token-sign  Login with token-sign mfa
  help            Print this message or the help of the given subcommand(s)

OPTIONS:
        --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error

        --username <USERNAME>
            Username to access the Cluster
        
        --role <ROLE>
            Role the user has in the Cluster
            
           Possible values:
           - crypto-user: A CryptoUser has the ability to manage and use keys
           - admin:       An Admin has the ability to manage user accounts

        --password <PASSWORD>
           Optional: Plaintext user's password. If you do not include this argument you will be prompted for it

  -h, --help
          Print help (see a summary with '-h')
```

## Beispiel
<a name="chsm-cli-login-example"></a>

**Example**  
Mit diesem Befehl melden Sie sich bei all HSMs in einem Cluster mit den Anmeldeinformationen eines Admin-Benutzers mit dem Namen an. `admin1`  

```
aws-cloudhsm > login --username admin1 --role admin
Enter password:
{
  "error_code": 0,
  "data": {
    "username": "admin1",
    "role": "admin"
  }
}
```

## Argumente
<a name="login-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<USERNAME>***  
Gibt einen Anzeigenamen für den Benutzer an. Die maximale Länge beträgt 31 Zeichen. Das einzige zulässige Sonderzeichen ist ein Unterstrich (\$1). Beim Benutzernamen wird in diesem Befehl nicht zwischen Groß- und Kleinschreibung unterschieden, der Benutzername wird immer in Kleinbuchstaben angezeigt.  
Erforderlich: Ja

***<ROLE>***  
Gibt die diesem Benutzer zugewiesene Rolle an. Gültige Werte sind **admin**, **crypto-user**.  
Verwenden Sie den **user list** Befehl, um die Rolle des Benutzers abzurufen. Ausführliche Informationen zu den Benutzertypen in einem HSM finden Sie unter [HSM-Benutzer verstehen](manage-hsm-users.md).  
Erforderlich: Ja

***<PASSWORD>***  
Gibt das Passwort des Benutzers an, der sich bei der anmeldet HSMs.  
Erforderlich: Kunden müssen das Passwort entweder über das `--password` Befehlszeilenargument angeben oder es weglassen, damit es interaktiv abgefragt wird.  
Wenn Sie das `--password` Argument in der Befehlszeile verwenden, werden möglicherweise Anmeldeinformationen in Ihrem Shell-Verlauf angezeigt. Erwägen Sie, das Passwort interaktiv einzugeben oder Ihren Shell-Verlauf nach der Verwendung zu löschen.

## Verwandte Themen
<a name="login-seeAlso"></a>
+ [Erste Schritte mit CloudHSM-CLI](cloudhsm_cli-getting-started.md)
+ [Aktivieren des Clusters](activate-cluster.md)

# Melden Sie sich mit MFA über die CloudHSM-CLI bei einem HSM an
<a name="cloudhsm_cli-login-mfa-token-sign"></a>

Verwenden Sie den **login mfa-token-sign** Befehl in der AWS CloudHSM CloudHSM-CLI, um sich mithilfe der Multi-Faktor-Authentifizierung (MFA) bei einem Hardware-Sicherheitsmodul (HSM) anzumelden. Um diesen Befehl verwenden zu können, müssen Sie zuerst [MFA für CloudHSM-CLI](login-mfa-token-sign.md) einrichten.

## Benutzertyp
<a name="cloudhsm_cli-login-mfa-token-userType"></a>

Die folgenden Benutzer können diese Befehle ausführen.
+ Admin.
+ Crypto-Benutzer (Crypto User, CU)

## Syntax
<a name="cloudhsm_cli-login-mfa-token-syntax"></a>

```
aws-cloudhsm > help login mfa-token-sign
Login with token-sign mfa

USAGE:
    login --username <username> --role <role> mfa-token-sign --token <token>

OPTIONS:
      --cluster-id <CLUSTER_ID>  Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --token <TOKEN>            Filepath where the unsigned token file will be written
  -h, --help                     Print help
```

## Beispiel
<a name="cloudhsm_cli-login-mfa-token-example"></a>

**Example**  

```
aws-cloudhsm > login --username test_user --role admin mfa-token-sign --token /home/valid.token
Enter password:
Enter signed token file path (press enter if same as the unsigned token file):
{
  "error_code": 0,
  "data": {
    "username": "test_user",
    "role": "admin"
  }
}
```

## Argumente
<a name="cloudhsm_cli-login-mfa-token-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<TOKEN>***  
Dateipfad, in den die unsignierte Tokendatei geschrieben wird.  
Erforderlich: Ja

## Verwandte Themen
<a name="cloudhsm_cli-login-mfa-token-seeAlso"></a>
+ [Erste Schritte mit CloudHSM-CLI](cloudhsm_cli-getting-started.md)
+ [Aktivieren des Clusters](activate-cluster.md)
+ [Verwenden von CloudHSM-CLI zur Verwaltung von MFA](login-mfa-token-sign.md)

# Melden Sie sich mit der CloudHSM-CLI von einem HSM ab
<a name="cloudhsm_cli-logout"></a>

Verwenden Sie den **logout** Befehl in der CloudHSM-CLI, um sich von jedem Hardware-Sicherheitsmodul (HSM) in einem Cluster abzumelden. AWS CloudHSM 

## Benutzertyp
<a name="chsm-cli-logout-userType"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Admin.
+ Crypto-Benutzer (Crypto User, CU)

## Syntax
<a name="chsm-cli-logout-syntax"></a>

```
aws-cloudhsm > help logout
Logout of your cluster

USAGE:
    logout

OPTIONS:
        --cluster-id <CLUSTER_ID> Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
    -h, --help                    Print help information
    -V, --version                 Print version information
```

## Beispiel
<a name="chsm-cli-logout-example"></a>

**Example**  
Mit diesem Befehl werden Sie von allen Clustern abgemeldet HSMs .  

```
aws-cloudhsm > logout
{
  "error_code": 0,
  "data": "Logout successful"
}
```

## Verwandte Themen
<a name="logout-seeAlso"></a>
+ [Erste Schritte mit CloudHSM-CLI](cloudhsm_cli-getting-started.md)
+ [Aktivieren des Clusters](activate-cluster.md)

# Die Benutzerkategorie in CloudHSM CLI
<a name="cloudhsm_cli-user"></a>

In der CloudHSM-CLI **user** ist dies eine übergeordnete Kategorie für eine Gruppe von Befehlen, die in Kombination mit der übergeordneten Kategorie einen benutzerspezifischen Befehl erstellen. Derzeit besteht die Benutzerkategorie aus den folgenden Befehlen:
+ [user change-mfa](cloudhsm_cli-user-change-mfa.md)
+ [user change-password](cloudhsm_cli-user-change-password.md)
+ [user create](cloudhsm_cli-user-create.md)
+ [user delete](cloudhsm_cli-user-delete.md)
+ [user list](cloudhsm_cli-user-list.md)
+ [Benutzer replizieren](cloudhsm_cli-user-replicate.md)

# Die Kategorie „user change-mfa“ in der CloudHSM-CLI
<a name="cloudhsm_cli-user-change-mfa"></a>

In der CloudHSM-CLI **user change-mfa** ist dies eine übergeordnete Kategorie für eine Gruppe von Befehlen, die in Kombination mit der übergeordneten Kategorie einen Befehl erstellen, der speziell für die Änderung der Multi-Faktor-Authentifizierung (MFA) für Benutzer spezifisch ist.

Derzeit besteht diese Kategorie aus dem folgenden Unterbefehl:
+ [token-sign](cloudhsm_cli-user-change-mfa-token-sign.md)

# Ändern Sie das MFA-Setup eines Benutzers mit der CloudHSM CLI
<a name="cloudhsm_cli-user-change-mfa-token-sign"></a>

Verwenden Sie den **user change-mfa token-sign** Befehl in der CloudHSM-CLI, um die Einrichtung der Multi-Faktor-Authentifizierung (MFA) eines Benutzerkontos zu aktualisieren. Jedes Benutzerkonto kann diesen Befehl ausführen. Konten mit der Administratorrolle können diesen Befehl für andere Benutzer ausführen.

## Benutzertyp
<a name="user-change-mfa-type"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Admin.
+ Crypto-Benutzer

## Syntax
<a name="user-change-mfa-syntax"></a>

Derzeit steht Benutzern nur eine einzige Multi-Faktor-Strategie zur Verfügung: Token Sign.

```
aws-cloudhsm > help user change-mfa
Change a user's Mfa Strategy

Usage:
    user change-mfa <COMMAND>
  
Commands:
  token-sign  Register or Deregister a public key using token-sign mfa strategy
  help        Print this message or the help of the given subcommand(s)
```

Die Token-Sign-Strategie verlangt nach einer Token-Datei, in die unsignierte Token geschrieben werden sollen.

```
aws-cloudhsm > help user change-mfa token-sign
Register or Deregister a public key using token-sign mfa strategy

Usage: user change-mfa token-sign [OPTIONS] --username <USERNAME> --role <ROLE> <--token <TOKEN>|--deregister>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error

      --username <USERNAME>
          Username of the user that will be modified

      --role <ROLE>
          Role the user has in the cluster

          Possible values:
          - crypto-user: A CryptoUser has the ability to manage and use keys
          - admin:       An Admin has the ability to manage user accounts

      --change-password <CHANGE_PASSWORD>
          Optional: Plaintext user's password. If you do not include this argument you will be prompted for it

      --token <TOKEN>
          Filepath where the unsigned token file will be written. Required for enabling MFA for a user

      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation

      --deregister
          Deregister the MFA public key, if present

      --change-quorum
          Change the Quorum public key along with the MFA key

  -h, --help
          Print help (see a summary with '-h')
```

## Beispiel
<a name="user-change-mfa-examples"></a>

Dieser Befehl schreibt ein unsigniertes Token pro HSM in Ihrem Cluster in die von `token` angegebene Datei. Signieren Sie die Token in der Datei, wenn Sie dazu aufgefordert werden.

**Example : Schreiben Sie ein unsigniertes Token pro HSM in Ihr Cluster**  

```
aws-cloudhsm > user change-mfa token-sign --username cu1 --change-password password --role crypto-user --token /path/myfile
Enter signed token file path (press enter if same as the unsigned token file):
Enter public key PEM file path:/path/mypemfile
{
  "error_code": 0,
  "data": {
    "username": "test_user",
    "role": "admin"
  }
}
```

### Argumente
<a name="user-change-mfa-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<ROLE>***  
Gibt die Rolle an, die dem Benutzerkonto zugewiesen wurde. Dieser Parameter muss angegeben werden. Ausführliche Informationen zu den Benutzertypen in einem HSM finden Sie unter [HSM-Benutzer verstehen](manage-hsm-users.md).  
**Zulässige Werte**  
+ **Admin**: Administratoren können Benutzer verwalten, aber sie können keine Schlüssel verwalten.
+ **Crypto-Benutzer**: Crypto-Benutzer können Schlüssel erstellen und verwalten und Schlüssel in kryptografischen Vorgängen verwenden.

***<USERNAME>***  
Gibt einen Anzeigenamen für den Benutzer an. Die maximale Länge beträgt 31 Zeichen. Das einzige zulässige Sonderzeichen ist ein Unterstrich (\$1).  
Sie können den Namen eines Benutzers nach der Erstellung nicht mehr ändern. Bei CloudHSM-CLI-Befehlen wird bei der Rolle und dem Passwort zwischen Groß- und Kleinschreibung unterschieden, beim Benutzernamen jedoch nicht.  
**Erforderlich**: Ja

***<CHANGE\$1PASSWORD>***  
Gibt das neue Klartext-Passwort des Benutzers an, dessen MFA registriert/deregistriert wird.  
**Erforderlich**: Ja

***<TOKEN>***  
Dateipfad, in den die unsignierte Tokendatei geschrieben wird.  
**Erforderlich**: Ja

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Quorum-Benutzerdienstes größer als 1 ist.

***<DEREGISTER>***  
Deregistriert den öffentlichen MFA-Schlüssel, falls vorhanden.

***<CHANGE-QUORUM>***  
Ändert den öffentlichen Quorum-Schlüssel zusammen mit dem MFA-Schlüssel.

## Verwandte Themen
<a name="user-change-mfa-seealso"></a>
+ [2FA für HSM-Benutzer verstehen](login-mfa-token-sign.md)

# Ändern Sie das Passwort eines Benutzers mit CloudHSM CLI
<a name="cloudhsm_cli-user-change-password"></a>

Verwenden Sie den **user change-password** Befehl in der CloudHSM-CLI, um das Passwort eines vorhandenen Benutzers in Ihrem AWS CloudHSM Cluster zu ändern. Verwenden Sie den `user change-mfa`-Befehl, um MFA für einen Benutzer zu aktivieren.

Jeder Benutzer kann das eigene Passwort ändern. Darüber hinaus können Benutzer mit der Administratorrolle das Passwort eines anderen Benutzers im Cluster ändern. Sie müssen das aktuelle Passwort nicht eingeben, um die Änderung vorzunehmen.

**Anmerkung**  
Sie können jedoch nicht das Passwort eines Benutzers ändern, der beim Cluster oder angemeldet ist.

## Benutzertyp
<a name="change-password-user-type"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Admin.
+ Crypto-Benutzer (Crypto User, CU)

## Syntax
<a name="change-password-syntax"></a>

**Anmerkung**  
 Verwenden Sie den Befehl, um die Multi-Faktor-Authentifizierung (MFA) für einen Benutzer zu aktivieren. **user change-mfa**

```
aws-cloudhsm > help user change-password
Change a user's password

    Usage:
        cloudhsm-cli user change-password [OPTIONS] --username <USERNAME> --role <ROLE> [--password <PASSWORD>]
    
    Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error

      --username <USERNAME>
          Username of the user that will be modified

      --role <ROLE>
          Role the user has in the cluster

          Possible values:
          - crypto-user: A CryptoUser has the ability to manage and use keys
          - admin:       An Admin has the ability to manage user accounts

      --password <PASSWORD>
          Optional: Plaintext user's password. If you do not include this argument you will be prompted for it

      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
          
      --deregister-mfa <DEREGISTER-MFA>
          Deregister the user's mfa public key, if present
          
      --deregister-quorum <DEREGISTER-QUORUM>
          Deregister the user's quorum public key, if present
 -h, --help
          Print help (see a summary with '-h')
```

## Beispiel
<a name="change-password-examples"></a>

Die folgenden Beispiele zeigen, wie Sie mit **user change-password** das Passwort für den aktuellen Benutzer oder einen anderen Benutzer in Ihrem Cluster zurücksetzen können.

**Example : Ändert Ihr Passwort**  
Jeder Benutzer im Cluster kann mit **user change-password** sein eigenes Passwort ändern.  
Die folgende Ausgabe zeigt, dass Bob derzeit als CU angemeldet ist.  

```
aws-cloudhsm > user change-password --username bob --role crypto-user
Enter password:
Confirm password:
{
  "error_code": 0,
  "data": {
    "username": "bob",
    "role": "crypto-user"
  }
}
```

## Argumente
<a name="change-password-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Quorum-Benutzerdienstes größer als 1 ist.

***<DEREGISTER-MFA>***  
Deregistriert den öffentlichen MFA-Schlüssel, falls vorhanden.

***<DEREGISTER-QUORUM>***  
Zum Deregistrieren des öffentlichen Quorum-Schlüssels, falls vorhanden.

***<PASSWORD>***  
Gibt das neue Klartext-Passwort des Benutzers an. Die folgenden Zeichen ':' sind nicht zulässig  
**Erforderlich**: Ja

***<ROLE>***  
Gibt die Rolle an, die dem Benutzerkonto zugewiesen wurde. Dieser Parameter muss angegeben werden. Ausführliche Informationen zu den Benutzertypen in einem HSM finden Sie unter [HSM-Benutzer verstehen](manage-hsm-users.md).  
**Zulässige Werte**  
+ **Admin**: Administratoren können Benutzer verwalten, aber sie können keine Schlüssel verwalten.
+ **Crypto-Benutzer**: Crypto-Benutzer können Schlüssel erstellen und verwalten und Schlüssel in kryptografischen Vorgängen verwenden.

***<USERNAME>***  
Gibt einen Anzeigenamen für den Benutzer an. Die maximale Länge beträgt 31 Zeichen. Das einzige zulässige Sonderzeichen ist ein Unterstrich (\$1).  
Sie können den Namen eines Benutzers nach der Erstellung nicht mehr ändern. Bei CloudHSM-CLI-Befehlen wird bei der Rolle und dem Passwort zwischen Groß- und Kleinschreibung unterschieden, beim Benutzernamen jedoch nicht.  
**Erforderlich**: Ja

## Verwandte Themen
<a name="change-password-seealso"></a>
+ [user list](cloudhsm_cli-user-list.md)
+ [user create](cloudhsm_cli-user-create.md)
+ [user delete](cloudhsm_cli-user-delete.md)

# Die Kategorie „Benutzeränderungsquorum“ in der CloudHSM-CLI
<a name="cloudhsm_cli-user-chqm"></a>

In der CloudHSM-CLI **user change-quorum** ist dies eine übergeordnete Kategorie für eine Gruppe von Befehlen, die in Kombination mit der übergeordneten Kategorie einen Befehl erstellen, der spezifisch für die Änderung des Quorums für Benutzer ist.

**user change-quorum** wird verwendet, um die Benutzerquorumauthentifizierung mithilfe einer bestimmten Quorumstrategie zu registrieren. Ab SDK 5.8.0 steht Benutzern nur eine einzige Quorumstrategie zur Verfügung, wie unten dargestellt.

Derzeit besteht diese Kategorie aus der folgenden Kategorie und dem folgenden Unterbefehl:
+ [token-sign](cloudhsm_cli-user-chqm-token.md)
  + [register](cloudhsm_cli-user-chqm-token-reg.md)

# Die Kategorie Change-Quorum-Token-Sign-Zeichen für Benutzer in der CloudHSM-CLI
<a name="cloudhsm_cli-user-chqm-token"></a>

In der CloudHSM-CLI **user change-quorum token-sign** ist dies eine übergeordnete Kategorie für Befehle, die in Kombination mit dieser übergeordneten Kategorie einen Befehl erstellen, der spezifisch für Tokensign-Quorumoperationen ist.

Derzeit besteht diese Kategorie aus den folgenden Befehlen:
+ [register](cloudhsm_cli-user-chqm-token-reg.md)

# Registrieren Sie die Token-Sign-Quorum-Strategie eines Benutzers mithilfe der CloudHSM-CLI
<a name="cloudhsm_cli-user-chqm-token-reg"></a>

Verwenden Sie den **user change-quorum token-sign register**-Befehl in der CloudHSM-CLI, um die Token-Sign-Quorumstrategie für einen Admin-Benutzer zu registrieren.

## Benutzertyp
<a name="token-register-user-type"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Admin.

## Syntax
<a name="token-register-syntax"></a>

```
aws-cloudhsm > help user change-quorum token-sign register
Register a user for quorum authentication with a public key

Usage: user change-quorum token-sign register --public-key <PUBLIC_KEY> --signed-token <SIGNED_TOKEN>

Options:
      --cluster-id <CLUSTER_ID>      Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
      --public-key <PUBLIC_KEY>      Filepath to public key PEM file
      --signed-token <SIGNED_TOKEN>  Filepath with token signed by user private key
  -h, --help Print help (see a summary with '-h')
```

## Beispiel
<a name="token-register-examples"></a>

**Example**  
Um diesen Befehl auszuführen, müssen Sie als der Benutzer angemeldet sein, für den Sie **register quorum token-sign** wollen.  

```
aws-cloudhsm > login --username admin1 --role admin
Enter password:
{
  "error_code": 0,
  "data": {
    "username": "admin1",
    "role": "admin"
  }
}
```
Der **user change-quorum token-sign register**-Befehl registriert Ihren öffentlichen Schlüssel beim HSM. Dadurch qualifizieren Sie sich als Quorum-Genehmiger für Quorum-Operationen, bei denen ein Benutzer Quorumsignaturen einholen muss, um den erforderlichen Quorumschwellenwert zu erreichen.  

```
aws-cloudhsm > user change-quorum token-sign register \
    --public-key /home/mypemfile \
    --signed-token /home/mysignedtoken
{
  "error_code": 0,
  "data": {
    "username": "admin1",
    "role": "admin"
  }
}
```
Sie können jetzt den **user list**-Befehl ausführen und bestätigen, dass das Quorum-token-sign für diesen Benutzer registriert wurde.  

```
aws-cloudhsm > user list
{
  "error_code": 0,
  "data": {
    "users": [
      {
        "username": "admin",
        "role": "admin",
        "locked": "false",
        "mfa": [],
        "quorum": [],
        "cluster-coverage": "full"
      },
      {
        "username": "admin1",
        "role": "admin",
        "locked": "false",
        "mfa": [],
        "quorum": [
          {        
            "strategy": "token-sign",
            "status": "enabled"
          }
        ],
        "cluster-coverage": "full"
      }
    ]
  }
}
```

## Argumente
<a name="token-register-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<PUBLIC-KEY>***  
Dateipfad zur PEM-Datei mit öffentlichem Schlüssel.  
**Erforderlich**: Ja

***<SIGNED-TOKEN>***  
Dateipfad mit Token, das mit dem privaten Schlüssel des Benutzers signiert wurde.  
**Erforderlich**: Ja

## Verwandte Themen
<a name="token-register-seealso"></a>
+ [Verwenden der CloudHSM-CLI zur Verwaltung der Quorum-Authentifizierung](quorum-auth-chsm-cli.md)
+ [Quorum-Authentifizierung für Admins verwenden: erstmalige Einrichtung](quorum-auth-chsm-cli-first-time.md)
+ [Ändern Sie den Quorum-Mindestwert für Administratoren](quorum-auth-chsm-cli-min-value.md)
+ [Namen und Typen von Diensten, die die Quorum-Authentifizierung unterstützen](quorum-auth-chsm-cli-service-names.md)

# Einen AWS CloudHSM Benutzer mit CloudHSM CLI erstellen
<a name="cloudhsm_cli-user-create"></a>

Der **user create** Befehl in der CloudHSM-CLI erstellt einen Benutzer in Ihrem AWS CloudHSM Cluster. Nur Benutzerkonten mit der Administratorrolle können diesen Befehl ausführen.

## Benutzertyp
<a name="user-create-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Admin.

## Voraussetzungen
<a name="user-create-requirements"></a>

Um diesen Befehl auszuführen, müssen Sie als Admin-Benutzer angemeldet sein

## Syntax
<a name="user-create-syntax"></a>

```
aws-cloudhsm > help user create
Create a new user

Usage: cloudhsm-cli user create [OPTIONS] --username <USERNAME> --role <ROLE> [--password <PASSWORD>]

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error

      --username <USERNAME>
          Username to access the HSM cluster

      --role <ROLE>
          Role the user has in the cluster

          Possible values:
          - crypto-user: A CryptoUser has the ability to manage and use keys
          - admin:       An Admin has the ability to manage user accounts

      --password <PASSWORD>
          Optional: Plaintext user's password. If you do not include this argument you will be prompted for it

      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation

  -h, --help
          Print help (see a summary with '-h')
```

## Beispiel
<a name="user-create-examples"></a>

Diese Beispiele zeigen, wie Sie **user create** neue Benutzer in Ihrem erstellen können. HSMs

**Example : Erstellen eines Crypto-Benutzers**  
In diesem Beispiel wird in Ihrem AWS CloudHSM Cluster ein Konto mit der Crypto-Benutzerrolle erstellt.  

```
aws-cloudhsm > user create --username alice --role crypto-user
Enter password:
Confirm password:
{
  "error_code": 0,
  "data": {
    "username": "alice",
    "role": "crypto-user"
  }
}
```

## Argumente
<a name="user-create-arguments"></a>

*<CLUSTER\$1ID>*  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

*<USERNAME>*  
Gibt einen Anzeigenamen für den Benutzer an. Die maximale Länge beträgt 31 Zeichen. Das einzige zulässige Sonderzeichen ist ein Unterstrich (\$1). Beim Benutzernamen wird in diesem Befehl nicht zwischen Groß- und Kleinschreibung unterschieden, der Benutzername wird immer in Kleinbuchstaben angezeigt.  
Erforderlich: Ja

*<ROLE>*  
Gibt die diesem Benutzer zugewiesene Rolle an. Dieser Parameter muss angegeben werden. Gültige Werte sind **admin**, **crypto-user**.  
Verwenden Sie den **user list**-Befehl, um die Rolle des Benutzers abzurufen. Ausführliche Informationen zu den Benutzertypen in einem HSM finden Sie unter [HSM-Benutzer verstehen](manage-hsm-users.md).

*<PASSWORD>*  
Gibt das Passwort des Benutzers an, der sich bei der anmeldet HSMs. Die folgenden Zeichen sind nicht zulässig ':'  
Erforderlich: Ja

*<APPROVAL>*  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Quorum-Benutzerdienstes größer als 1 ist.

## Verwandte Themen
<a name="user-create-seealso"></a>
+ [user list](cloudhsm_cli-user-list.md)
+ [user delete](cloudhsm_cli-user-delete.md)
+ [user change-password](cloudhsm_cli-user-change-password.md)

# Löschen Sie einen AWS CloudHSM Benutzer mit CloudHSM CLI
<a name="cloudhsm_cli-user-delete"></a>

Der **user delete** Befehl in der CloudHSM-CLI löscht einen Benutzer aus Ihrem Cluster. AWS CloudHSM Nur Benutzerkonten mit der Administratorrolle dürfen diesen Befehl ausführen. Sie können keinen Benutzer löschen, der derzeit bei einem HSM angemeldet ist. 

## Benutzertyp
<a name="user-delete-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Admin.

## Voraussetzungen
<a name="user-delete-requirements"></a>
+ Sie können keine Benutzerkonten löschen, die Schlüssel besitzen.
+ Ihr Benutzerkonto muss über die Administratorrolle verfügen, um diesen Befehl ausführen zu können.

## Syntax
<a name="user-delete-syntax"></a>

Da dieser Befehl keine benannten Parameter hat, müssen Sie die Argumente in der im Syntaxdiagramm angegebenen Reihenfolge eingeben.

```
aws-cloudhsm > help user delete
Delete a user

Usage: user delete [OPTIONS] --username <USERNAME> --role <ROLE>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error

      --username <USERNAME>
          Username to access the HSM cluster

      --role <ROLE>
          Role the user has in the cluster

          Possible values:
          - crypto-user: A CryptoUser has the ability to manage and use keys
          - admin:       An Admin has the ability to manage user accounts

      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation
```

## Beispiel
<a name="user-delete-examples"></a>

```
aws-cloudhsm > user delete --username alice --role crypto-user
{
  "error_code": 0,
  "data": {
    "username": "alice",
    "role": "crypto-user"
  }
}
```

## Argumente
<a name="user-delete-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<USERNAME>***  
Gibt einen Anzeigenamen für den Benutzer an. Die maximale Länge beträgt 31 Zeichen. Das einzige zulässige Sonderzeichen ist ein Unterstrich (\$1). Beim Benutzernamen wird in diesem Befehl nicht zwischen Groß- und Kleinschreibung unterschieden, der Benutzername wird immer in Kleinbuchstaben angezeigt.  
Erforderlich: Ja

***<ROLE>***  
Gibt die diesem Benutzer zugewiesene Rolle an. Dieser Parameter muss angegeben werden. Gültige Werte sind **admin**, **crypto-user**.  
Verwenden Sie den **user list**-Befehl, um die Rolle des Benutzers abzurufen. Ausführliche Informationen zu den Benutzertypen in einem HSM finden Sie unter [HSM-Benutzer verstehen](manage-hsm-users.md).  
Erforderlich: Ja

***<APPROVAL>***  
Gibt den Dateipfad zu einer signierten Quorum-Token-Datei an, um den Vorgang zu genehmigen. Nur erforderlich, wenn der Quorumwert des Quorum-Benutzerdienstes größer als 1 ist.  
Erforderlich: Ja

## Verwandte Themen
<a name="user-delete-seealso"></a>
+ [user list](cloudhsm_cli-user-list.md)
+ [user create](cloudhsm_cli-user-create.md)
+ [user change-password](cloudhsm_cli-user-change-password.md)

# Alle AWS CloudHSM Benutzer mit CloudHSM CLI auflisten
<a name="cloudhsm_cli-user-list"></a>

Der **user list** Befehl in der CloudHSM-CLI listet die Benutzerkonten auf, die in Ihrem AWS CloudHSM Cluster vorhanden sind. Sie müssen nicht bei CloudHSM-CLI angemeldet sein, um diesen Befehl auszuführen.

**Anmerkung**  
Wenn Sie hinzufügen oder löschen HSMs, aktualisieren Sie die Konfigurationsdateien, die der AWS CloudHSM Client und die Befehlszeilentools verwenden. Andernfalls sind die Änderungen, die Sie vornehmen, möglicherweise nicht für alle Mitglieder HSMs des Clusters wirksam.

## Benutzertyp
<a name="user-list-userType"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Alle Benutzer. Sie müssen nicht angemeldet sein, um diesen Befehl auszuführen.

## Syntax
<a name="chsm-cli-user-list-syntax"></a>

```
aws-cloudhsm > help user list
List the users in your cluster

USAGE:
    user list

Options:
      --cluster-id <CLUSTER_ID>  Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
  -h, --help                     Print help
```

## Beispiel
<a name="chsm-cli-user-list-examples"></a>

Dieser Befehl listet die Benutzer auf, die in Ihrem CloudHSM-Cluster vorhanden sind.

```
aws-cloudhsm > user list
{
  "error_code": 0,
  "data": {
    "users": [
      {
        "username": "admin",
        "role": "admin",
        "locked": "false",
        "mfa": [],
        "cluster-coverage": "full"
      },
      {
        "username": "test_user",
        "role": "admin",
        "locked": "false",
        "mfa": [
          {
            "strategy": "token-sign",
            "status": "enabled"
          }
        ],
        "cluster-coverage": "full"
      },
      {
        "username": "app_user",
        "role": "internal(APPLIANCE_USER)",
        "locked": "false",
        "mfa": [],
        "cluster-coverage": "full"
      }
    ]
  }
}
```

Die Ausgabe umfasst die folgenden Benutzerattribute:
+ **Benutzername**: Zeigt den benutzerdefinierten Anzeigenamen für den Benutzer an. Der Benutzername wird immer in Kleinbuchstaben angezeigt. 
+ **Benutzertyp**: Bestimmt die Operationen, die der Benutzer im HSM ausführen kann.
+ **Gesperrt**: Zeigt an, ob dieses Benutzerkonto gesperrt wurde.
+ **MFA**: Gibt die unterstützten Multi-Faktor-Authentifizierungsmechanismen für dieses Benutzerkonto an.
+ **Clusterabdeckung**: Zeigt die clusterweite Verfügbarkeit dieses Benutzerkontos an.

## Verwandte Themen
<a name="chsm-user-list-seealso"></a>
+ [listUsers](key_mgmt_util-listUsers.md) in key\$1mgmt\$1util
+ [user create](cloudhsm_cli-user-create.md)
+ [user delete](cloudhsm_cli-user-delete.md)
+ [user change-password](cloudhsm_cli-user-change-password.md)

# Replizieren Sie einen Benutzer mit CloudHSM CLI
<a name="cloudhsm_cli-user-replicate"></a>

Verwenden Sie den **user replicate** Befehl in der CloudHSM-CLI, um einen Benutzer von einem Quell-Cluster auf einen AWS CloudHSM Ziel-Cluster zu replizieren. AWS CloudHSM 

## Benutzertyp
<a name="chsm-cli-user-replicate-user-type"></a>

Die folgenden Benutzertypen können diesen Befehl ausführen.
+ Administratoren () COs

## Voraussetzungen
<a name="cloudhsm_cli-user-replicate-requirements"></a>
+ Bei den Quell- und Zielclustern muss es sich um Klone handeln. Das bedeutet, dass einer aus einem Backup des anderen erstellt wurde oder dass beide aus einem gemeinsamen Backup erstellt wurden. Weitere Informationen finden Sie unter [Cluster aus Sicherungen erstellen](create-cluster-from-backup.md).
+ Um diesen Befehl ausführen zu können, müssen Sie sowohl auf dem Quell- als auch auf dem Zielcluster als Administrator angemeldet sein.
  +  Im Einzelbefehlsmodus verwendet der Befehl die Umgebungsvariablen CLOUDHSM\$1PIN und CLOUDHSM\$1ROLE, um sich auf dem Quellcluster zu authentifizieren. Weitere Informationen finden Sie unter [Einzelbefehlsmodus](cloudhsm_cli-modes.md#cloudhsm_cli-mode-single-command). Um Anmeldeinformationen für den Zielcluster bereitzustellen, müssen Sie zwei zusätzliche Umgebungsvariablen festlegen: DESTINATION\$1CLOUDHSM\$1PIN und DESTINATION\$1CLOUDHSM\$1ROLE:

    ```
    $ export DESTINATION_CLOUDHSM_ROLE=<role>
    ```

    ```
    $ export DESTINATION_CLOUDHSM_PIN=<username:password>
    ```
  +  Im interaktiven Modus müssen sich Benutzer explizit sowohl beim Quell- als auch beim Zielcluster anmelden.

## Syntax
<a name="chsm-cli-user-replicate-syntax"></a>

```
aws-cloudhsm > help user replicate
Replicate a user from a source to a destination cluster

Usage: user replicate --username <USERNAME> --role <ROLE> --source-cluster-id <SOURCE_CLUSTER_ID> --destination-cluster-id <DESTINATION_CLUSTER_ID>

Options:
      --username <USERNAME>
          Username of the user to replicate

      --role <ROLE>
          Role the user has in the cluster

          Possible values:
          - crypto-user: A CryptoUser has the ability to manage and use keys
          - admin:       An Admin has the ability to manage user accounts

      --source-cluster-id <SOURCE_CLUSTER_ID>
          Source cluster ID

      --destination-cluster-id <DESTINATION_CLUSTER_ID>
          Destination cluster ID

  -h, --help
          Print help (see a summary with '-h')
```

## Beispiele
<a name="chsm-cli-user-replicate-examples"></a>

**Example Beispiel: Benutzer replizieren**  
Dieser Befehl repliziert einen Benutzer von einem Quellcluster mit auf einen geklonten Zielcluster. Das folgende Beispiel zeigt die Ausgabe, wenn Sie auf beiden Clustern als Administrator angemeldet sind.  

```
admin-user@cluster-1234abcdefg > user replicate \
      --username example-admin \
      --role admin \
      --source-cluster-id cluster-1234abcdefg \
      --destination-cluster-id cluster-2345bcdefgh
{
  "error_code": 0,
  "data": {
    "user": {
      "username": "example-admin",
      "role": "admin",
      "locked": "false",
      "mfa": [],
      "quorum": [],
      "cluster-coverage": "full"
    },
    "message": "Successfully replicated user"
  }
}
```

## Argumente
<a name="user-replicate-arguments"></a>

***<USERNAME>***  
Gibt den Benutzernamen des Benutzers an, der im Quellcluster repliziert werden soll.  
Erforderlich: Ja

***<ROLE>***  
Gibt die diesem Benutzer zugewiesene Rolle an. Dieser Parameter muss angegeben werden. Gültige Werte sind **admin**, **crypto-user**.  
Verwenden Sie den **user list**-Befehl, um die Rolle des Benutzers abzurufen. Ausführliche Informationen zu den Benutzertypen in einem HSM finden Sie unter [HSM-Benutzer verstehen](manage-hsm-users.md).  
Erforderlich: Ja

***<SOURCE\$1CLUSTER\$1ID>***  
Die Quellcluster-ID.  
Erforderlich: Ja

***<DESTINATION\$1CLUSTER\$1ID>***  
Die Zielcluster-ID.  
Erforderlich: Ja

## Verwandte Themen
<a name="chsm-user-replicate-seealso"></a>
+ [Verbindung zu mehreren Clustern mit CloudHSM CLI herstellen](cloudhsm_cli-configs-multi-cluster.md)

# Die Quorum-Kategorie in CloudHSM CLI
<a name="cloudhsm_cli-qm"></a>

In der CloudHSM-CLI **quorum** ist dies eine übergeordnete Kategorie für eine Gruppe von Befehlen, die in Kombination mit **quorum** einem Befehl speziell für die Quorumauthentifizierung oder M-of-N-Operationen erstellt werden. Derzeit besteht diese Kategorie aus der **token-sign**-Unterkategorie, die aus eigenen Befehlen besteht. Weitere Informationen finden Sie unter dem nachfolgenden Link.
+ [token-sign](cloudhsm_cli-qm-token.md)

**Admin-Dienste**: Die Quorum-Authentifizierung wird für Dienste mit Administratorrechten verwendet, z. B. für das Erstellen von Benutzern, das Löschen von Benutzern, das Ändern von Benutzerkennwörtern, das Festlegen von Quorumwerten und das Deaktivieren von Quorum- und MFA-Funktionen.

**Crypto User Services**: Die Quorum-Authentifizierung wird für privilegierte Dienste verwendet, die Krypto-Benutzern vorbehalten sind und mit einem bestimmten Schlüssel verknüpft sind, z. B. das Signieren mit einem Schlüssel, sharing/unsharing einem Schlüssel, einem Schlüssel und das wrapping/unwrapping Festlegen eines Schlüsselattributs. Der Quorumwert eines zugehörigen Schlüssels wird konfiguriert, wenn der Schlüssel generiert, importiert oder entpackt wird. Der Quorumwert muss gleich oder kleiner als die Anzahl der Benutzer sein, denen der Schlüssel zugeordnet ist. Dazu gehören Benutzer, mit denen der Schlüssel geteilt wird, und der Schlüsselbesitzer.

Jeder Diensttyp wird weiter in einen qualifizierenden Dienstnamen unterteilt, der eine bestimmte Gruppe von Quorum-unterstützten Dienstvorgängen enthält, die ausgeführt werden können.


****  

| Service-Name | Servicetyp | Serviceoperationen | 
| --- | --- | --- | 
| user | Admin. |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-qm.html)  | 
| quorum | Admin. |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-qm.html)  | 
| Cluster 1 | Admin. |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-qm.html)  | 
| Schlüsselverwaltung | Crypto-Benutzer |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-qm.html)  | 
| Verwendung des Schlüssels | Crypto-Benutzer |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-qm.html)  | 

[1] Der Cluster-Service ist ausschließlich auf hsm2m.medium verfügbar

## Verwandte Themen
<a name="cloudhsm_cli-qm-seealso"></a>
+ [Richten Sie die Quorum-Authentifizierung für AWS CloudHSM Administratoren mithilfe der CloudHSM-CLI ein](quorum-auth-chsm-cli-first-time.md)
+ [Verwaltung der Quorum-Authentifizierung (M-of-N-Zugriffskontrolle) mithilfe der CloudHSM-CLI](quorum-auth-chsm-cli.md)

# Die Quorum-Tokensign-Kategorie in der CloudHSM-CLI
<a name="cloudhsm_cli-qm-token"></a>

In der CloudHSM-CLI **quorum token-sign** ist dies eine Kategorie für eine Gruppe von Befehlen, die in Kombination mit **quorum token-sign** einem Befehl einen spezifischen Befehl für die Quorumauthentifizierung oder M-of-N-Operationen erstellen.

Derzeit besteht diese Kategorie aus den folgenden Befehlen:
+ [delete](cloudhsm_cli-qm-token-del.md)
+ [generate](cloudhsm_cli-qm-token-gen.md)
+ [list](cloudhsm_cli-qm-token-list.md)
+ [list-quorum-values](cloudhsm_cli-qm-token-list-qm.md)
+ [set-quorum-value](cloudhsm_cli-qm-token-set-qm.md)

# Quorum-Token mithilfe der CloudHSM-CLI löschen
<a name="cloudhsm_cli-qm-token-del"></a>

Verwenden Sie den **quorum token-sign delete**-Befehl in der CloudHSM-CLI, um ein oder mehrere Token für einen vom Quorum autorisierten Dienst zu löschen.

## Benutzertyp
<a name="quorum-token-delete-user-type"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Admin.

## Syntax
<a name="quorum-token-delete-syntax"></a>

```
aws-cloudhsm > help quorum token-sign delete 
Delete one or more Quorum Tokens

Usage: quorum token-sign delete --scope <SCOPE>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error

      --scope <SCOPE>
          Scope of which token(s) will be deleted

          Possible values:
          - user: Deletes all token(s) of currently logged in user
          - all:  Deletes all token(s) on the HSM
  -h, --help
          Print help (see a summary with '-h')
```

## Beispiel
<a name="quorum-token-delete-examples"></a>

Das folgende Beispiel zeigt, wie der **quorum token-sign delete**-Befehl in der CloudHSM-CLI verwendet werden kann, um ein oder mehrere Token für einen vom Quorum autorisierten Dienst zu löschen.

**Example : Löschen Sie ein oder mehrere Token für einen vom Quorum autorisierten Dienst**  

```
aws-cloudhsm > quorum token-sign delete --scope all
{
  "error_code": 0,
  "data": "Deletion of quorum token(s) successful"
}
```

## Argumente
<a name="quorum-token-delete-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<SCOPE>***  
Der Bereich, in dem Token im AWS CloudHSM Cluster gelöscht werden.  
**Zulässige Werte**  
+ **Benutzer**: Wird verwendet, um nur Token zu löschen, die dem angemeldeten Benutzer gehören.
+ **Alle**: Wird verwendet, um alle Token im AWS CloudHSM Cluster zu löschen.

## Verwandte Themen
<a name="quorum-token-delete-seealso"></a>
+ [user list](cloudhsm_cli-user-list.md)
+ [user create](cloudhsm_cli-user-create.md)
+ [user delete](cloudhsm_cli-user-delete.md)

# Generieren Sie ein Quorum-Token mit der CloudHSM-CLI
<a name="cloudhsm_cli-qm-token-gen"></a>

Verwenden Sie den **quorum token-sign generate**-Befehl in der CloudHSM-CLI, um ein Token für einen vom Quorum autorisierten Dienst zu generieren.

In einem HSM-Cluster für Dienstbenutzer und Quorum gibt es eine Obergrenze für den Erhalt eines aktiven Tokens pro Benutzer und Dienst. Dieses Limit gilt nicht für Token, die sich auf wichtige Dienste beziehen.

**Anmerkung**  
Nur Admins und Crypto-Benutzer dürfen bestimmte Service-Token generieren. Weitere Informationen zu Diensttypen und -namen finden Sie unter [Dienstnamen und Typen, die die Quorum-Authentifizierung unterstützen](quorum-auth-chsm-cli-service-names.md)

**Admin-Dienste**: Die Quorum-Authentifizierung wird für Dienste mit Administratorrechten verwendet, z. B. für das Erstellen von Benutzern, das Löschen von Benutzern, das Ändern von Benutzerkennwörtern, das Festlegen von Quorumwerten und das Deaktivieren von Quorum- und MFA-Funktionen.

**Crypto User Services**: Die Quorum-Authentifizierung wird für Dienste verwendet, für die Krypto-Benutzer privilegiert sind und mit einem bestimmten Schlüssel verknüpft sind, z. B. das Signieren mit sharing/unsharing einem Schlüssel, wrapping/unwrapping einem Schlüssel und das Festlegen eines Schlüsselattributs. Der Quorumwert eines zugehörigen Schlüssels wird konfiguriert, wenn der Schlüssel generiert, importiert oder entpackt wird. Der Quorumwert muss gleich oder kleiner als die Anzahl der Benutzer sein, denen der Schlüssel zugeordnet ist. Dazu gehören Benutzer, mit denen der Schlüssel geteilt wird, und der Schlüsselbesitzer.

Jeder Diensttyp wird weiter in einen qualifizierenden Dienstnamen unterteilt, der eine bestimmte Gruppe von Quorum-unterstützten Dienstvorgängen enthält, die ausgeführt werden können.


****  

| Service-Name | Servicetyp | Serviceoperationen | 
| --- | --- | --- | 
| user | Admin. |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-qm-token-gen.html)  | 
| quorum | Admin. |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-qm-token-gen.html)  | 
| Cluster 1 | Admin. |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-qm-token-gen.html)  | 
| Schlüsselverwaltung | Crypto-Benutzer |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-qm-token-gen.html)  | 
| Verwendung des Schlüssels | Crypto-Benutzer |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/cloudhsm/latest/userguide/cloudhsm_cli-qm-token-gen.html)  | 

[1] Der Cluster-Service ist ausschließlich auf hsm2m.medium verfügbar

## Benutzertyp
<a name="quorum-token-generate-user-type"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Admin.
+ Crypto-Benutzer (Crypto User, CU)

## Syntax
<a name="quorum-token-generate-syntax"></a>

```
aws-cloudhsm > help quorum token-sign generate
Generate a token

Usage: quorum token-sign generate --service <SERVICE> --token <TOKEN>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error

      --service <SERVICE>
          Service the token will be used for

          Possible values:
          - user:
            User management service is used for executing quorum authenticated user management operations
          - quorum:
            Quorum management service is used for setting quorum values for any quorum service
          - cluster: 
            Cluster management service is used for executing quorum for cluster wide configuration managements like mtls enforcement, mtls registration and mtls deregistration
          - registration:
            Registration service is used for registering a public key for quorum authentication
          - key-usage:
            Key usage service is used for executing quorum authenticated key usage operations
          - key-management:
            Key management service is used for executing quorum authenticated key management operations

      --token <TOKEN>
          Filepath where the unsigned token file will be written
  -h, --help                     Print help
```

## Beispiel
<a name="quorum-token-generate-examples"></a>

Dieser Befehl schreibt ein unsigniertes Token pro HSM in Ihrem Cluster in die von `token` angegebene Datei.

**Example : Schreiben Sie ein unsigniertes Token pro HSM in Ihr Cluster**  

```
aws-cloudhsm > quorum token-sign generate --service user --token /home/tfile
{
  "error_code": 0,
  "data": {
    "filepath": "/home/tfile"
  }
}
```

## Argumente
<a name="quorum-token-generate-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<SERVICE>***  
Gibt den vom Quorum autorisierten Dienst an, für den ein Token generiert werden soll Dieser Parameter muss angegeben werden.  
**Zulässige Werte**  
+ **Benutzer**: Der Benutzerverwaltungsdienst, der für die Ausführung von Vorgängen zur Verwaltung autorisierter Quorum-Benutzer verwendet wird.
+ **Quorum**: Der Quorumverwaltungsdienst, der zum Festlegen von Quorum-autorisierten Quorumwerten für jeden vom Quorum autorisierten Dienst verwendet wird.
+ **Cluster**: Der Clusterverwaltungsdienst, der für die Ausführung von Quorum für clusterweites Konfigurationsmanagement wie MTLS-Durchsetzung, MTLS-Registrierung und MTLS-Deregistrierung verwendet wird.
+ **Registrierung**: Generiert ein unsigniertes Token zur Registrierung eines öffentlichen Schlüssels für die Quorumautorisierung.
+ **Schlüsselverwendung**: Generiert ein unsigniertes Token, das für die Ausführung von Quorum-autorisierten Schlüsselverwendungsvorgängen verwendet wird.
+ **Schlüsselverwaltung**: Generiert ein unsigniertes Token, das für die Ausführung von vom Quorum autorisierten Schlüsselverwaltungsoperationen verwendet wird.
**Erforderlich**: Ja

***<TOKEN>***  
Dateipfad, in den die unsignierte Tokendatei geschrieben wird.  
**Erforderlich**: Ja

## Verwandte Themen
<a name="quorum-token-generate-seealso"></a>
+ [Namen und Typen von Diensten, die die Quorum-Authentifizierung unterstützen](quorum-auth-chsm-cli-service-names.md)

# Quorum-Token mithilfe der CloudHSM-CLI auflisten
<a name="cloudhsm_cli-qm-token-list"></a>

Verwenden Sie den **quorum token-sign list** Befehl in der CloudHSM-CLI, um alle Tokensign-Quorum-Token aufzulisten, die in Ihrem Cluster vorhanden sind. AWS CloudHSM Dazu gehören auch Token, die von anderen Benutzern generiert wurden. Ein Token ist an einen Benutzer gebunden. Sie können also möglicherweise Token von anderen Benutzern sehen, Sie können jedoch nur Token verwenden, die dem aktuell angemeldeten Benutzer zugeordnet sind.

Weitere Informationen zu Diensttypen und -namen finden Sie unter [Dienstnamen und -typen, die die Quorumauthentifizierung unterstützen](quorum-auth-chsm-cli-service-names.md). Weitere Informationen zu den Inhalten, die anhand der aufgelisteten Token angezeigt werden, finden Sie unter [Schlüsselverwaltung und -nutzung mit aktivierter Quorum-Authentifizierung für die AWS CloudHSM Verwendung von CloudHSM CLI](key-quorum-auth-chsm-cli-crypto-user.md) Für Tokens, die mit `key-management` und `key-usage` Diensten verknüpft sind, bzw. unter [Benutzerverwaltung mit aktivierter Quorum-Authentifizierung für die AWS CloudHSM Verwendung von CloudHSM CLI](quorum-auth-chsm-cli-admin.md) Für Tokens`user`, die mit`quorum`, oder dem `cluster` Dienst verknüpft sind.

## Benutzertyp
<a name="quorum-token-list-user-type"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Admin.
+ Crypto-Benutzer (Crypto User, CU)

## Syntax
<a name="quorum-token-list-syntax"></a>

```
aws-cloudhsm > help quorum token-sign list
List the token-sign tokens in your cluster

Usage: quorum token-sign list

Options:
      --cluster-id <CLUSTER_ID>  Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
  -h, --help                     Print help
```

## Beispiel
<a name="quorum-token-list-examples"></a>

Dieser Befehl listet alle Tokensign-Token auf, die in Ihrem Cluster vorhanden sind. AWS CloudHSM Dies schließt Token ein, die von anderen Benutzern generiert wurden. Ein Token ist an einen Benutzer gebunden. Sie können also möglicherweise Token von anderen Benutzern sehen, Sie können jedoch nur Token verwenden, die dem aktuell angemeldeten Benutzer zugeordnet sind.

**Example**  

```
aws-cloudhsm > quorum token-sign list
{
  "error_code": 0,
  "data": {
    "tokens": [
      {
        "username": "admin",
        "service": "quorum",
        "approvals-required": 2,
        "number-of-approvals": 0,
        "token-timeout-seconds": 397,
        "cluster-coverage": "full"
      },
      {
        "username": "admin",
        "service": "user",
        "approvals-required": 2,
        "number-of-approvals": 0,
        "token-timeout-seconds": 588,
        "cluster-coverage": "full"
      },
      {
        "username": "crypto_user1",
        "service": "key-management",
        "key-reference": "0x00000000002c33f7",
        "minimum-token-count": 1
      },
      {
        "username": "crypto_user1",
        "service": "key-usage",
        "key-reference": "0x00000000002c33f7",
        "minimum-token-count": 1
      }
    ]
  }
}
```

## Verwandte Themen
<a name="quorum-token-list-seealso"></a>
+ [quorum token-sign generate](cloudhsm_cli-qm-token-gen.md)

# Quorumwerte mit CloudHSM CLI anzeigen
<a name="cloudhsm_cli-qm-token-list-qm"></a>

Verwenden Sie den **quorum token-sign list-quorum-values** Befehl in der CloudHSM-CLI, um die in Ihrem Cluster festgelegten Quorumwerte aufzulisten. AWS CloudHSM 

## Benutzertyp
<a name="quorum-token-list-qm-user-type"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Alle Benutzer. Sie müssen nicht angemeldet sein, um diesen Befehl auszuführen.

## Syntax
<a name="quorum-token-list-qm-syntax"></a>

```
aws-cloudhsm > help quorum token-sign list-quorum-values
List current quorum values

Usage: quorum token-sign list-quorum-values

Options:
      --cluster-id <CLUSTER_ID>  Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error
  -h, --help                     Print help
```

## Beispiel
<a name="quorum-token-list-qm-examples"></a>

Dieser Befehl listet die in Ihrem AWS CloudHSM Cluster für jeden Service festgelegten Quorumwerte auf.

**Example**  
**hsm1.medium**:  

```
aws-cloudhsm > quorum token-sign list-quorum-values
{
  "error_code": 0,
  "data": {
    "user": 1,
    "quorum": 1
  }
}
```
**hsm2m. Mittel**:  

```
aws-cloudhsm > quorum token-sign list-quorum-values
{
  "error_code": 0,
  "data": {
    "user": 1,
    "quorum": 1,
    "cluster": 1
  }
}
```

## Verwandte Themen
<a name="quorum-token-list-qm-seealso"></a>
+ [Namen und Typen von Diensten, die die Quorum-Authentifizierung unterstützen](quorum-auth-chsm-cli-service-names.md)
+  [mTLS einrichten (empfohlen)](getting-started-setup-mtls.md) 

# Einen Quorumwert mithilfe der CloudHSM-CLI aktualisieren
<a name="cloudhsm_cli-qm-token-set-qm"></a>

Verwenden Sie den **quorum token-sign set-quorum-value**-Befehl in der CloudHSM-CLI, um einen neuen Quorumwert für einen autorisierten Quorum-Dienst festzulegen.

## Benutzertyp
<a name="quorum-token-set-qm-user-type"></a>

Die folgenden Benutzer können diesen Befehl ausführen.
+ Admin.

## Syntax
<a name="quorum-token-set-qm-syntax"></a>

```
aws-cloudhsm > help quorum token-sign set-quorum-value
Set a quorum value

Usage: quorum token-sign set-quorum-value [OPTIONS] --service <SERVICE> --value <VALUE>

Options:
      --cluster-id <CLUSTER_ID>
          Unique Id to choose which of the clusters in the config file to run the operation against. If not provided, will fall back to the value provided when interactive mode was started, or error

      --service <SERVICE>
          Service the token will be used for

          Possible values:
          - user:
            User management service is used for executing quorum authenticated user management operations
          - quorum:
            Quorum management service is used for setting quorum values for any quorum service
          - cluster: 
            Cluster management service is used for executing quorum for cluster wide configuration managements like mtls enforcement, mtls registration and mtls deregistration

      --value <VALUE>
          Value to set for service

      --approval <APPROVAL>
          Filepath of signed quorum token file to approve operation

  -h, --help
          Print help (see a summary with '-h')
```

## Beispiel
<a name="quorum-token-set-qm-examples"></a>

**Example**  
Im folgenden Beispiel schreibt dieser Befehl ein unsigniertes Token pro HSM in Ihr Cluster in die durch das Token angegebene Datei. Signieren Sie die Token in der Datei, wenn Sie dazu aufgefordert werden.  

```
aws-cloudhsm > quorum token-sign set-quorum-value --service quorum --value 2
{
  "error_code": 0,
  "data": "Set Quorum Value successful"
}
```
Anschließend können Sie den **list-quorum-values**-Befehl ausführen, um zu bestätigen, dass der Quorumwert für den Quorumverwaltungsdienst festgelegt wurde:  
**hsm1.medium**:  

```
aws-cloudhsm > quorum token-sign list-quorum-values
{
  "error_code": 0,
  "data": {
    "user": 1,
    "quorum": 2
  }
}
```
**hsm2m. Mittel**:  

```
aws-cloudhsm > quorum token-sign list-quorum-values
{
  "error_code": 0,
  "data": {
    "user": 1,
    "quorum": 2,
    "cluster": 1
  }
}
```

## Argumente
<a name="quorum-token-set-qm-arguments"></a>

***<CLUSTER\$1ID>***  
Die ID des Clusters, auf dem dieser Vorgang ausgeführt werden soll.  
Erforderlich: Wenn mehrere Cluster [konfiguriert wurden.](cloudhsm_cli-configs-multi-cluster.md)

***<APPROVAL>***  
Der Dateipfad der signierten Tokendatei, die auf dem HSM genehmigt werden soll.

***<SERVICE>***  
Gibt den vom Quorum autorisierten Dienst an, für den ein Token generiert werden soll Dieser Parameter muss angegeben werden. Weitere Informationen zu Diensttypen und -namen finden Sie unter [Dienstnamen und -typen, die die Quorumauthentifizierung unterstützen](quorum-auth-chsm-cli-service-names.md).  
**Zulässige Werte**  
+ **Benutzer**: Der Benutzerverwaltungsdienst. Dienst, der für die Ausführung autorisierter Quorum-Benutzerverwaltungsvorgänge verwendet wird.
+ **Quorum**: Der Quorum-Verwaltungsdienst. Dienst, der zum Festlegen von Quorum-autorisierten Quorumwerten für jeden vom Quorum autorisierten Dienst verwendet wird.
+ **Cluster**: Der Clusterverwaltungsdienst, der für die Ausführung von Quorum für clusterweites Konfigurationsmanagement wie MTLS-Durchsetzung, MTLS-Registrierung und MTLS-Deregistrierung verwendet wird.
+ **Registrierung**: Generiert ein unsigniertes Token zur Registrierung eines öffentlichen Schlüssels für die Quorumautorisierung.
**Erforderlich**: Ja

***<VALUE>***  
Gibt den Quorumwert an, der festgelegt werden soll. Der maximale Quorumwert ist acht (8).  
**Erforderlich**: Ja

## Verwandte Themen
<a name="quorum-token-set-qm-seealso"></a>
+ [Quorum-Tokenzeichen list-quorum-values](cloudhsm_cli-qm-token-list-qm.md)
+ [Namen und Typen von Diensten, die die Quorum-Authentifizierung unterstützen](quorum-auth-chsm-cli-service-names.md)
+ [mTLS einrichten (empfohlen)](getting-started-setup-mtls.md)