Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# AWS CloudHSM Interfaccia a riga di comando (CLI)
<a name="cloudhsm_cli"></a>

La CLI di **CloudhSM** aiuta gli amministratori a gestire gli utenti e gli utenti di criptovalute a gestire le chiavi nel proprio cluster in. AWS CloudHSM La CLI include strumenti che possono essere utilizzati per creare, eliminare ed elencare utenti, modificare le password degli utenti, aggiornare l'autenticazione a più fattori (MFA) dell'utente. Include anche comandi che generano, eliminano, importano ed esportano chiavi, ottengono e impostano attributi, trovano chiavi ed eseguono operazioni crittografiche.

Per un elenco dettagliato di utenti della CLI di CloudHSM, vedi [Gestione degli utenti HSM con CLI CloudHSM](manage-hsm-users-chsm-cli.md). Per un elenco definito di attributi chiave per la CLI di CloudHSM, vedere. [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md) Per informazioni su come utilizzare la CLI di CloudHSM per gestire le chiavi, consulta. [Gestione delle chiavi con CloudHSM CLI](manage-keys-chsm-cli.md)

Per una guida rapida, vedi [Guida introduttiva all'interfaccia a riga di AWS CloudHSM comando (CLI)](cloudhsm_cli-getting-started.md). Per informazioni dettagliate sui comandi della CLI di CloudHSM ed esempi di utilizzo dei comandi, vedi [Riferimento per i comandi della CLI di CloudHSM](cloudhsm_cli-reference.md). 

**Topics**
+ [Piattaforme supportate](cloudhsm-cli-support.md)
+ [Nozioni di base](cloudhsm_cli-getting-started.md)
+ [Modalità di comando](cloudhsm_cli-modes.md)
+ [Attributi chiave](cloudhsm_cli-key-attributes.md)
+ [Configurazioni avanzate.](cloudhsm_cli-configs.md)
+ [Documentazione di riferimento](cloudhsm_cli-reference.md)

# AWS CloudHSM Piattaforme supportate dall'interfaccia a riga di comando (CLI)
<a name="cloudhsm-cli-support"></a>

Questo argomento descrive le piattaforme Linux e Windows supportate dalla AWS CloudHSM CLI.

## Supporto Linux
<a name="w2aac23c15c11b5"></a>


| Piattaforme supportate | Architettura: x86\$164 | Architettura ARM | 
| --- | --- | --- | 
| Amazon Linux 2 | Sì  | Sì | 
| Amazon Linux 2023 | Sì  | Sì | 
| Red Hat Enterprise Linux 8 (8.3\$1) | Sì  | Sì | 
| Red Hat Enterprise Linux 9 (9.2\$1) | Sì  | Sì | 
| Red Hat Enterprise Linux 10 (10.0\$1) | Sì  | Sì | 
| Ubuntu 22.04 LTS | Sì  | Sì | 
| Ubuntu 24.04 LTS | Sì  | Sì | 
+ SDK 5.16 è stata l'ultima versione a fornire il supporto della piattaforma Ubuntu 20.04 LTS. [Per ulteriori informazioni, consulta il sito Web di Ubuntu.](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 è stata l'ultima versione a fornire il supporto per la piattaforma CentOS 7 (7.8\$1). Per ulteriori informazioni, vedi il [sito web CentOS](https://blog.centos.org/2023/04/end-dates-are-coming-for-centos-stream-8-and-centos-linux-7/).
+ SDK 5.12 è stata l'ultima versione a fornire il supporto per la piattaforma Red Hat Enterprise Linux 7 (7.8\$1). [Per ulteriori informazioni, consulta il sito Web di Red Hat.](https://www.redhat.com/en/technologies/linux-platforms/enterprise-linux/rhel-7-end-of-maintenance)
+ SDK 5.4.2 è stata l'ultima versione a fornire il supporto della piattaforma CentOS 8. Per ulteriori informazioni, vedi il [sito web CentOS](https://www.centos.org/centos-linux-eol/).

## Supporto Windows
<a name="w2aac23c15c11b7"></a>
+ Microsoft Windows Server 2016
+ Microsoft Windows Server 2019
+ Microsoft Windows Server 2022
+ Microsoft Windows Server 2025

# Guida introduttiva all'interfaccia a riga di AWS CloudHSM comando (CLI)
<a name="cloudhsm_cli-getting-started"></a>

Con l'interfaccia a riga di comando (CLI) della CLI di CloudHSM, puoi gestire gli utenti del tuo cluster. AWS CloudHSM Utilizza questo argomento per iniziare con le attività di gestione degli utenti dei moduli di sicurezza hardware (HSM) di base, come la creazione di utenti, l'elenco degli utenti e la connessione della CLI di CloudHSM al cluster.

**Topics**
+ [Installa la CLI CloudhSM](w2aac23c15c13b7.md)
+ [Usa la CLI CloudhSM](cloudhsm_cli-getting-started-use.md)

# Installa la CLI CloudhSM
<a name="w2aac23c15c13b7"></a>

Utilizza i seguenti comandi per scaricare e installare la CLI CloudhSM per. AWS CloudHSM

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

Amazon Linux 2023 su architettura x86\$164:

```
$ 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 sull' ARM64 architettura:

```
$ 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 su architettura x86\$164:

```
$ 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 sull' ARM64 architettura:

```
$ 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 su architettura x86\$164:

```
$ 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 sull'architettura: 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 su architettura x86\$164:

```
$ 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 sull'architettura: 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 su architettura x86\$164:

```
$ 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 sull' ARM64 architettura:

```
$ 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 su architettura x86\$164:

```
$ 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 sull'architettura: 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 su architettura x86\$164:

```
$ 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 sull'architettura: 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 ]

Per Windows Server 2022 su architettura x86\$164, apri PowerShell come amministratore ed esegui il seguente comando:

```
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 ]

Per Windows Server 2019 su architettura x86\$164, apri PowerShell come amministratore ed esegui il comando seguente:

```
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 ]

Per Windows Server 2016 su architettura x86\$164, apri PowerShell come amministratore ed esegui il comando seguente:

```
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
```

------

Usa i seguenti comandi per configurare la CLI di CloudHSM.

**Per eseguire il bootstrap di un'istanza EC2 Linux per Client SDK 5**
+  Usa lo strumento di configurazione per specificare l'indirizzo IP degli HSM sul cluster. 

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

**Per effettuare il bootstrap di un'istanza EC2 Windows per il Client SDK 5**
+  Usa lo strumento di configurazione per specificare l'indirizzo IP degli HSM sul cluster. 

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

# Usa la CLI CloudhSM
<a name="cloudhsm_cli-getting-started-use"></a>

Utilizza i seguenti comandi per avviare e utilizzare la CLI CloudhSM.

1. Utilizza il seguente comando per avviare la CLI di CloudHSM.

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

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

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

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

------

1. Utilizza il comando **login** per effettuare la connessione al cluster. Tutti gli utenti possono utilizzare questo comando.

   Il comando dell'esempio seguente consente di accedere ad *admin*, che è l'account [admin](understanding-users.md) predefinito. Imposta questa password dell'utente una volta che avrai [attivato il cluster](activate-cluster.md).

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

   Il sistema ti invita a inserire la tua password. Immetti la password e l'output mostra che il comando è stato eseguito con successo.

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

1. Esegui il comando **user list** per elencare tutti gli utenti del cluster.

   ```
   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.  Utilizza **user create** per creare un utente CU denominato **example\$1user**. 

   Puoi creare CUs perché in un passaggio precedente hai effettuato l'accesso come utente amministratore. Solo gli utenti admin possono eseguire attività di gestione degli utenti, come la creazione e l'eliminazione di utenti e la modifica delle password di altri utenti. 

   ```
   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.  Utilizza **user list** per elencare tutti gli utenti del cluster. 

   ```
   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. Usa il **logout** comando per disconnetterti dal AWS CloudHSM cluster.

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

1. Utilizza il comando **quit** per chiudere la CLI.

   ```
   aws-cloudhsm > quit
   ```

# Modalità di comando nella CLI di CloudHSM
<a name="cloudhsm_cli-modes"></a>

Nella CLI di CloudHSM, puoi eseguire i comandi in due modi diversi: in modalità comando singolo e in modalità interattiva. La modalità interattiva è progettata per gli utenti e la modalità a comando singolo è progettata per gli script.

**Nota**  
Tutti i comandi funzionano sia in modalità interattiva che in modalità a comando singolo.

## Modalità interattiva
<a name="cloudhsm_cli-mode-interactive"></a>

Usa i seguenti comandi per avviare la modalità interattiva nella CLI di CloudHSM

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

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

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

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

------

Quando si utilizza la CLI in modalità interattiva, è possibile accedere a un account utente utilizzando il comando **login**.

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

Per visualizzare un elenco di tutti i comandi della CLI di CloudHSM, esegui il seguente comando:

```
aws-cloudhsm > help
```

Per ottenere la sintassi di un comando della CLI di CloudHSM, esegui il seguente comando:

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

Per ottenere un elenco di utenti su HSMs, digitare**user list**.

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

Per terminare la sessione della CLI di CloudHSM, esegui il seguente comando:

```
aws-cloudhsm > quit
```

## Modalità di comando singolo
<a name="cloudhsm_cli-mode-single-command"></a>

**Nota**  
Quando si utilizza la modalità a comando singolo, è necessario evitare eventuali caratteri speciali nelle variabili di ambiente e negli argomenti della riga di comando che possono essere interpretati dalla shell.

Se usi la CLI di CloudHSM CLI con la modalità a comando singolo, devi impostare due variabili di ambiente per fornire le credenziali: PIN\$1CLOUDHSM e RUOLO\$1CLOUDHSM:

```
$ export CLOUDHSM_ROLE=admin
```

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

Una volta fatto ciò, puoi eseguire i comandi utilizzando le credenziali memorizzate nel tuo ambiente.

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

# Attributi chiave per la CLI di CloudHSM
<a name="cloudhsm_cli-key-attributes"></a>

Questo argomento descrive come utilizzare la CLI CloudHSM per impostare gli attributi di una chiave. L'attributo di una chiave nella CLI di CloudHSM può definire la tipologia di una chiave, come può funzionare una chiave o come viene etichettata una chiave. Alcuni attributi definiscono caratteristiche uniche (ad esempio il tipo di chiave). Altri attributi possono essere impostati su vero o falso: la loro modifica attiva o disattiva una funzionalità della chiave.

Per esempi che mostrano come utilizzare gli attributi delle chiavi, vedi i comandi elencati sotto il comando principale [La categoria chiave della CLI di CloudHSM](cloudhsm_cli-key.md).

I seguenti argomenti forniscono ulteriori dettagli sugli attributi chiave nella CLI di CloudHSM.

**Topics**
+ [Attributi supportati](cloudhsm_cli-key-attributes-table.md)
+ [Valore di controllo](chsm-cli-key-attribute-details.md)
+ [Argomenti correlati](chsm_cli-key-attributes-seealso.md)

# Attributi supportati per CloudHSM CLI
<a name="cloudhsm_cli-key-attributes-table"></a>

Come best practice, imposta i valori solo per gli attributi che desideri rendere restrittivi. Se non specifichi un valore, la CLI di CloudHSM utilizza il valore predefinito specificato nella tabella sottostante.

La tabella seguente elenca gli attributi chiave, i valori possibili, i valori predefiniti e le note correlate per CloudHSM CLI. Una cella vuota nella colonna **Valore** indica che non vi è alcun valore predefinito specifico assegnato all'attributo.


****  

| Attributo della CLI del CloudHSM | Valore | Modificabile con [key set-attribute](cloudhsm_cli-key-set-attribute.md) | Da impostare al momento della creazione della chiave | 
| --- | --- | --- | --- | 
| always-sensitive |  Il valore è `True` se `sensitive` è sempre stato impostato su `True` e non è mai stato cambiato.  | No | No | 
| check-value | Valore di controllo della chiave. Per ulteriori informazioni, vedi [Ulteriori dettagli](chsm-cli-key-attribute-details.md). | No | No | 
| class | Valori possibili: `secret-key`, `public-key` e `private-key`. | No | Sì | 
| curve |  Curva ellittica usata per generare la coppia di chiavi EC. Valori validi:`secp224r1`,,,,`secp256r1`, e `prime256v1` `secp384r1` `secp256k1` `secp521r1` `ed25519` `ed25519`è supportato solo sulle istanze hsm2m.medium in modalità non FIPS.  | No | Impostabile con EC, non impostabile con RSA | 
| decrypt | Impostazione predefinita: `False` | Sì  | Sì | 
| derive | Impostazione predefinita: `False` | Derive può essere impostato su istanze hsm2m.medium. Non può essere impostato per le chiavi RSA sulle istanze hsm1.medium. | Sì | 
| destroyable | Impostazione predefinita: `True` | Sì  | Sì | 
| ec-point | Per le chiavi EC, codifica DER del valore ANSI ECPoint X9.62 «Q» in formato esadecimale. Per altri tipi di chiavi, questo attributo non esiste. | No | No | 
| encrypt | Impostazione predefinita: `False` | Sì  | Sì | 
| extractable | Impostazione predefinita: `True` | No | Sì | 
| id | Impostazione predefinita: Vuoto | id può essere impostato su istanze hsm2m.medium. Non può essere impostato sulle istanze hsm1.medium. | Sì | 
| key-length-bytes | Necessario per generare una chiave AES.Valori validi: `16``24`, e `32` byte. | No | No | 
| key-type | Valori possibili: `aes`, `rsa` e `ec` | No | Sì | 
| label | Impostazione predefinita: Vuoto | Sì  | Sì | 
| local | Impostazione predefinita: `True` per le chiavi generate nell'HSM, `False` per le chiavi importate nell'HSM. | No | No | 
| modifiable | Impostazione predefinita: `True` | Può essere modificato da vero a falso, ma non da falso a vero. | Sì | 
| modulus | Il modulo utilizzato per creare una coppia di chiavi RSA. Per altri tipi di chiavi, questo attributo non esiste. | No | No | 
| modulus-size-bits | Necessario per generare una coppia di chiavi RSA.Il valore minimo è `2048`. | No | Da impostare con RSA, non può essere impostato con EC | 
| never-extractable |  Il valore è `True` se la modalità Estraibile non è mai stata impostata su `False`. Il valore è `False` se la modalità Estraibile è stata impostata su `True`.  | No | No | 
| private | Impostazione predefinita: `True` | No | Sì | 
| public-exponent | Necessario per generare una coppia di chiavi RSA.Valore valido: Il valore deve essere un numero dispari maggiore o uguale a `65537`. | No | Da impostare con RSA, non può essere impostato con EC | 
| sensitive |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-key-attributes-table.html)  | No | Si può impostare su chiavi private, non può essere impostato su chiavi pubbliche. | 
| sign |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-key-attributes-table.html)  | Sì  | Sì | 
| token | Impostazione predefinita: `True` | Può essere modificato da falso a vero, ma non da vero a falso. | Sì | 
| trusted | Impostazione predefinita: `False` | Solo gli utenti amministratori possono impostare questo parametro. | No | 
| unwrap | Impostazione predefinita: False | Sì | Sì, ad eccezione delle chiavi pubbliche. | 
| unwrap-template | I valori devono utilizzare il modello di attributo applicato a qualsiasi chiave di cui è stato annullato il wrapping utilizzando questa chiave di wrapping. | Sì | No | 
| verify |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-key-attributes-table.html)  | Sì  | Sì | 
| wrap | Impostazione predefinita: False | Sì | Sì, tranne le chiavi private. | 
| wrap-template | I valori devono utilizzare il modello di attributo per abbinare la chiave sottoposta a wrapping usando questa chiave di wrapping. | Sì | No | 
| wrap-with-trusted | Impostazione predefinita: `False` | Sì  | Sì | 

# Verifica il valore nella CLI di CloudHSM
<a name="chsm-cli-key-attribute-details"></a>

Il *valore di controllo* nella CLI di CloudHSM è un hash o checksum a 3 byte di una chiave che viene generato quando l'HSM importa o genera una chiave. È possibile anche calcolare un valore di controllo al di fuori dell'HSM, ad esempio dopo aver esportato una chiave. È quindi possibile confrontare i valori del valore di controllo per confermare l'identità e l'integrità della chiave. Per ottenere il valore di controllo di una chiave, usa l'[elenco delle chiavi](cloudhsm_cli-key-list.md) con il flag output dettagliato.

AWS CloudHSM utilizza i seguenti metodi standard per generare un valore di controllo:
+ **Chiavi simmetriche**: primi 3 byte del risultato della crittografia a blocchi zero con la chiave.
+ **Coppie di chiavi asimmetriche**: primi 3 byte dell'hash SHA-1 della chiave pubblica.
+ **Chiavi HMAC**: KCV per le chiavi HMAC attualmente non supportato.

# Argomenti correlati per CloudHSM CLI
<a name="chsm_cli-key-attributes-seealso"></a>

Per ulteriori informazioni sulla CLI di CloudHSM, consulta i seguenti argomenti.
+ [La categoria chiave della CLI di CloudHSM](cloudhsm_cli-key.md)
+ [Riferimento per i comandi della CLI di CloudHSM](cloudhsm_cli-reference.md)

# Configurazioni avanzate per CloudHSM CLI
<a name="cloudhsm_cli-configs"></a>

L'interfaccia a riga di AWS CloudHSM comando (CLI) include la seguente configurazione avanzata, che non fa parte delle configurazioni generali utilizzate dalla maggior parte dei clienti. Queste configurazioni offrono funzionalità aggiuntive.
+ [Connessione a più cluster](cloudhsm_cli-configs-multi-cluster.md)

# Connessione a più cluster con la CLI CloudhSM
<a name="cloudhsm_cli-configs-multi-cluster"></a>

 Con AWS CloudHSM Client SDK 5, puoi configurare CloudHSM CLI per consentire le connessioni a più cluster CloudHSM da una singola istanza CLI. 

I seguenti argomenti descrivono come utilizzare la funzionalità multi-cluster della CLI di CloudHSM per connettersi a più cluster.

**Topics**
+ [Prerequisiti](cloudhsm_cli-multi-cluster-prereqs.md)
+ [Configura la funzionalità multi-cluster](cloudhsm_cli-multi-cluster-config-run.md)
+ [Aggiungi un cluster](cloudhsm_cli-multi-cluster-add-cluster.md)
+ [Rimuovi un cluster](cloudhsm_cli-multi-cluster-remove-cluster.md)
+ [Interagisci con i cluster](cloudhsm_cli-multi-cluster-usage.md)

# Prerequisiti per più cluster per AWS CloudHSM
<a name="cloudhsm_cli-multi-cluster-prereqs"></a>

Prima di configurare il cluster per la connessione AWS CloudHSM a più cluster, è necessario soddisfare i seguenti prerequisiti: 
+ Due o più AWS CloudHSM cluster a cui desideri connetterti, insieme ai relativi certificati di cluster.
+ Un' EC2 istanza con gruppi di sicurezza configurati correttamente per connettersi a tutti i cluster di cui sopra. Per ulteriori informazioni su come configurare un cluster e l'istanza del client, consulta la sezione [Guida introduttiva AWS CloudHSM](getting-started.md).
+ Per configurare la funzionalità multi-cluster, è necessario aver già scaricato e installato la CLI ClouDHSM. Se non lo hai ancora fatto, consulta le istruzioni riportate in [Guida introduttiva all'interfaccia a riga di AWS CloudHSM comando (CLI)](cloudhsm_cli-getting-started.md).
+  Non sarai in grado di accedere a un cluster configurato con `./configure-cli[.exe] -a` poiché non sarà associato a un. `cluster-id` Puoi riconfigurarlo seguendo `config-cli add-cluster` come descritto in questa guida. 

# Configura la CLI CloudHSM per la funzionalità multi-cluster
<a name="cloudhsm_cli-multi-cluster-config-run"></a>

Per configurare la CLI di CloudHSM per la funzionalità multi-cluster, procedi nel seguente modo:

1. Identifica i cluster a cui desideri connetterti.

1. [Aggiungi questi cluster alla configurazione CLI di CloudHSM utilizzando il sottocomando configure-cli come descritto di seguito.](configure-sdk-5.md) `add-cluster`

1. Riavvia tutti i processi CLI di CloudHSM per rendere effettiva la nuova configurazione.

# Aggiungi un cluster alla tua configurazione AWS CloudHSM
<a name="cloudhsm_cli-multi-cluster-add-cluster"></a>

Quando ti connetti a più cluster, usa il `configure-cli add-cluster` comando per aggiungere un cluster alla tua configurazione.

## Sintassi
<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]
```

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

### Aggiungere un cluster utilizzando il parametro `cluster-id`
<a name="w2aac23c15c19b7c13b7b3b1"></a>

**Example**  
 Utilizza il parametro `configure-cli add-cluster` insieme a `cluster-id` per aggiungere un cluster (con l'ID del `cluster-1234567`) alla tua configurazione.   

```
$ 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>
```

**Suggerimento**  
Se l'utilizzo del parametro `configure-cli add-cluster` con `cluster-id` non dà come risultato l'aggiunta del cluster, consulta l'esempio seguente per una versione più lunga del comando che richiede anche i parametri `--region` e `--endpoint` per identificare il cluster che si sta aggiungendo. Se, ad esempio, la regione del cluster è diversa da quella configurata come impostazione predefinita per la CLI di AWS, è necessario impiegare il parametro `--region` per utilizzare la regione corretta. Inoltre, hai la possibilità di specificare l'endpoint AWS CloudHSM API da utilizzare per la chiamata, che potrebbe essere necessario per varie configurazioni di rete, ad esempio l'utilizzo di endpoint di interfaccia VPC che non utilizzano il nome host DNS predefinito per. AWS CloudHSM

### Aggiungere un cluster utilizzando i parametri `cluster-id`, `endpoint` e `region`
<a name="w2aac23c15c19b7c13b7b3b3"></a>

**Example**  
 Utilizza `configure-cli add-cluster` insieme ai parametri `cluster-id`, `endpoint` e `region` per aggiungere un cluster (con l'ID del `cluster-1234567`) alla tua configurazione.   

```
$ 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>
```

Per ulteriori informazioni sui parametri `--cluster-id`, `--region` e `--endpoint`, vedi [AWS CloudHSM Parametri di configurazione di Client SDK 5](configure-tool-params5.md).

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

**--cluster-id *<Cluster ID>***  
 Effettua una chiamata `DescribeClusters` per trovare tutti gli indirizzi IP a interfaccia di rete elastica (ENI) dell’HSM nel cluster associati all'ID del cluster. Il sistema aggiunge gli indirizzi IP ENI ai file di configurazione. AWS CloudHSM   
Se utilizzi il `--cluster-id` parametro da un' EC2 istanza all'interno di un VPC che non ha accesso alla rete Internet pubblica, devi creare un endpoint VPC di interfaccia con cui connetterti. AWS CloudHSM Per ulteriori informazioni sugli endpoint VPC, consulta la pagina [AWS CloudHSM ed endpoint VPC](cloudhsm-vpc-endpoint.md).
Obbligatorio: sì

**--endpoint *<Endpoint>***  
Specificare l'endpoint AWS CloudHSM API utilizzato per effettuare la chiamata. `DescribeClusters` È necessario impostare questa opzione insieme a `--cluster-id`.   
Obbligatorio: no

**--hsm-ca-cert *<HsmCA Certificate Filepath>***  
Speciifica il percorso del file del certificato CA HSM.  
Obbligatorio: no

**--region *<Region>***  
Specifica la regione del cluster. È necessario impostare questa opzione insieme a `--cluster-id`.  
Se non indichi il parametro `--region`, il sistema sceglie la regione tentando di leggere le variabili di ambiente `AWS_DEFAULT_REGION` o `AWS_REGION`. Se queste variabili non sono impostate, il sistema controlla la regione associata al tuo profilo indicata nel tuo file di AWS Config (generalmente `~/.aws/config`) a meno che non sia stato specificato un file diverso nella variabile di ambiente `AWS_CONFIG_FILE`. Se non è stata impostata nessuna delle variabili precedenti, il sistema utilizza la regione `us-east-1` per impostazione predefinita.  
Obbligatorio: no

**-- -archivio client-cert-hsm-tls *<client certificate hsm tls path>***  
 Percorso del certificato client utilizzato per l'autenticazione reciproca TLS Client-HSM.   
 Utilizza questa opzione solo se hai registrato almeno un trust anchor su HSM con CloudHSM CLI. È necessario impostare questa opzione insieme a `--client-key-hsm-tls-file`.   
Obbligatorio: no

**-- -file client-key-hsm-tls *<client key hsm tls path>***  
 Percorso della chiave client utilizzata per l'autenticazione reciproca TLS Client-HSM.   
 Utilizza questa opzione solo se hai registrato almeno un trust anchor su HSM con CloudHSM CLI. È necessario impostare questa opzione insieme a `--client-cert-hsm-tls-file`.   
Obbligatorio: no

# Rimuovi un cluster dalla tua configurazione AWS CloudHSM
<a name="cloudhsm_cli-multi-cluster-remove-cluster"></a>

Quando ti connetti a più cluster con la CLI di CloudhSM, usa `configure-cli remove-cluster` il comando per rimuovere un cluster dalla tua configurazione.

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

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

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

### Rimuovere un cluster utilizzando il parametro `cluster-id`
<a name="w2aac23c15c19b7c15b7b3b1"></a>

**Example**  
 Utilizza il parametro `configure-cli remove-cluster` insieme a `cluster-id` per rimuovere un cluster (con l'ID del `cluster-1234567`) dalla tua configurazione.   

```
$ 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>
```

Per ulteriori informazioni sul parametro `--cluster-id`, vedi [AWS CloudHSM Parametri di configurazione di Client SDK 5](configure-tool-params5.md).

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

**--cluster-id *<Cluster ID>***  
L'ID del cluster da rimuovere dalla configurazione.  
Obbligatorio: sì

# Interagisci con più cluster in AWS CloudHSM
<a name="cloudhsm_cli-multi-cluster-usage"></a>

Dopo aver configurato più cluster con la CLI di CloudhSM, usa il comando per interagire con essi. `cloudhsm-cli`

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

### Impostazione di un valore predefinito quando si utilizza la modalità interattiva `cluster-id`
<a name="w2aac23c15c19b7c17b5b3b1"></a>

**Example**  
 Utilizza il parametro [Modalità interattiva](cloudhsm_cli-modes.md#cloudhsm_cli-mode-interactive) insieme al `cluster-id` parametro per impostare un cluster predefinito (con l'ID di`cluster-1234567`) dalla tua configurazione.   

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

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

### Impostazione di `cluster-id` quando si esegue un singolo comando
<a name="w2aac23c15c19b7c17b5b5b1"></a>

**Example**  
 Utilizzate il `cluster-id` parametro per impostare il cluster (con l'ID di`cluster-1234567`) da cui [Elenco HSMs con CLI CloudHSM](cloudhsm_cli-cluster-hsm-info.md) partire.   

```
$ 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>
```

# Riferimento per i comandi della CLI di CloudHSM
<a name="cloudhsm_cli-reference"></a>

La CLI di CloudhSM aiuta gli amministratori a gestire gli utenti nel proprio cluster. AWS CloudHSM La CLI di CloudHSM può essere eseguita in due modalità: modalità interattiva e modalità a comando singolo. Per una guida rapida, vedi [Guida introduttiva all'interfaccia a riga di AWS CloudHSM comando (CLI)](cloudhsm_cli-getting-started.md). 

Per eseguire la maggior parte dei comandi della CLI di CloudHSM, è necessario avviare la CLI di CloudHSM e accedere all'HSM. Se aggiungi o elimini HSMs, aggiorna i file di configurazione per CloudHSM CLI. In caso contrario, le modifiche apportate potrebbero non essere efficaci per tutti gli HSMs utenti del cluster.

I seguenti argomenti descrivono i comandi nella CLI di CloudHSM: 


| Comando | Description | Tipo di utente | 
| --- | --- | --- | 
| [attivazione](cloudhsm_cli-cluster-activate.md) | Attiva un cluster CloudHSM e conferma che il cluster è nuovo. Questa deve essere fatto prima di poter eseguire qualsiasi altra operazione. | Admin non attivato | 
| [hsm-info](cloudhsm_cli-cluster-hsm-info.md) | Elencali HSMs nel tuo cluster. | Tutti [1](#cli-ref-1), compresi gli utenti non autenticati. L'accesso non è necessario. | 
| [ecdsa](cloudhsm_cli-crypto-sign-ecdsa.md) | Genera una firma utilizzando una chiave privata EC e il meccanismo di firma ECDSA.  | Crypto user (CU) | 
| [ed25519ph](cloudhsm_cli-crypto-sign-ed25519ph.md) | Genera una firma utilizzando una chiave privata Ed25519 e il HashEd meccanismo di firma DSA.  | CU | 
| [rsa-pkcs](cloudhsm_cli-crypto-sign-rsa-pkcs.md) | Genera una firma utilizzando una chiave privata RSA e il meccanismo di firma RSA-PKCS. | CU | 
| [rsa-pkcs-pss](cloudhsm_cli-crypto-sign-rsa-pkcs-pss.md) | Genera una firma utilizzando una chiave privata RSA e il meccanismo di firma. RSA-PKCS-PSS | CU | 
| [ecdsa](cloudhsm_cli-crypto-verify-ecdsa.md) | Conferma che un file è stato firmato nell'HSM con una determinata chiave pubblica. Verifica che la firma sia stata generata utilizzando il meccanismo di firma ECDSA. Confronta un file firmato con un file sorgente e determina se i due sono correlati crittograficamente in base a una determinata chiave pubblica ecdsa e a un determinato meccanismo di firma.  | CU | 
| [ed25519ph](cloudhsm_cli-crypto-verify-ed25519ph.md) | Verifica le firme HashEd DSA utilizzando una chiave pubblica Ed25519. | CU | 
| [rsa-pkcs](cloudhsm_cli-crypto-verify-rsa-pkcs.md) | Conferma che un file è stato firmato nell'HSM con una determinata chiave pubblica. Verifica che la firma sia stata generata utilizzando il meccanismo di firma RSA-PKCS. Confronta un file firmato con un file sorgente e determina se i due sono correlati crittograficamente in base a una determinata chiave pubblica rsa e a un determinato meccanismo di firma. | CU | 
| [rsa-pkcs-pss](cloudhsm_cli-crypto-verify-rsa-pkcs-pss.md) | Conferma che un file è stato firmato nell'HSM con una determinata chiave pubblica. Verifica che la firma sia stata generata utilizzando il meccanismo di RSA-PKCS-PSS firma. Confronta un file firmato con un file sorgente e determina se i due sono correlati crittograficamente in base a una determinata chiave pubblica rsa e a un determinato meccanismo di firma. | CU | 
| [Elimina chiave](cloudhsm_cli-key-delete.md) | Elimina una chiave dal cluster. AWS CloudHSM  | CU | 
| [Generazione chiavi-file](cloudhsm_cli-key-generate-file.md) | Genera un file chiave nel AWS CloudHSM cluster. | CU | 
| [chiave generate-asymmetric-pair rsa](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md) | Genera una coppia di chiavi RSA asimmetrica nel cluster. AWS CloudHSM  | CU | 
| [chiave ec generate-asymmetric-pair](cloudhsm_cli-key-generate-asymmetric-pair-ec.md) | Genera una coppia di chiavi a curva ellittica (EC) asimmetrica nel cluster. AWS CloudHSM  | CU | 
| [Generazione chiavi-simmetriche aes](cloudhsm_cli-key-generate-symmetric-aes.md) | Genera una chiave AES simmetrica nel cluster. AWS CloudHSM  | CU | 
| [Generazione chiavi-simmetriche generiche-segrete](cloudhsm_cli-key-generate-symmetric-generic-secret.md) | Genera una chiave segreta generica simmetrica nel cluster. AWS CloudHSM  | CU | 
| [chiave di importazione pem](cloudhsm_cli-key-import-pem.md) | Importa una chiave in formato PEM in un HSM. È possibile utilizzarlo per importare le chiavi pubbliche generate al di fuori del HSM. | CU | 
| [Elenco chiavi](cloudhsm_cli-key-list.md) | Trova tutte le chiavi per l'utente corrente presente nel cluster AWS CloudHSM . | CU | 
| [chiave: replica](cloudhsm_cli-key-replicate.md) | Replica una chiave da un cluster di origine a un cluster di destinazione clonato. | CU | 
| [key set-attribute](cloudhsm_cli-key-set-attribute.md) | Imposta gli attributi delle chiavi nel cluster. AWS CloudHSM  | CUs può eseguire questo comando, gli amministratori possono impostare l'attributo trusted. | 
| [Condivisione chiave](cloudhsm_cli-key-share.md) | Condivide una chiave con altri membri CUs del cluster AWS CloudHSM . | CU | 
| [Annulla condivisione chiave](cloudhsm_cli-key-unshare.md) | Annulla la condivisione di una chiave con altri CUs membri del AWS CloudHSM cluster. | CU | 
| [aes-gcm](cloudhsm_cli-key-unwrap-aes-gcm.md) | Scompone una chiave di payload nel cluster utilizzando la chiave di wrapping AES e il meccanismo di unwrapping AES-GCM. | CU | 
| [aes-no-pad](cloudhsm_cli-key-unwrap-aes-no-pad.md) | Scompone una chiave di payload nel cluster utilizzando la chiave di wrapping AES e il meccanismo di unwrapping. AES-NO-PAD | CU | 
| [aes-pkcs5-pad](cloudhsm_cli-key-unwrap-aes-pkcs5-pad.md) | Scompone una chiave di payload utilizzando la chiave di wrapping AES e il meccanismo di apertura AES- -PAD. PKCS5 | CU | 
| [aes-zero-pad](cloudhsm_cli-key-unwrap-aes-zero-pad.md) | Scompone una chiave di payload nel cluster utilizzando la chiave di wrapping AES e il meccanismo di unwrapping. AES-ZERO-PAD | CU | 
| [cloudhsm-aes-gcm](cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm.md) | Scompone una chiave di payload nel cluster utilizzando la chiave di wrapping AES e il meccanismo di unwrapping. CLOUDHSM-AES-GCM | CU | 
| [rsa-aes](cloudhsm_cli-key-unwrap-rsa-aes.md) | Scompone una chiave di payload utilizzando una chiave privata RSA e il meccanismo di unwrapping RSA-AES. | CU | 
| [rsa-oaep](cloudhsm_cli-key-unwrap-rsa-oaep.md) | Scompone una chiave di payload utilizzando la chiave privata RSA e il meccanismo di decompressione RSA-OAEP. | CU | 
| [rsa-pkcs](cloudhsm_cli-key-unwrap-rsa-pkcs.md) | Scompone una chiave di payload utilizzando la chiave privata RSA e il meccanismo di decompressione RSA-PKCS. | CU | 
| [aes-gcm](cloudhsm_cli-key-wrap-aes-gcm.md) | Racchiude una chiave di payload utilizzando una chiave AES sull'HSM e il meccanismo di wrapping AES-GCM. | CU | 
| [aes-no-pad](cloudhsm_cli-key-wrap-aes-no-pad.md) | Avvolge una chiave di payload utilizzando una chiave AES sull'HSM e sul meccanismo di wrapping. AES-NO-PAD | CU | 
| [aes-pkcs5-pad](cloudhsm_cli-key-wrap-aes-pkcs5-pad.md) | Avvolge una chiave di payload utilizzando una chiave AES sull'HSM e il meccanismo di wrapping AES- -PAD. PKCS5 | CU | 
| [aes-zero-pad](cloudhsm_cli-key-wrap-aes-zero-pad.md) | Avvolge una chiave di payload utilizzando una chiave AES sull'HSM e sul meccanismo di wrapping. AES-ZERO-PAD | CU | 
| [cloudhsm-aes-gcm](cloudhsm_cli-key-wrap-cloudhsm-aes-gcm.md) | Avvolge una chiave di payload utilizzando una chiave AES sull'HSM e sul meccanismo di wrapping. CLOUDHSM-AES-GCM | CUs | 
| [rsa-aes](cloudhsm_cli-key-wrap-rsa-aes.md) | Racchiude una chiave di payload utilizzando una chiave pubblica RSA sull'HSM e il meccanismo di wrapping RSA-AES. | CU | 
| [rsa-oaep](cloudhsm_cli-key-wrap-rsa-oaep.md) | Racchiude una chiave di payload utilizzando una chiave pubblica RSA sull'HSM e il meccanismo di wrapping RSA-OAEP. | CU | 
| [ Inserisci una chiave con RSA-PKCS utilizzando la CLI di CloudhSMrsa-pkcs  Il **key wrap rsa-pkcs** comando esegue il wrapping di una chiave di payload utilizzando una chiave pubblica RSA sull'HSM e il meccanismo di wrapping. `RSA-PKCS`   Utilizzate il **key wrap rsa-pkcs** comando nella CLI di CloudHSM per eseguire il wrapping di una chiave di payload utilizzando una chiave pubblica RSA sul modulo di sicurezza hardware (HSM) e sul meccanismo di wrapping. `RSA-PKCS` L'attributo della chiave di payload deve essere impostato su. `extractable` `true` Solo il proprietario di una chiave, ovvero l'utente crittografico (CU) che ha creato la chiave, può impacchettare la chiave. Gli utenti che condividono la chiave possono utilizzarla nelle operazioni crittografiche. Per utilizzare il **key wrap rsa-pkcs** comando, è necessario innanzitutto disporre di una chiave RSA nel cluster AWS CloudHSM . È possibile generare una coppia di chiavi RSA utilizzando il [La generate-asymmetric-pair categoria nella CLI di CloudHSM](cloudhsm_cli-key-generate-asymmetric-pair.md) comando e l'`wrap`attributo `true` impostati su.  Tipo di utente  I seguenti tipi di utenti possono eseguire questo comando.   Utenti Crypto () CUs     Requisiti    Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.     Sintassi  

```
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
```   Esempio  Questo esempio mostra come utilizzare il **key wrap rsa-pkcs** comando utilizzando una chiave pubblica RSA. 

**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=="
  }
```   Arguments (Argomenti)   

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster. 

***<PAYLOAD\$1FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di payload.  
Obbligatorio: sì 

***<PATH>***  
Percorso del file binario in cui verranno salvati i dati chiave racchiusi.  
Obbligatorio: no 

***<WRAPPING\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di avvolgimento.   
Obbligatorio: sì 

***<WRAPPING\$1APPROVALR>***  
Specificate il percorso del file di un file token quorum firmato per approvare l'operazione di wrapping key. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di wrapping è maggiore di 1. 

***<PAYLOAD\$1APPROVALR>***  
Speciifica il percorso del file di un file di token quorum firmato per approvare l'operazione per la chiave di payload. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di payload è maggiore di 1.    Argomenti correlati    [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)   [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)    ](cloudhsm_cli-key-wrap-rsa-pkcs.md) | Racchiude una chiave di payload utilizzando una chiave pubblica RSA sull'HSM e il meccanismo di wrapping RSA-PKCS. | CU | 
| [Login](cloudhsm_cli-login.md) | Accedi AWS CloudHSM al tuo cluster. | Admin, crypto user (CU) e utente dell'applicazione (AU) | 
| [Disconnessione](cloudhsm_cli-logout.md) | Esci dal tuo AWS CloudHSM cluster. | Admin, CU e utente dell'applicazione (AU) | 
| [Quorum token-firma elimina](cloudhsm_cli-qm-token-del.md) | Elimina uno o più token per un servizio autorizzato dal quorum. | Admin | 
| [quorum token-sign generate](cloudhsm_cli-qm-token-gen.md) | Genera un token per un servizio autorizzato dal quorum. | Admin | 
| [quorum token-sign list](cloudhsm_cli-qm-token-list.md) | Elenca tutti i token-firma del quorum presenti nel cluster di CloudHSM. | Tutti [1](#cli-ref-1), compresi gli utenti non autenticati. L'accesso non è necessario. | 
| [firma del token del quorum list-quorum-values](cloudhsm_cli-qm-token-list-qm.md) | Elenca i valori del quorum impostati nel cluster CloudHSM. | Tutti [1](#cli-ref-1), compresi gli utenti non autenticati. L'accesso non è necessario. | 
| [firma-token del quorum set-quorum-value](cloudhsm_cli-qm-token-set-qm.md) | Imposta un nuovo valore di quorum per un servizio autorizzato dal quorum. | Admin | 
| [user change-mfa](cloudhsm_cli-user-change-mfa.md) | Modifica la strategia di autenticazione a più fattori (MFA) di un utente. | Admin, CU | 
| [user change-password](cloudhsm_cli-user-change-password.md) | Modifica le password degli utenti su. HSMs Qualsiasi utente può modificare la propria password. Gli admin possono modificare la password di chiunque. | Admin, CU | 
| [user create](cloudhsm_cli-user-create.md) | Crea un utente nel tuo AWS CloudHSM cluster. | Admin | 
| [user delete](cloudhsm_cli-user-delete.md) | Elimina un utente nel AWS CloudHSM cluster. | Admin | 
| [user list](cloudhsm_cli-user-list.md) | Elenca gli utenti del AWS CloudHSM cluster. | Tutti [1](#cli-ref-1), compresi gli utenti non autenticati. L'accesso non è richiesto. | 
| [Modifica utente-quorum token-firma registra](cloudhsm_cli-user-chqm-token-reg.md) | Registra la strategia del quorum token-firma quorum per un utente. | Admin | 

**Annotazioni**
+ [1] Tutti gli utenti includono tutti i ruoli elencati e gli utenti non connessi.

# La categoria di cluster nella CLI di CloudHSM
<a name="cloudhsm_cli-cluster"></a>

Nella **cluster** CLI di CloudHSM, è una categoria principale per un gruppo di comandi che, se combinati con la categoria principale, creano un comando specifico per i cluster. Attualmente, la categoria cluster è composta dai seguenti comandi:

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

# Attiva un cluster con CloudHSM CLI
<a name="cloudhsm_cli-cluster-activate"></a>

Utilizza il **cluster activate** comando nella CLI di CloudHSM per attivare un [nuovo cluster in](activate-cluster.md). AWS CloudHSMÈ necessario eseguire questo comando prima di poter utilizzare il cluster per eseguire operazioni di crittografia.

## Tipo di utente
<a name="cluster-activate-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Admin non attivato

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

Questo comando non ha parametri.

```
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')
```

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

Questo comando attiva il cluster impostando la password iniziale per l'utente amministratore.

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

## Argomenti correlati
<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)

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

Utilizzate il **cluster hsm-info** comando nella CLI di CloudHSM per elencare i HSMs moduli di sicurezza hardware () nel cluster. AWS CloudHSM Non è necessario che tu abbia eseguito l'accesso alla CLI di CloudHSM per eseguire questo comando.

**Nota**  
Se aggiungi o elimini HSMs, aggiorna i file di configurazione utilizzati dal AWS CloudHSM client e dagli strumenti della riga di comando. In caso contrario, le modifiche apportate potrebbero non essere valide per tutti HSMs gli utenti del cluster.

## Tipo di utente
<a name="chsm-cluster-hsm-info-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Tutti gli utenti. Non è necessario che tu abbia eseguito l'accesso per eseguire questo comando.

## Sintassi
<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
```

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

Questo comando elenca il HSMs presente nel AWS CloudHSM cluster.

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

L'output ha i seguenti attributi:
+ **Fornitore**: il nome del fornitore dell'HSM. 
+ **Modello**: il numero di modello dell'HSM.
+ **Numero di serie**: Il numero di serie dell'HSM. Questo potrebbe cambiare a causa di sostituzioni.
+ **H ardware-version-major**: La versione hardware principale.
+ **H ardware-version-minor**: La versione hardware secondaria.
+ **F irmware-version-major**: La versione principale del firmware.
+ **F irmware-version-minor**: La versione secondaria del firmware.
+ **F irmware-build-number**: Il numero di build del firmware.
+ **Firmware-id**: l'ID del firmware, che include le versioni principali e secondarie insieme al build.
+ **Stato FIPS**: la modalità FIPS del cluster e il suo interno. HSMs In modalità FIPS, l'output è «2 [modalità FIPS con autenticazione a fattore singolo]». In modalità non FIPS, l'output è «0 [modalità non FIPS con autenticazione a fattore singolo]».

## Argomenti correlati
<a name="chsm-cluster-hsm-info-seealso"></a>
+ [Attiva un cluster con CloudHSM CLI](cloudhsm_cli-cluster-activate.md)

# La categoria cluster mtls nella CLI di CloudhSM
<a name="cloudhsm_cli-cluster-mtls"></a>

In CloudHSM **cluster mtls** CLI, è una categoria principale per un gruppo di comandi che, se combinati con la categoria principale, creano un comando specifico per i cluster. AWS CloudHSM Attualmente, questa categoria comprende i seguenti comandi:

**Topics**
+ [deregister-trust-anchor](cloudhsm_cli-cluster-mtls-deregister-trust-anchor.md)
+ [ottenere l'applicazione](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)
+ [imposizione del set](cloudhsm_cli-cluster-mtls-set-enforcement.md)

# Annulla la registrazione di un trust anchor con la CLI di CloudhSM
<a name="cloudhsm_cli-cluster-mtls-deregister-trust-anchor"></a>

Utilizza il **cluster mtls deregister-trust-anchor** comando nella CLI di CloudHSM per annullare la registrazione di un trust anchor per il TLS reciproco tra client e. AWS CloudHSM

## Tipo di utente
<a name="cluster-mtls-deregister-trust-anchor-userType"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Admin

## Requisiti
<a name="cluster-mtls-deregister-trust-anchor-requirements"></a>
+ Per eseguire questo comando, devi accedere come utente amministratore.

## Sintassi
<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
```

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

**Example**  
Nell'esempio seguente, questo comando rimuove un trust anchor dall'HSM.  

```
aws-cloudhsm > cluster mtls deregister-trust-anchor --certificate-reference 0x01
                
{
  "error_code": 0,
  "data": {
    "message": "Trust anchor with reference 0x01 deregistered successfully"
  }
}
```
È quindi possibile eseguire il **list-trust-anchors** comando per confermare che la registrazione di trust anchor è stata cancellata da: AWS CloudHSM  

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

## Arguments (Argomenti)
<a name="cluster-mtls-deregister-trust-anchor-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

** *<CERTIFICATE\$1REFERENCE>* **  
Un riferimento al certificato in formato esadecimale o decimale.  
 **Obbligatorio:** sì  
Dopo aver annullato la registrazione di un trust anchor nel cluster, tutte le connessioni MTLS esistenti che utilizzano il certificato client firmato da quel trust anchor verranno eliminate.

** *<APPROVAL>* **  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del quorum del servizio del cluster quorum è maggiore di 1.

## Argomenti correlati
<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) 
+  [Configurazione MTLs (consigliato)](getting-started-setup-mtls.md) 

# Ottieni il livello di applicazione dell'MTLS con la CLI di CloudhSM
<a name="cloudhsm_cli-cluster-mtls-get-enforcement"></a>

Utilizza il **cluster mtls get-enforcement** comando nella CLI di CloudHSM per ottenere il livello di applicazione dell'uso del TLS reciproco tra client e. AWS CloudHSM

## Tipo di utente
<a name="cluster-mtls-get-enforcement-userType"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Admin
+ Utenti Crypto () CUs

## Requisiti
<a name="cluster-mtls-get-enforcement-requirements"></a>
+ Per eseguire questo comando, devi accedere come utente amministratore o utente crittografico (CUs).

## Sintassi
<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
```

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

**Example**  
Nell'esempio seguente, questo comando elenca il livello di applicazione mtls di. AWS CloudHSM  

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

## Arguments (Argomenti)
<a name="cluster-mtls-get-enforcement-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

## Argomenti correlati
<a name="cluster-mtls-get-enforcement-seealso"></a>
+  [cluster mtls set-enforcement](cloudhsm_cli-cluster-mtls-set-enforcement.md) 
+  [Configurazione MTLs (consigliato)](getting-started-setup-mtls.md) 

# Elenca gli ancoraggi di fiducia con la CLI di CloudhSM
<a name="cloudhsm_cli-cluster-mtls-list-trust-anchors"></a>

Utilizza il **cluster mtls list-trust-anchors** comando nella CLI di CloudHSM per elencare tutti gli ancoraggi di fiducia che possono essere utilizzati per il TLS reciproco tra client e. AWS CloudHSM

## Tipo di utente
<a name="cluster-mtls-list-trust-anchors-userType"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Tutti gli utenti. Non è necessario che tu abbia eseguito l'accesso per eseguire questo comando.

## Sintassi
<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
```

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

**Example**  
Nell'esempio seguente, questo comando elenca tutti gli ancoraggi di fiducia registrati da. 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"
      }
    ]
  }
}
```

## Arguments (Argomenti)
<a name="cluster-mtls-list-trust-anchors-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire l'operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

## Argomenti correlati
<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) 
+  [Configurazione MTLs (consigliato)](getting-started-setup-mtls.md) 

# Registra un trust anchor con la CLI di CloudhSM
<a name="cloudhsm_cli-cluster-mtls-register-trust-anchor"></a>

Usa il **cluster mtls register-trust-anchor** comando nella CLI di CloudHSM per registrare un trust anchor per il TLS reciproco tra client e. AWS CloudHSM

## Tipo di utente
<a name="cluster-mtls-register-trust-anchor-userType"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Admin

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

Accept Trust AWS CloudHSM Anchora con i seguenti tipi di chiavi:


****  

| Tipo di chiavi | Description | 
| --- | --- | 
| EC |  curve secp256r1 (P-256), secp384r1 (P-384) e secp521r1 (P-521).  | 
| RSA |  Chiavi RSA a 2048 bit, 3072 bit e 4096 bit.  | 

## Sintassi
<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
```

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

**Example**  
Nell'esempio seguente, questo comando registra un trust anchor sull'HSM. Il numero massimo di trust anchors che è possibile registrare è due (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"
    }
  }
}
```
È quindi possibile eseguire il **list-trust-anchors** comando per confermare che trust anchor è stato registrato su: 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"
      }
    ]
  }
}
```

## Arguments (Argomenti)
<a name="cluster-mtls-register-trust-anchor-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

** *<PATH>* **  
Percorso del file del trust anchor da registrare.  
 **Obbligatorio:** sì  
AWS CloudHSM supporta la registrazione di certificati intermedi come trust anchor. In questi casi, l'intero file della catena di certificati con codifica PEM deve essere registrato nell'HSM, con i certificati in ordine gerarchico.   
 AWS CloudHSM supporta una catena di certificati di 6980 byte.

** *<APPROVAL>* **  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del quorum del servizio cluster quorum è maggiore di 1.

## Argomenti correlati
<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) 
+  [Configurazione MTLs (consigliato)](getting-started-setup-mtls.md) 

# Imposta il livello di applicazione dell'MTLS con la CLI di CloudhSM
<a name="cloudhsm_cli-cluster-mtls-set-enforcement"></a>

Utilizza il **cluster mtls set-enforcement** comando nella CLI di CloudHSM per impostare il livello di applicazione dell'uso del TLS reciproco tra client e. AWS CloudHSM

## Tipo di utente
<a name="cluster-mtls-set-enforcement-userType"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Amministratore con nome utente come amministratore

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

Per eseguire questo comando:
+ Almeno un trust anchor è stato registrato con successo su. AWS CloudHSM
+ Configura la CLI di CloudHSM con la chiave privata e il certificato client corretti e avvia CloudHSM CLI con una connessione TLS reciproca.
+ Devi accedere come amministratore predefinito con il nome utente «admin». Qualsiasi altro utente amministratore non sarà in grado di eseguire questo comando.

## Sintassi
<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
```

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

**Example**  
Nell'esempio seguente, questo comando imposta il livello di applicazione mtls del cluster AWS CloudHSM to be. Il comando set-enforcement può essere eseguito solo in una connessione TLS reciproca e può essere effettuato l'accesso come utente amministratore con nome utente come amministratore, vedi [impostare](getting-started-setup-mtls.md#getting-start-setup-mtls-enforcement) l'applicazione MTLS per. AWS CloudHSM  

```
aws-cloudhsm > cluster mtls set-enforcement --level cluster
                
{
  "error_code": 0,
  "data": {
    "message": "Mtls enforcement level set to Cluster successfully"
  }
}
```
Puoi quindi eseguire il **get-enforcement** comando per confermare che il livello di applicazione è stato impostato su cluster:  

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

## Arguments (Argomenti)
<a name="cluster-mtls-set-enforcement-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

** *<LEVEL>* **  
Livello da impostare per mtls nel cluster.   
 **Valori validi**   
+  **cluster**: applica l'uso del TLS reciproco tra client e AWS CloudHSM nel cluster.
+  **nessuno**: non imporre l'uso del TLS reciproco tra client e AWS CloudHSM nel cluster.
 **Obbligatorio:** sì  
Dopo aver imposto l'utilizzo di MTLS nel cluster, tutte le connessioni non MTLS esistenti verranno interrotte e sarà possibile connettersi al cluster solo con certificati MTLS.

** *<APPROVAL>* **  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del quorum del servizio del cluster quorum è maggiore di 1.

## Argomenti correlati
<a name="cluster-mtls-set-enforcement-seealso"></a>
+  [cluster mtls get-enforcement](cloudhsm_cli-cluster-mtls-get-enforcement.md) 
+  [Configurazione MTLs (consigliato)](getting-started-setup-mtls.md) 

# La categoria delle criptovalute nella CLI di CloudHSM
<a name="cloudhsm_cli-crypto"></a>

Nella **crypto** CLI di CloudHSM, è una categoria principale per un gruppo di comandi che, se combinati con la categoria principale, creano un comando specifico per le operazioni crittografiche. Attualmente, questa categoria comprende i seguenti comandi: 
+ [Firma](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)
+ [Verifica](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)

# La categoria dei segni crittografici nella CLI di CloudhSM
<a name="cloudhsm_cli-crypto-sign"></a>

Nella **crypto sign** CLI di CloudHSM, è una categoria principale per un gruppo di comandi che, se combinata con la categoria principale, utilizza una chiave privata scelta AWS CloudHSM nel cluster per generare una firma. **crypto sign**ha i seguenti sottocomandi:
+ [Genera una firma con il meccanismo ECDSA nella CLI di CloudhSM](cloudhsm_cli-crypto-sign-ecdsa.md)
+ [Genera una firma con il meccanismo HashEd DSA nella CLI di CloudhSM](cloudhsm_cli-crypto-sign-ed25519ph.md)
+ [Genera una firma con il meccanismo RSA-PKCS nella CLI di CloudHSM](cloudhsm_cli-crypto-sign-rsa-pkcs.md)
+ [Genera una firma con il RSA-PKCS-PSS meccanismo della CLI di CloudhSM](cloudhsm_cli-crypto-sign-rsa-pkcs-pss.md)

Per utilizzarlo**crypto sign**, è necessario disporre di una chiave privata nell'HSM. È possibile generare una chiave privata con i seguenti comandi:
+ [chiave generate-asymmetric-pair ec](cloudhsm_cli-key-generate-asymmetric-pair-ec.md)
+ [chiave generate-asymmetric-pair rsa](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md)

# Genera una firma con il meccanismo ECDSA nella CLI di CloudhSM
<a name="cloudhsm_cli-crypto-sign-ecdsa"></a>

Utilizza il **crypto sign ecdsa** comando nella CLI di CloudHSM per generare una firma utilizzando una chiave privata EC e il meccanismo di firma ECDSA. 

Per utilizzare il **crypto sign ecdsa** comando, devi prima avere una chiave privata EC nel tuo cluster. AWS CloudHSM È possibile generare una chiave privata EC utilizzando il [Genera una coppia di key pair EC asimmetrica con CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair-ec.md) comando con l'`sign`attributo impostato su`true`.

La firma ECDSA risultante viene generata nel formato`r||s`, in cui i componenti r e s sono concatenati come dati binari grezzi e restituiti in formato codificato base64.

**Nota**  
Le firme possono essere verificate con sottocomandi. AWS CloudHSM [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md)

## Tipo di utente
<a name="cloudhsm_cli-crypto-sign-ecdsa-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-crypto-sign-ecdsa-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

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

Questi esempi mostrano come **crypto sign ecdsa** generare una firma utilizzando il meccanismo di firma e la funzione `SHA256` hash ECDSA. Questo comando utilizza una chiave privata nell'HSM.

**Example Esempio: generare una firma per dati codificati in base 64**  

```
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 Esempio: generazione di una firma per un file di dati**  

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

## Arguments (Argomenti)
<a name="cloudhsm_cli-crypto-sign-ecdsa-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<DATA>***  
Dati codificati in Base64 da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<DATA\$1PATH>***  
Speciifica la posizione dei dati da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<HASH\$1FUNCTION>***  
Speciifica la funzione hash.   
Valori validi:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Obbligatorio: sì

***<KEY\$1FILTER>***  
Riferimento chiave (ad esempio`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di attr.KEY\$1ATTRIBUTE\$1NAME=KEY\$1ATTRIBUTE\$1VALUE per selezionare una chiave corrispondente.  
Per un elenco degli attributi chiave CLI di CloudHSM supportati, consulta Attributi chiave per CloudHSM CLI.  
Obbligatorio: sì

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di utilizzo delle chiavi della chiave privata è maggiore di 1.

***<DATA\$1TYPE>***  
 Speciifica se il valore del parametro data deve essere sottoposto a hash come parte dell'algoritmo di firma. Utilizzare `raw` per dati non sottoposti a hash; utilizzare `digest` per digest già sottoposti a hash.   
Valori validi:  
+ raw
+ digerire

## Argomenti correlati
<a name="cloudhsm_cli-crypto-sign-ecdsa-seealso"></a>
+ [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)
+ [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md)

# Genera una firma con il meccanismo HashEd DSA nella CLI di CloudhSM
<a name="cloudhsm_cli-crypto-sign-ed25519ph"></a>

**Importante**  
HashEdLe operazioni di firma DSA sono supportate solo su istanze hsm2m.medium in modalità non FIPS.

Utilizza il **crypto sign ed25519ph** comando nella CLI di CloudHSM per generare una firma utilizzando una chiave privata Ed25519 e il meccanismo di firma DSA. HashEd [Per ulteriori informazioni su HashEd DSA, vedere NIST SP 186-5, Sezione 7.8.](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-5.pdf)

Per utilizzare il **crypto sign ed25519ph** comando, è necessario innanzitutto disporre di una chiave privata Ed25519 nel cluster. AWS CloudHSM È possibile generare una chiave privata Ed25519 utilizzando il [Genera una coppia di key pair EC asimmetrica con CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair-ec.md) comando con il `curve` parametro impostato su `ed25519` e l'`sign`attributo impostato su. `true`

**Nota**  
Le firme possono essere verificate con sottocomandi. AWS CloudHSM [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md)

## Tipo di utente
<a name="cloudhsm_cli-crypto-sign-ed25519ph-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-crypto-sign-ed25519ph-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.
+ HashEdLe operazioni di firma DSA sono supportate solo su istanze hsm2m.medium in modalità non FIPS.

## Sintassi
<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
```

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

Questi esempi mostrano come generare una firma utilizzando il meccanismo di firma e **crypto sign ed25519ph** la funzione hash ED25519ph. `sha512` Questo comando utilizza una chiave privata nell'HSM.

**Example Esempio: generare una firma per dati codificati in base 64**  

```
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 Esempio: generazione di una firma per un file di dati**  

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

## Arguments (Argomenti)
<a name="cloudhsm_cli-crypto-sign-ed25519ph-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<DATA>***  
Dati codificati in Base64 da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<DATA\$1PATH>***  
Speciifica la posizione dei dati da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il parametro data)

***<HASH\$1FUNCTION>***  
Specifica la funzione hash. ED25519ph supporta solo. SHA512   
Valori validi:  
+ sha512
Obbligatorio: sì

***<KEY\$1FILTER>***  
Riferimento alla chiave (ad esempio`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma di attr.KEY\$1ATTRIBUTE\$1NAME=KEY\$1ATTRIBUTE\$1VALUE per selezionare una chiave corrispondente.  
Per un elenco degli attributi chiave CLI di CloudHSM supportati, consulta. [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)  
Obbligatorio: sì

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di utilizzo delle chiavi della chiave privata è maggiore di 1.

***<DATA\$1TYPE>***  
 Speciifica se il valore del parametro data deve essere sottoposto a hash come parte dell'algoritmo di firma. Utilizzare `raw` per dati non sottoposti a hash; utilizzare `digest` per digest già sottoposti a hash.   
Valori validi:  
+ raw
+ digerire
Campo obbligatorio: sì

## Argomenti correlati
<a name="cloudhsm_cli-crypto-sign-ed25519ph-seealso"></a>
+ [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)
+ [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md)

# Genera una firma con il meccanismo RSA-PKCS nella CLI di CloudHSM
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs"></a>

Utilizza il **crypto sign rsa-pkcs** comando nella CLI di CloudHSM per generare una firma utilizzando una chiave privata RSA e il meccanismo di firma RSA-PKCS.

Per utilizzare il **crypto sign rsa-pkcs** comando, devi prima avere una chiave privata RSA nel cluster. AWS CloudHSM È possibile generare una chiave privata RSA utilizzando il [Genera una coppia di key pair RSA asimmetrica con CloudhSM CLI](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md) comando con l'`sign`attributo impostato su. `true`

**Nota**  
Le firme possono essere verificate AWS CloudHSM con [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md) sottocomandi.

## Tipo di utente
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

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

Questi esempi mostrano come **crypto sign rsa-pkcs** generare una firma utilizzando il meccanismo di firma RSA-PKCS e la funzione hash. `SHA256` Questo comando utilizza una chiave privata nell'HSM.

**Example Esempio: generare una firma per dati codificati in base 64**  

```
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 Esempio: generazione di una firma per un file di dati**  

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

## Arguments (Argomenti)
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<DATA>***  
Dati codificati in Base64 da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<DATA\$1PATH>***  
Speciifica la posizione dei dati da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite i dati)

***<HASH\$1FUNCTION>***  
Specifica la funzione hash.   
Valori validi:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Obbligatorio: sì

***<KEY\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave corrispondente.  
Per un elenco degli attributi chiave CLI di CloudHSM supportati, consulta Attributi chiave per CloudHSM CLI.  
Obbligatorio: sì

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di utilizzo delle chiavi della chiave privata è maggiore di 1.

***<DATA\$1TYPE>***  
 Speciifica se il valore del parametro data deve essere sottoposto a hash come parte dell'algoritmo di firma. Utilizzare `raw` per dati non sottoposti a hash; utilizzare `digest` per digest già sottoposti a hash.   
[Per RSA-PKCS, i dati devono essere passati nel formato codificato DER come specificato in RFC 8017, Sezione 9.2](https://www.rfc-editor.org/rfc/rfc8017#section-9.2)  
Valori validi:  
+ raw
+ digerire

## Argomenti correlati
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-seealso"></a>
+ [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)
+ [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md)

# Genera una firma con il RSA-PKCS-PSS meccanismo della CLI di CloudhSM
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-pss"></a>

Utilizza il **crypto sign rsa-pkcs-pss** comando nella CLI di CloudHSM per generare una firma utilizzando una chiave privata RSA e il meccanismo di firma. `RSA-PKCS-PSS`

Per utilizzare il **crypto sign rsa-pkcs-pss** comando, devi prima avere una chiave privata RSA nel cluster. AWS CloudHSM È possibile generare una chiave privata RSA utilizzando il [Genera una coppia di key pair RSA asimmetrica con CloudhSM CLI](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md) comando con l'`sign`attributo impostato su. `true`

**Nota**  
Le firme possono essere verificate AWS CloudHSM con [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md) sottocomandi.

## Tipo di utente
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

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

Questi esempi mostrano come **crypto sign rsa-pkcs-pss** generare una firma utilizzando il meccanismo di firma e la `RSA-PKCS-PSS` funzione `SHA256` hash. Questo comando utilizza una chiave privata nell'HSM.

**Example Esempio: generare una firma per dati codificati in base 64**  

```
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 Esempio: generazione di una firma per un file di dati**  

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

## Arguments (Argomenti)
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<DATA>***  
Dati codificati Base64 da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<DATA\$1PATH>***  
Speciifica la posizione dei dati da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite i dati)

***<HASH\$1FUNCTION>***  
Speciifica la funzione hash.   
Valori validi:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Obbligatorio: sì

***<KEY\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave corrispondente.  
Per un elenco degli attributi chiave CLI di CloudHSM supportati, consulta Attributi chiave per CloudHSM CLI.  
Obbligatorio: sì

***<MGF>***  
Specifica la funzione di generazione della maschera.  
La funzione hash della funzione di generazione della maschera deve corrispondere alla funzione hash del meccanismo di firma.
Valori validi:  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Obbligatorio: sì

***<SALT\$1LENGTH>***  
Specifica la lunghezza del sale.  
Obbligatorio: sì

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di utilizzo delle chiavi della chiave privata è maggiore di 1.

***<DATA\$1TYPE>***  
 Speciifica se il valore del parametro data deve essere sottoposto a hash come parte dell'algoritmo di firma. Utilizzare `raw` per dati non sottoposti a hash; utilizzare `digest` per digest già sottoposti a hash.   
Valori validi:  
+ raw
+ digerire

## Argomenti correlati
<a name="cloudhsm_cli-crypto-sign-rsa-pkcs-seealso"></a>
+ [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)
+ [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md)

## Argomenti correlati
<a name="cloudhsm_cli-crypto-sign-seealso"></a>
+ [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md)

# La categoria crypto verify nella CLI di CloudHSM
<a name="cloudhsm_cli-crypto-verify"></a>

Nella CLI di CloudHSM, è una categoria principale per un gruppo di comandi che, se combinata con la categoria principale, conferma se un file è stato firmato da una determinata **crypto verify** chiave. **crypto verify**ha i seguenti sottocomandi: 
+ [crypto verify ecdsa](cloudhsm_cli-crypto-verify-ecdsa.md)
+ [verifica crittografica ed25519ph](cloudhsm_cli-crypto-verify-ed25519ph.md)
+ [verifica crittografica rsa-pkcs](cloudhsm_cli-crypto-verify-rsa-pkcs.md)
+ [verifica crittografica rsa-pkcs-pss](cloudhsm_cli-crypto-verify-rsa-pkcs-pss.md)

Il **crypto verify** comando confronta un file firmato con un file sorgente e analizza se sono correlati crittograficamente in base a una determinata chiave pubblica e a un determinato meccanismo di firma.

**Nota**  
I file possono essere registrati con l'operazione. AWS CloudHSM [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)

# Verifica una firma firmata con il meccanismo ECDSA nella CLI di CloudHSM
<a name="cloudhsm_cli-crypto-verify-ecdsa"></a>

Utilizzate il **crypto verify ecdsa** comando nella CLI di CloudHSM per completare le seguenti operazioni:
+ Conferma che un file è stato firmato nell'HSM con una determinata chiave pubblica.
+ Verifica che la firma sia stata generata utilizzando il meccanismo di firma ECDSA.
+ Confronta un file firmato con un file sorgente e determina se i due sono correlati crittograficamente in base a una determinata chiave pubblica ecdsa e a un determinato meccanismo di firma. 
+  La funzione di verifica ECDSA prevede la firma nel formato`r||s`, in cui i componenti r e s sono concatenati come dati binari non elaborati. 

Per utilizzare il **crypto verify ecdsa** comando, è necessario innanzitutto disporre di una chiave pubblica EC nel cluster. AWS CloudHSM È possibile importare una chiave pubblica EC utilizzando il [Importa una chiave in formato PEM con CloudhSM CLI](cloudhsm_cli-key-import-pem.md) comando con l'`verify`attributo impostato su`true`.

**Nota**  
È possibile generare una firma nella CLI di CloudHSM con sottocomandi. [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)

## Tipo di utente
<a name="cloudhsm_cli-crypto-verify-ecdsa-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-crypto-verify-ecdsa-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

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

Questi esempi mostrano come **crypto verify ecdsa** verificare una firma generata utilizzando il meccanismo di firma e la funzione `SHA256` hash ECDSA. Questo comando utilizza una chiave pubblica nell'HSM.

**Example Esempio: verifica una firma codificata Base64 con dati codificati Base64**  

```
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 Esempio: verifica un file di firma con un file di dati**  

```
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 Esempio: dimostrare una relazione con falsi firmi**  
Questo comando verifica se i dati presenti in sono `/home/data` stati firmati da una chiave pubblica con l'etichetta `ecdsa-public` utilizzando il meccanismo di firma ECDSA per produrre la firma che si trova in. `/home/signature` Poiché gli argomenti forniti non costituiscono una vera relazione di firma, il comando restituisce un messaggio di errore.  

```
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"
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-crypto-verify-ecdsa-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire l'operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<DATA>***  
Dati codificati in Base64 da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<DATA\$1PATH>***  
Speciifica la posizione dei dati da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<HASH\$1FUNCTION>***  
Specifica la funzione hash.   
Valori validi:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Obbligatorio: sì

***<KEY\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave corrispondente.  
Per un elenco degli attributi chiave CLI di CloudHSM supportati, consulta Attributi chiave per CloudHSM CLI.  
Obbligatorio: sì

***<SIGNATURE>***  
Firma codificata Base64.  
Obbligatorio: Sì (a meno che non sia fornita tramite il percorso della firma)

***<SIGNATURE\$1PATH>***  
Speciifica la posizione della firma.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso della firma)

***<DATA\$1TYPE>***  
 Speciifica se il valore del parametro data deve essere sottoposto a hash come parte dell'algoritmo di firma. Utilizzare `raw` per dati non sottoposti a hash; utilizzare `digest` per digest già sottoposti a hash.   
Valori validi:  
+ raw
+ digerire

## Argomenti correlati
<a name="cloudhsm_cli-crypto-verify-ecdsa-seealso"></a>
+ [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)
+ [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md)

# Verifica una firma firmata con il meccanismo HashEd DSA nella CLI di CloudhSM
<a name="cloudhsm_cli-crypto-verify-ed25519ph"></a>

**Importante**  
HashEdLe operazioni di verifica della firma DSA sono supportate solo sulle istanze hsm2m.medium in modalità non FIPS.

Utilizzate il **crypto verify ed25519ph** comando nella CLI di CloudHSM per completare le seguenti operazioni:
+ Verifica le firme di dati o file utilizzando una determinata chiave pubblica Ed25519.
+ Conferma che la firma è stata generata utilizzando il meccanismo di firma HashEd DSA. Per ulteriori informazioni su HashEd DSA, vedere [NIST SP 186-5](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-5.pdf), Sezione 7.8.

Per utilizzare il **crypto verify ed25519ph** comando, è necessario innanzitutto disporre di una chiave pubblica Ed25519 nel cluster. AWS CloudHSM È possibile generare una coppia di chiavi Ed25519 utilizzando il [Genera una coppia di key pair EC asimmetrica con CloudHSM CLI](cloudhsm_cli-key-generate-asymmetric-pair-ec.md) comando con il `curve` parametro impostato su `ed25519` e l'`verify`attributo impostato su`true`, oppure importare una chiave pubblica Ed25519 utilizzando il [Importa una chiave in formato PEM con CloudhSM CLI](cloudhsm_cli-key-import-pem.md) comando con l'`verify`attributo impostato su. `true`

**Nota**  
È possibile generare una firma nella CLI di CloudHSM con sottocomandi. [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)

## Tipo di utente
<a name="cloudhsm_cli-crypto-verify-ed25519ph-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-crypto-verify-ed25519ph-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.
+ HashEdLe operazioni di verifica della firma DSA sono supportate solo su istanze hsm2m.medium in modalità non FIPS.

## Sintassi
<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
```

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

Questi esempi mostrano come verificare una firma generata utilizzando **crypto verify ed25519ph** il meccanismo di firma e la funzione hash ED25519ph. `sha512` Questo comando utilizza una chiave pubblica Ed25519 nell'HSM.

**Example Esempio: verifica una firma codificata Base64 con dati codificati Base64**  

```
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 Esempio: verifica un file di firma con un file di dati**  

```
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"
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-crypto-verify-ed25519ph-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<DATA>***  
Dati codificati Base64 da verificare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<DATA\$1PATH>***  
Speciifica la posizione dei dati da verificare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il parametro data)

***<HASH\$1FUNCTION>***  
Specifica la funzione hash. ED25519ph supporta solo. SHA512   
Valori validi:  
+ sha512
Obbligatorio: sì

***<KEY\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave corrispondente.  
Per un elenco degli attributi chiave CLI di CloudHSM supportati, consulta. [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)  
Obbligatorio: sì

***<SIGNATURE>***  
Firma codificata Base64.  
Obbligatorio: Sì (a meno che non sia fornita tramite il percorso della firma)

***<SIGNATURE\$1PATH>***  
Speciifica la posizione della firma.  
Obbligatorio: Sì (a meno che non sia fornito tramite il parametro signature)

***<DATA\$1TYPE>***  
 Speciifica se il valore del parametro data deve essere sottoposto a hash come parte dell'algoritmo di verifica. Utilizzare `raw` per dati non sottoposti a hash; utilizzare `digest` per digest già sottoposti a hash.   
Valori validi:  
+ raw
+ digerire
Campo obbligatorio: sì

## Argomenti correlati
<a name="cloudhsm_cli-crypto-verify-ed25519ph-seealso"></a>
+ [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)
+ [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md)
+ [Genera una firma con il meccanismo HashEd DSA nella CLI di CloudhSM](cloudhsm_cli-crypto-sign-ed25519ph.md)

# Verifica una firma firmata con il meccanismo RSA-PKCS nella CLI di CloudHSM
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs"></a>

Utilizzate il **crypto verify rsa-pkcs** comando nella CLI di CloudHSM e completate le seguenti operazioni:
+ Conferma che un file è stato firmato nell'HSM con una determinata chiave pubblica.
+ Verifica che la firma sia stata generata utilizzando il meccanismo di `RSA-PKCS` firma.
+ Confronta un file firmato con un file sorgente e determina se i due sono correlati crittograficamente in base a una determinata chiave pubblica rsa e a un determinato meccanismo di firma.

Per utilizzare il **crypto verify rsa-pkcs** comando, è necessario innanzitutto disporre di una chiave pubblica RSA nel cluster. AWS CloudHSM 

**Nota**  
È possibile generare una firma utilizzando la CLI CloudhSM con i sottocomandi. [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)

## Tipo di utente
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

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

Questi esempi mostrano come **crypto verify rsa-pkcs** verificare una firma generata utilizzando il meccanismo di firma e la funzione hash RSA-PKCS. `SHA256` Questo comando utilizza una chiave pubblica nell'HSM.

**Example Esempio: verifica una firma codificata Base64 con dati codificati Base64**  

```
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 Esempio: verifica un file di firma con un file di dati**  

```
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 Esempio: dimostrare una relazione con falsi firmi**  
Questo comando verifica se i dati non validi sono stati firmati da una chiave pubblica con l'etichetta `rsa-public` utilizzando il meccanismo di firma RSAPKCS per produrre la firma che si trova in. `/home/signature` Poiché gli argomenti forniti non costituiscono una vera relazione di firma, il comando restituisce un messaggio di errore.  

```
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"
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire l'operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<DATA>***  
Dati codificati Base64 da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<DATA\$1PATH>***  
Speciifica la posizione dei dati da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<HASH\$1FUNCTION>***  
Speciifica la funzione hash.   
Valori validi:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Obbligatorio: sì

***<KEY\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave corrispondente.  
Per un elenco degli attributi chiave CLI di CloudHSM supportati, consulta Attributi chiave per CloudHSM CLI.  
Obbligatorio: sì

***<SIGNATURE>***  
Firma codificata Base64.  
Obbligatorio: Sì (a meno che non sia fornita tramite il percorso della firma)

***<SIGNATURE\$1PATH>***  
Speciifica la posizione della firma.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso della firma)

***<DATA\$1TYPE>***  
 Speciifica se il valore del parametro data deve essere sottoposto a hash come parte dell'algoritmo di firma. Utilizzare `raw` per dati non sottoposti a hash; utilizzare `digest` per digest già sottoposti a hash.   
[Per RSA-PKCS, i dati devono essere passati nel formato codificato DER come specificato in RFC 8017, Sezione 9.2](https://www.rfc-editor.org/rfc/rfc8017#section-9.2)  
Valori validi:  
+ raw
+ digerire

## Argomenti correlati
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-seealso"></a>
+ [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)
+ [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md)

# Verifica una firma firmata con il RSA-PKCS-PSS meccanismo nella CLI di CloudhSM
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-pss"></a>

Utilizzate il **crypto sign rsa-pkcs-pss** comando nella CLI di CloudHSM per completare le seguenti operazioni.
+ Conferma che un file è stato firmato nell'HSM con una determinata chiave pubblica.
+ Verifica che la firma sia stata generata utilizzando il meccanismo di RSA-PKCS-PSS firma.
+ Confronta un file firmato con un file sorgente e determina se i due sono correlati crittograficamente in base a una determinata chiave pubblica rsa e a un determinato meccanismo di firma.

Per utilizzare il **crypto verify rsa-pkcs-pss** comando, è necessario innanzitutto disporre di una chiave pubblica RSA nel cluster. AWS CloudHSM È possibile importare una chiave pubblica RSA utilizzando il comando key import pem (ADD UNWRAP LINK HERE) con l'`verify`attributo impostato su. `true`

**Nota**  
È possibile generare una firma utilizzando la CLI CloudhSM con i sottocomandi. [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)

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

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-pss-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

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

Questi esempi mostrano come **crypto verify rsa-pkcs-pss** verificare una firma generata utilizzando il meccanismo di RSA-PKCS-PSS firma e la funzione `SHA256` hash. Questo comando utilizza una chiave pubblica nell'HSM.

**Example Esempio: verifica una firma codificata Base64 con dati codificati Base64**  

```
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 Esempio: verifica un file di firma con un file di dati**  

```
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 Esempio: dimostrare una relazione con falsi firmi**  
Questo comando verifica se i dati non validi sono stati firmati da una chiave pubblica con l'etichetta `rsa-public` utilizzando il meccanismo di firma RSAPKCSPSS per produrre la firma che si trova in. `/home/signature` Poiché gli argomenti forniti non costituiscono una vera relazione di firma, il comando restituisce un messaggio di errore.  

```
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"
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-pss-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire l'operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<DATA>***  
Dati codificati in Base64 da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<DATA\$1PATH>***  
Speciifica la posizione dei dati da firmare.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<HASH\$1FUNCTION>***  
Specifica la funzione hash.   
Valori validi:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Obbligatorio: sì

***<KEY\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave corrispondente.  
Per un elenco degli attributi chiave CLI di CloudHSM supportati, consulta Attributi chiave per CloudHSM CLI.  
Obbligatorio: sì

***<MFG>***  
Specifica la funzione di generazione della maschera.  
La funzione hash della funzione di generazione della maschera deve corrispondere alla funzione hash del meccanismo di firma.
Valori validi:  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Obbligatorio: sì

***<SIGNATURE>***  
Firma codificata Base64.  
Obbligatorio: Sì (a meno che non sia fornita tramite il percorso della firma)

***<SIGNATURE\$1PATH>***  
Specifica la posizione della firma.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso della firma)

***<DATA\$1TYPE>***  
 Speciifica se il valore del parametro data deve essere sottoposto a hash come parte dell'algoritmo di firma. Utilizzare `raw` per dati non sottoposti a hash; utilizzare `digest` per digest già sottoposti a hash.   
Valori validi:  
+ raw
+ digerire

## Argomenti correlati
<a name="cloudhsm_cli-crypto-verify-rsa-pkcs-pss-seealso"></a>
+ [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)
+ [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md)

# La categoria chiave della CLI di CloudHSM
<a name="cloudhsm_cli-key"></a>

Nella **key** CLI di CloudHSM, è una categoria principale per un gruppo di comandi che, se combinati con la categoria principale, creano un comando specifico per le chiavi. Attualmente, questa categoria comprende i seguenti comandi:
+ [Elimina](cloudhsm_cli-key-delete.md)
+ [Generazione-file](cloudhsm_cli-key-generate-file.md)
+ [key generate-asymmetric-pair](cloudhsm_cli-key-generate-asymmetric-pair.md)
  + [ generate-asymmetric-pairchiave rsa](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md)
  + [chiave ec generate-asymmetric-pair](cloudhsm_cli-key-generate-asymmetric-pair-ec.md)
+ [Generazione chiavi-simmetriche](cloudhsm_cli-key-generate-symmetric.md)
  + [Generazione chiavi-simmetriche aes](cloudhsm_cli-key-generate-symmetric-aes.md)
  + [Generazione chiavi-simmetriche generiche-segrete](cloudhsm_cli-key-generate-symmetric-generic-secret.md)
+ [importa pem](cloudhsm_cli-key-import-pem.md)
+ [elenco](cloudhsm_cli-key-list.md)
+ [replicare](cloudhsm_cli-key-replicate.md)
+ [Set-attributi](cloudhsm_cli-key-set-attribute.md)
+ [Condivisione](cloudhsm_cli-key-share.md)
+ [Annulla condivisione](cloudhsm_cli-key-unshare.md)
+ [scartare](cloudhsm_cli-key-unwrap.md)
+ [avvolgere](cloudhsm_cli-key-wrap.md)

# Eliminare una chiave con CloudHSM CLI
<a name="cloudhsm_cli-key-delete"></a>

Utilizzate il **key delete** comando nella CLI di CloudHSM per eliminare una chiave da un cluster. AWS CloudHSM Puoi eliminare soltanto una chiave alla volta. L'eliminazione di una chiave di una coppia di chiavi non influisce sull'altra chiave della coppia. 

Solo il CU che ha creato la chiave e di conseguenza la possiede può eliminarla. Gli utenti che condividono la chiave possono utilizzarla nelle operazioni di crittografia, ma non possono eliminarla.

## Tipo di utente
<a name="key-delete-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="key-delete-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempio
<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"
  }
}
```

## Arguments (Argomenti)
<a name="key-delete-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave corrispondente da eliminare.  
Per un elenco degli attributi delle chiavi supportati dalla CLI di CloudHSM, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)  
Campo obbligatorio: sì

## Argomenti correlati
<a name="key-delete-seealso"></a>
+ [Elenca le chiavi per un utente con CLI CloudhSM](cloudhsm_cli-key-list.md)
+ [Esportazione di una chiave asimmetrica con CLI CloudhSM](cloudhsm_cli-key-generate-file.md)
+ [Annullare la condivisione di una chiave utilizzando la CLI di CloudhSM](cloudhsm_cli-key-unshare.md)
+ [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)
+ [Filtrare le chiavi utilizzando la CLI di CloudHSM](manage-keys-cloudhsm-cli-filtering.md)

# Esportazione di una chiave asimmetrica con CLI CloudhSM
<a name="cloudhsm_cli-key-generate-file"></a>

Utilizzate il **key generate-file** comando nella CLI di CloudHSM per esportare una chiave asimmetrica dal modulo di sicurezza hardware (HSM). Se la destinazione è una chiave privata, il riferimento alla chiave privata verrà esportato in formato PEM falso. Se la destinazione è una chiave pubblica, i byte della chiave pubblica verranno esportati in formato PEM.

Il file PEM falso, che non contiene l'effettivo materiale della chiave privata ma fa invece riferimento alla chiave privata nell'HSM, può essere utilizzato per stabilire l' SSL/TLS offload dal server Web a. AWS CloudHSM Per ulteriori informazioni, vedi [Offload SSL/TLS](ssl-offload.md).

## Tipo di utente
<a name="key-generate-file-user-type"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

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

Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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')
```

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

Questo esempio mostra come utilizzare **key generate-file** per generare un file chiave nel AWS CloudHSM cluster.

**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"
  }
}
```

## Arguments (Argomenti)
<a name="key-generate-file-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave corrispondente da eliminare.  
Per un elenco degli attributi chiave della CLI di CloudHSM supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)  
Obbligatorio: no

***<ENCODING>***  
Specifica il formato di codifica per il file di chiavi  
Obbligatorio: sì

***<PATH>***  
Specifica il percorso del file in cui verrà scritto il file di chiavi  
Obbligatorio: sì

## Generazione di riferimenti chiave KSP (Windows)
<a name="key-generate-ksp-key-reference"></a>

**Nota**  
Questa funzionalità è disponibile solo nella versione SDK 5.16.0 e successive.

### Prerequisiti
<a name="key-generate-ksp-key-reference-requirements"></a>
+ È possibile generare riferimenti chiave KSP solo su piattaforme Windows.
+ Devi accedere come utente crittografico (CU).

### Posizione del file
<a name="key-generate-ksp-key-reference-options"></a>

Per impostazione predefinita, AWS CloudHSM archivia i file generati in: `C:\Users\Default\AppData\Roaming\Microsoft\Crypto\CaviumKSP\GlobalPartition`

Per specificare una posizione diversa, usa il `--path` parametro.

### Sintassi
<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')
```

### Esempio: genera un riferimento a una chiave KSP utilizzando un filtro di attributi di una chiave privata
<a name="key-generate-ksp-key-reference-example1"></a>

L'esempio seguente genera un riferimento alla chiave KSP per una chiave privata con un'etichetta specifica.

**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"
  }
}
```

### Esempio: genera riferimenti chiave KSP per tutte le coppie di chiavi
<a name="key-generate-ksp-key-reference-example2"></a>

L'esempio seguente genera riferimenti alle chiavi KSP per tutte le coppie di chiavi del cluster.

**Example**  

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

## Argomenti correlati
<a name="key-generate-file-seealso"></a>
+ [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)
+ [Filtrare le chiavi utilizzando la CLI di CloudHSM](manage-keys-cloudhsm-cli-filtering.md)
+ [La generate-asymmetric-pair categoria nella CLI di CloudHSM](cloudhsm_cli-key-generate-asymmetric-pair.md)
+ [La categoria generate-symmetric nella CLI di CloudhSM](cloudhsm_cli-key-generate-symmetric.md)

# La generate-asymmetric-pair categoria nella CLI di CloudHSM
<a name="cloudhsm_cli-key-generate-asymmetric-pair"></a>

Nella CLI di CloudHSM, è una categoria principale per un gruppo di comandi che, se combinati con la categoria principale, creano un comando che genera coppie di chiavi **key generate-asymmetric-pair** asimmetriche. Attualmente, questa categoria comprende i seguenti comandi:
+ [ generate-asymmetric-pairchiave ec](cloudhsm_cli-key-generate-asymmetric-pair-ec.md)
+ [chiave generate-asymmetric-pair rsa](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md)

# Genera una coppia di key pair EC asimmetrica con CloudHSM CLI
<a name="cloudhsm_cli-key-generate-asymmetric-pair-ec"></a>

Utilizza il **key asymmetric-pair ec** comando nella CLI di CloudHSM per generare una coppia di chiavi a curva ellittica (EC) asimmetrica nel cluster. AWS CloudHSM 

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

I seguenti tipi di utenti possono eseguire questo comando.
+ CUsUtenti Crypto ()

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

Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

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

Questi esempi mostrano come utilizzare il comando **key generate-asymmetric-pair ec** per creare una coppia di chiavi EC.

**Example Esempio: Creare una coppia di chiavi EC**  

```
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 Esempio: Creare una coppia di chiavi EC con attributi opzionali**  

```
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 Esempio: creazione di una coppia di chiavi EC con valori quorum**  
Quando si genera una chiave con controlli del quorum, la chiave deve essere associata a un numero minimo di utenti pari al valore del quorum chiave massimo. Gli utenti associati includono il proprietario della chiave e gli utenti Crypto con cui viene condivisa la chiave. Per determinare il numero minimo di utenti con cui condividere la chiave, ottieni il valore di quorum più alto tra il valore del quorum di utilizzo della chiave e il valore del quorum di gestione delle chiavi e sottrai 1 per tenere conto del proprietario della chiave, che per impostazione predefinita è associato alla chiave. Per condividere la chiave con più utenti, usa il comando. **[Condividi una chiave utilizzando la CLI di CloudHSM](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"
      }
    }
  }
}
```

## Arguments (Argomenti)
<a name="key-generate-asymmetric-pair-ec-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<CURVE>***  
Specifica l'identificatore per la curva ellittica.  
+ prime256v1
+ secp256r1
+ secp224r1
+ secp384r1
+ secp256k1
+ secp521r1
+ ed25519 (supportato solo su istanze hsm2m.medium in modalità non FIPS)
Obbligatorio: sì

***<PUBLIC\$1KEY\$1ATTRIBUTES>***  
Specifica un elenco separato da spazi di attributi delle chiavi da impostare per la chiave pubblica EC generata sotto forma di `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (ad esempio `verify=true`)  
Per un elenco degli attributi delle chiavi supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md).  
Obbligatorio: no

***<PUBLIC\$1LABEL>***  
Specifica un'etichetta definita dall'utente per la chiave pubblica. La dimensione massima consentita è di 127 caratteri per `label` Client SDK 5.11 e versioni successive. Client SDK 5.10 e versioni precedenti hanno un limite di 126 caratteri.  
Obbligatorio: sì

***<PRIVATE\$1KEY\$1ATTRIBUTES>***  
Specifica un elenco separato da spazi di attributi delle chiavi da impostare per la chiave privata EC generata sotto forma di `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (ad esempio `sign=true`)  
Per un elenco degli attributi delle chiavi supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md).  
Obbligatorio: no

***<PRIVATE\$1LABEL>***  
Specifica un'etichetta definita dall'utente per la chiave privata. La dimensione massima consentita `label` è di 127 caratteri per Client SDK 5.11 e versioni successive. Client SDK 5.10 e versioni precedenti hanno un limite di 126 caratteri.  
Obbligatorio: sì

***<SESSION>***  
Crea una chiave che esiste solo nella sessione corrente. La chiave non può essere recuperata dopo la fine della sessione.  
Utilizza questo parametro quando hai bisogno di una chiave solo per un breve periodo, ad esempio una chiave di wrapping che crittografa e quindi decodifica rapidamente un'altra chiave. Non utilizzare una chiave di sessione per crittografare dati che potresti aver bisogno di decodificare al termine della sessione.  
Per impostazione predefinita, le chiavi generate sono chiavi persistenti (token). L'inserimento dell'argomento <SESSIONE> modifica la situazione, assicurando che una chiave generata con questo argomento sia una chiave di sessione (effimera).  
Obbligatorio: no

***<SHARE\$1CRYPTO\$1USERS>***  
Specifica un elenco separato da spazi di nomi utente Crypto User con cui condividere la chiave privata EC  
Obbligatorio: no

***<MANAGE\$1PRIVATE\$1KEY\$1QUORUM\$1VALUE>***  
Il valore del quorum per le operazioni di gestione delle chiavi della chiave privata. Questo valore deve essere inferiore o uguale al numero di utenti a cui è associata la chiave. Ciò include gli utenti con cui viene condivisa la chiave e il proprietario della chiave. Valore massimo di 8.  
Obbligatorio: no

***<USE\$1PRIVATE\$1KEY\$1QUORUM\$1VALUE>***  
Il valore del quorum per le operazioni di utilizzo delle chiavi private. Questo valore deve essere inferiore o uguale al numero di utenti a cui è associata la chiave. Ciò include gli utenti con cui viene condivisa la chiave e il proprietario della chiave. Valore massimo di 8.  
Obbligatorio: no

## Argomenti correlati
<a name="key-generate-asymmetric-pair-ec-seealso"></a>
+ [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)
+ [Filtrare le chiavi utilizzando la CLI di CloudHSM](manage-keys-cloudhsm-cli-filtering.md)

# Genera una coppia di key pair RSA asimmetrica con CloudhSM CLI
<a name="cloudhsm_cli-key-generate-asymmetric-pair-rsa"></a>

Usa il **key generate-asymmetric-pair rsa** comando nella CLI di CloudHSM per generare una coppia di key pair RSA asimmetrica nel tuo cluster. AWS CloudHSM 

## Tipo di utente
<a name="key-generate-asymmetric-pair-rsa-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ CUsUtenti Crypto ()

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

Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

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

Questi esempi mostrano come utilizzare `key generate-asymmetric-pair rsa` per creare una coppia di chiavi RSA.

**Example Esempio: Creare una coppia di chiavi RSA**  

```
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 Esempio: Creare una coppia di chiavi RSA con attributi opzionali**  

```
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 Esempio: creare una coppia di key pair RSA con valori quorum**  
Quando si genera una chiave con controlli del quorum, la chiave deve essere associata a un numero minimo di utenti pari al valore del quorum della chiave massimo. Gli utenti associati includono il proprietario della chiave e gli utenti Crypto con cui viene condivisa la chiave. Per determinare il numero minimo di utenti con cui condividere la chiave, ottieni il valore di quorum più alto tra il valore del quorum di utilizzo della chiave e il valore del quorum di gestione delle chiavi e sottrai 1 per tenere conto del proprietario della chiave, che per impostazione predefinita è associato alla chiave. Per condividere la chiave con più utenti, usa il comando. **[Condividi una chiave utilizzando la CLI di CloudHSM](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
      }
    }
  }
}
```

## Arguments (Argomenti)
<a name="key-generate-asymmetric-pair-rsa-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<MODULUS\$1SIZE\$1BITS>***  
 Specifica la lunghezza del modulo in bit. Il valore minimo è 2048.   
Obbligatorio: sì

***<PRIVATE\$1KEY\$1ATTRIBUTES>***  
Specifica un elenco separato da spazi di attributi di chiavi da impostare per la chiave privata RSA generata sotto forma di `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (ad esempio `sign=true`)  
Per un elenco degli attributi di chiavi supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md).  
Obbligatorio: no

***<PRIVATE\$1LABEL>***  
 Specifica un'etichetta definita dall'utente per la chiave privata. La dimensione massima consentita `label` è di 127 caratteri per Client SDK 5.11 e versioni successive. Client SDK 5.10 e versioni precedenti hanno un limite di 126 caratteri.  
Obbligatorio: sì

***<PUBLIC\$1EXPONENT>***  
Specifica l'esponente pubblico. Il valore deve essere un numero dispari maggiore o uguale a 65537.  
Obbligatorio: sì

***<PUBLIC\$1KEY\$1ATTRIBUTES>***  
Specifica un elenco separato da spazi di attributi chiave da impostare per la chiave pubblica RSA generata sotto forma di `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (ad esempio `verify=true`)  
Per un elenco degli attributi delle chiavi supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md).  
Obbligatorio: no

***<PUBLIC\$1LABEL>***  
 Specifica un'etichetta definita dall'utente per la chiave pubblica. La dimensione massima consentita `label` è di 127 caratteri per Client SDK 5.11 e versioni successive. Client SDK 5.10 e versioni precedenti hanno un limite di 126 caratteri.  
Obbligatorio: sì

***<SESSION>***  
Crea una chiave che esiste solo nella sessione corrente. La chiave non può essere recuperata dopo la fine della sessione.  
Utilizza questo parametro quando hai bisogno di una chiave solo per un breve periodo, ad esempio una chiave di wrapping che crittografa e quindi decodifica rapidamente un'altra chiave. Non utilizzare una chiave di sessione per crittografare dati che potresti aver bisogno di decodificare al termine della sessione.  
Per impostazione predefinita, le chiavi generate sono chiavi persistenti (token). L'inserimento dell'argomento <SESSIONE> modifica la situazione, assicurando che una chiave generata con questo argomento sia una chiave di sessione (effimera).  
Obbligatorio: no

***<SHARE\$1CRYPTO\$1USERS>***  
Specifica un elenco separato da spazi di nomi utente Crypto User con cui condividere la chiave privata RSA  
Obbligatorio: no

***<MANAGE\$1PRIVATE\$1KEY\$1QUORUM\$1VALUE>***  
Il valore del quorum per le operazioni di gestione delle chiavi della chiave privata. Questo valore deve essere inferiore o uguale al numero di utenti a cui è associata la chiave. Ciò include gli utenti con cui viene condivisa la chiave e il proprietario della chiave. Valore massimo di 8.  
Obbligatorio: no

***<USE\$1PRIVATE\$1KEY\$1QUORUM\$1VALUE>***  
Il valore del quorum per le operazioni di utilizzo delle chiavi private. Questo valore deve essere inferiore o uguale al numero di utenti a cui è associata la chiave. Ciò include gli utenti con cui viene condivisa la chiave e il proprietario della chiave. Valore massimo di 8.  
Obbligatorio: no

## Argomenti correlati
<a name="key-generate-asymmetric-pair-rsa-seealso"></a>
+ [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)
+ [Filtrare le chiavi utilizzando la CLI di CloudHSM](manage-keys-cloudhsm-cli-filtering.md)

# La categoria generate-symmetric nella CLI di CloudhSM
<a name="cloudhsm_cli-key-generate-symmetric"></a>

Nella CLI di CloudHSM, è una categoria principale per un gruppo di comandi che, se combinati con la categoria principale, creano un comando che genera chiavi **key generate-symmetric** simmetriche. Attualmente, questa categoria comprende i seguenti comandi:
+ [Generazione chiavi-simmetriche aes](cloudhsm_cli-key-generate-symmetric-aes.md)
+ [Generazione chiavi-simmetriche generiche-segrete](cloudhsm_cli-key-generate-symmetric-generic-secret.md)

# Genera una chiave AES simmetrica con CloudhSM CLI
<a name="cloudhsm_cli-key-generate-symmetric-aes"></a>

Usa il **key generate-symmetric aes** comando nella CLI di CloudHSM per generare una chiave AES simmetrica nel tuo cluster. AWS CloudHSM 

## Tipo di utente
<a name="key-generate-symmetric-aes-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti CUs Crypto ()

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

Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

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

Questi esempi mostrano come utilizzare il comando **key generate-symmetric aes** per creare una chiave AES.

**Example Esempio: creare una chiave AES**  

```
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 Esempio: creare una chiave AES con attributi opzionali**  

```
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 Esempio: crea una chiave AES con valori di quorum**  
Quando si genera una chiave con controlli del quorum, la chiave deve essere associata a un numero minimo di utenti pari al valore del quorum chiave massimo. Gli utenti associati includono il proprietario della chiave e gli utenti Crypto con cui viene condivisa la chiave. Per determinare il numero minimo di utenti con cui condividere la chiave, ottieni il valore di quorum più alto tra il valore del quorum di utilizzo della chiave e il valore del quorum di gestione delle chiavi e sottrai 1 per tenere conto del proprietario della chiave, che per impostazione predefinita è associato alla chiave. Per condividere la chiave con più utenti, usa il comando. **[Condividi una chiave utilizzando la CLI di CloudHSM](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
      }
    }
  }
}
```

## Arguments (Argomenti)
<a name="key-generate-symmetric-aes-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<KEY\$1ATTRIBUTES>***  
Specifica un elenco separato da spazi di attributi delle chiavi da impostare per la chiave AES generata sotto forma di `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (ad esempio `sign=true`).  
Per un elenco degli attributi delle chiavi supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md).  
Obbligatorio: no

***<KEY-LENGTH-BYTES>***  
Specifica le dimensioni della chiave in byte.  

Valori validi:
+ 16, 24 e 32
Obbligatorio: sì

***<LABEL>***  
Specifica un'etichetta definita dall'utente per la chiave AES. La dimensione massima consentita `label` è di 127 caratteri per Client SDK 5.11 e versioni successive. Client SDK 5.10 e versioni precedenti hanno un limite di 126 caratteri.  
Obbligatorio: sì

***<SESSION>***  
Crea una chiave che esiste solo nella sessione corrente. La chiave non può essere recuperata dopo la fine della sessione.  
Utilizza questo parametro quando hai bisogno di una chiave solo per un breve periodo, ad esempio una chiave di wrapping che crittografa e quindi decodifica rapidamente un'altra chiave. Non utilizzare una chiave di sessione per crittografare dati che potresti aver bisogno di decodificare al termine della sessione.  
Per impostazione predefinita, le chiavi generate sono chiavi persistenti (token). L'inserimento dell'argomento <SESSIONE> modifica la situazione, assicurando che una chiave generata con questo argomento sia una chiave di sessione (effimera).  
Obbligatorio: no

***<SHARE\$1CRYPTO\$1USERS>***  
Specifica un elenco separato da spazi di nomi utente Crypto User con cui condividere la chiave AES  
Obbligatorio: no

***<MANAGE\$1KEY\$1QUORUM\$1VALUE>***  
Il valore del quorum per le operazioni di gestione delle chiavi. Questo valore deve essere inferiore o uguale al numero di utenti a cui è associata la chiave. Ciò include gli utenti con cui viene condivisa la chiave e il proprietario della chiave. Valore massimo di 8.  
Obbligatorio: no

***<USE\$1KEY\$1QUORUM\$1VALUE>***  
Il valore del quorum per le operazioni di utilizzo delle chiavi. Questo valore deve essere inferiore o uguale al numero di utenti a cui è associata la chiave. Ciò include gli utenti con cui viene condivisa la chiave e il proprietario della chiave. Valore massimo di 8.  
Obbligatorio: no

## Argomenti correlati
<a name="key-generate-symmetric-aes-seealso"></a>
+ [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)
+ [Filtrare le chiavi utilizzando la CLI di CloudHSM](manage-keys-cloudhsm-cli-filtering.md)

# Genera una chiave segreta generica simmetrica con la CLI di CloudhSM
<a name="cloudhsm_cli-key-generate-symmetric-generic-secret"></a>

Usa il **key generate-symmetric generic-secret** comando nella CLI di CloudHSM per generare una chiave segreta generica simmetrica nel tuo cluster. AWS CloudHSM 

## Tipo di utente
<a name="key-generate-symmetric-generic-secret-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ CUsUtenti Crypto ()

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

Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

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

Questi esempi mostrano come utilizzare il comando **key generate-symmetric generic-secret** per creare una chiave generica segreta.

**Example Esempio: creare una chiave generica segreta**  

```
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 Esempio: creare una chiave generica segreta con attributi opzionali**  

```
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 Esempio: crea una chiave segreta generica con valori di quorum**  
Quando si genera una chiave con controlli quorum, la chiave deve essere associata a un numero minimo di utenti pari al valore del quorum della chiave massimo. Gli utenti associati includono il proprietario della chiave e gli utenti Crypto con cui viene condivisa la chiave. Per determinare il numero minimo di utenti con cui condividere la chiave, ottieni il valore di quorum più alto tra il valore del quorum di utilizzo della chiave e il valore del quorum di gestione delle chiavi e sottrai 1 per tenere conto del proprietario della chiave, che per impostazione predefinita è associato alla chiave. Per condividere la chiave con più utenti, usa il comando. **[Condividi una chiave utilizzando la CLI di CloudHSM](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
      }
    }
  }
}
```

## Arguments (Argomenti)
<a name="key-generate-symmetric-generic-secret-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<KEY\$1ATTRIBUTES>***  
Specifica un elenco separato da spazi di attributi delle chiavi da impostare per la chiave AES generata sotto forma di `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (ad esempio `sign=true`).  
Per un elenco degli attributi delle chiavi supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md).  
Obbligatorio: no

***<KEY-LENGTH-BYTES>***  
Specifica le dimensioni della chiave in byte.  

Valori validi:
+ Da 1 a 800
Obbligatorio: sì

***<LABEL>***  
Specifica un'etichetta definita dall'utente per la chiave generica segreta. La dimensione massima consentita `label` è di 127 caratteri per Client SDK 5.11 e versioni successive. Client SDK 5.10 e versioni precedenti hanno un limite di 126 caratteri.  
Obbligatorio: sì

***<SESSION>***  
Crea una chiave che esiste solo nella sessione corrente. La chiave non può essere recuperata dopo la fine della sessione.  
Utilizza questo parametro quando hai bisogno di una chiave solo per un breve periodo, ad esempio una chiave di wrapping che crittografa e quindi decodifica rapidamente un'altra chiave. Non utilizzare una chiave di sessione per crittografare dati che potresti aver bisogno di decodificare al termine della sessione.  
Per impostazione predefinita, le chiavi generate sono chiavi persistenti (token). L'inserimento dell'argomento <SESSIONE> modifica la situazione, assicurando che una chiave generata con questo argomento sia una chiave di sessione (effimera).  
Obbligatorio: no

***<SHARE\$1CRYPTO\$1USERS>***  
Elenco separato da spazi di nomi utente Crypto User con cui condividere la chiave segreta generica  
Obbligatorio: no

***<MANAGE\$1KEY\$1QUORUM\$1VALUE>***  
Il valore del quorum per le operazioni di gestione delle chiavi. Questo valore deve essere inferiore o uguale al numero di utenti a cui è associata la chiave. Ciò include gli utenti con cui viene condivisa la chiave e il proprietario della chiave. Valore massimo di 8.  
Obbligatorio: no

***<USE\$1KEY\$1QUORUM\$1VALUE>***  
Il valore del quorum per le operazioni di utilizzo delle chiavi. Questo valore deve essere inferiore o uguale al numero di utenti a cui è associata la chiave. Ciò include gli utenti con cui viene condivisa la chiave e il proprietario della chiave. Valore massimo di 8.  
Obbligatorio: no

## Argomenti correlati
<a name="key-generate-symmetric-generic-secret-seealso"></a>
+ [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)
+ [Filtrare le chiavi utilizzando la CLI di CloudHSM](manage-keys-cloudhsm-cli-filtering.md)

# Importa una chiave in formato PEM con CloudhSM CLI
<a name="cloudhsm_cli-key-import-pem"></a>

Utilizzate il **key import pem** comando in AWS CloudHSM per importare una chiave in formato PEM in un modulo di sicurezza hardware (HSM). È possibile utilizzarlo per importare le chiavi pubbliche generate al di fuori del HSM.

**Nota**  
Utilizzate il [Esportazione di una chiave asimmetrica con CLI CloudhSM](cloudhsm_cli-key-generate-file.md) comando per creare un file PEM standard da una chiave pubblica o per creare un file PEM di riferimento da una chiave privata.

## Tipo di utente
<a name="cloudhsm_cli-key-import-pem-user-type"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti crittografici () CUs

## Requisiti
<a name="cloudhsm_cli-key-import-pem-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

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

Questo esempio mostra come utilizzare il **key import pem** comando per importare una chiave pubblica RSA da un file in formato PEM.

**Example Esempio: importare una chiave pubblica RSA**  

```
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 Esempio: importazione di una chiave pubblica RSA con attributi opzionali**  

```
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"
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-import-pem-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<PATH>***  
Speciifica il percorso del file in cui si trova il file chiave.  
Obbligatorio: sì

***<LABEL>***  
Specifica un'etichetta definita dall'utente per la chiave importata. La dimensione massima per l'`label` è 126 caratteri.  
Obbligatorio: sì

***<KEY\$1TYPE\$1CLASS>***  
Tipo di chiave e classe di chiave racchiusa.  
Valori possibili:  
+ ec-public
+ rsa-pubblico
Obbligatorio: sì

***<IMPORT\$1KEY\$1ATTRIBUTES>***  
Specifica un elenco separato da spazi di attributi chiave da impostare per la chiave importata sotto forma di `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (ad esempio,). `sign=true` Per un elenco degli attributi di chiavi supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md).  
Obbligatorio: no

## Argomenti correlati
<a name="cloudhsm_cli-key-import-pem-seealso"></a>
+ [La categoria dei segni crittografici nella CLI di CloudhSM](cloudhsm_cli-crypto-sign.md)
+ [La categoria crypto verify nella CLI di CloudHSM](cloudhsm_cli-crypto-verify.md)

# Elenca le chiavi per un utente con CLI CloudhSM
<a name="cloudhsm_cli-key-list"></a>

Utilizza il **key list** comando nella CLI di CloudHSM per trovare tutte le chiavi per l'utente corrente presente nel cluster. AWS CloudHSM L'output include le chiavi che l'utente possiede e condivide e tutte le chiavi pubbliche ne cluster del CloudHSM.

## Tipo di utente
<a name="chsm-cli-key-list-user-type"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Amministratori () COs
+ Utenti Crypto () CUs

## Sintassi
<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
```

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

Nell'esempio seguente vengono illustrati tipi diversi di esecuzione del comando **key list**. Gli esempi seguenti mostrano gli output di un utente crittografico.

**Example Esempio: Trova tutte le chiavi (impostazione predefinita)**  
Questo comando elenca le chiavi dell'utente registrato presente nel AWS CloudHSM cluster.  
Per impostazione predefinita, vengono visualizzate solo 10 chiavi dell'utente attualmente connesso e solo la `key-reference` e la `label` vengono visualizzate come output. Utilizza le opzioni di impaginazione appropriate per visualizzare più o meno chiavi come output.

```
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 Esempio: Trova tutte le chiavi — verbose**  
L'output include le chiavi che l'utente possiede e condivide, oltre a tutte le chiavi pubbliche di. HSMs  
Nota: per impostazione predefinita, vengono visualizzate solo 10 chiavi dell'utente attualmente connesso. Utilizza le opzioni di impaginazione appropriate per visualizzare più o meno chiavi come output.

```
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 Esempio: ritorno impaginato**  
L'esempio seguente mostra un sottoinsieme impaginato di chiavi che mostra solo due chiavi. L'esempio prevede quindi una chiamata successiva per visualizzare le due chiavi successive.  

```
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"
  }
}
```
Per visualizzare le 2 chiavi successive, è possibile effettuare una chiamata successiva:  

```
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"
  }
}
```
Per altri esempi che dimostrano come funziona il meccanismo di filtraggio chiave nella CLI di CloudHSM, vedi [Filtrare le chiavi utilizzando la CLI di CloudHSM](manage-keys-cloudhsm-cli-filtering.md).

## Arguments (Argomenti)
<a name="key-list-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire l'operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di selezione delle chiavi corrispondenti da elencare.  
Per un elenco degli attributi chiave della CLI di CloudHSM supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)  
Obbligatorio: no

***<MAX\$1ITEMS>***  
Il numero totale di elementi da restituire nell'output del comando. Se il numero totale di elementi disponibili supera il valore specificato, viene fornito un token-successivo nell'output del comando. Per riprendere l'impaginazione, specifica il valore del token-successivo nell'argomento token-iniziale di un comando successivo.  
Obbligatorio: no

***<STARTING\$1TOKEN>***  
Token per specificare dove iniziare l'impaginazione. Si tratta del token-successivo da una risposta precedentemente troncata.  
Obbligatorio: no

***<VERBOSE>***  
Se incluso, stampa tutti gli attributi e le informazioni della chiave per ogni chiave abbinata. Per impostazione predefinita, ogni chiave abbinata mostra solo il riferimento alla chiave e l'etichetta dell'attributo. Questo flag, se usato dagli amministratori, non ha alcun effetto.  
Obbligatorio: no

## Argomenti correlati
<a name="chsm-key-list-seealso"></a>
+ [Eliminare una chiave con CloudHSM CLI](cloudhsm_cli-key-delete.md)
+ [Esportazione di una chiave asimmetrica con CLI CloudhSM](cloudhsm_cli-key-generate-file.md)
+ [Annullare la condivisione di una chiave utilizzando la CLI di CloudhSM](cloudhsm_cli-key-unshare.md)
+ [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)
+ [Filtrare le chiavi utilizzando la CLI di CloudHSM](manage-keys-cloudhsm-cli-filtering.md)

# Replica di una chiave con la CLI di CloudhSM
<a name="cloudhsm_cli-key-replicate"></a>

Utilizza il **key replicate** comando nella CLI di CloudHSM per replicare una chiave da AWS CloudHSM un cluster di origine a un cluster di destinazione. AWS CloudHSM 

## Tipo di utente
<a name="chsm-cli-key-replicate-user-type"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Amministratori () COs
+ Utenti Crypto () CUs
**Nota**  
Gli utenti Crypto devono possedere la chiave per utilizzare questo comando.

## Requisiti
<a name="cloudhsm_cli-key-replicate-requirements"></a>
+ I cluster di origine e di destinazione devono essere cloni. Ciò significa che uno è stato creato da un backup dell'altro o entrambi sono stati creati da un backup comune. Per ulteriori informazioni, consulta [Creazione di cluster dai backup](create-cluster-from-backup.md).
+ Il proprietario della chiave deve esistere nel cluster di destinazione. Inoltre, se la chiave è condivisa con qualsiasi utente, tali utenti devono esistere anche nel cluster di destinazione.
+ Per eseguire questo comando, devi accedere come utente crittografico o amministratore sia nel cluster di origine che in quello di destinazione.
  +  In modalità a comando singolo, il comando utilizzerà le variabili ambientali CLOUDHSM\$1PIN e CLOUDHSM\$1ROLE per l'autenticazione nel cluster di origine. Per ulteriori informazioni, consulta [Modalità di comando singolo](cloudhsm_cli-modes.md#cloudhsm_cli-mode-single-command). Per fornire le credenziali per il cluster di destinazione, è necessario impostare due variabili ambientali aggiuntive: DESTINATION\$1CLOUDHSM\$1PIN e DESTINATION\$1CLOUDHSM\$1ROLE:

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

    ```
    $ export DESTINATION_CLOUDHSM_PIN=<username:password>
    ```
  +  In modalità interattiva, gli utenti dovranno accedere in modo esplicito ai cluster di origine e di destinazione.

## Sintassi
<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
```

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

**Example Esempio: chiave di replica**  
Questo comando replica una chiave da un cluster di origine in un cluster di destinazione clonato. L'esempio seguente mostra l'output quando si accede come utente crittografico su entrambi i cluster.  

```
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"
  }
}
```

## Arguments (Argomenti)
<a name="key-replicate-arguments"></a>

***<FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave corrispondente nel cluster di origine.  
Per un elenco degli attributi chiave della CLI di CloudHSM supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)  
Obbligatorio: sì

***<SOURCE\$1CLUSTER\$1ID>***  
L'ID del cluster di origine.  
Obbligatorio: sì

***<DESTINATION\$1CLUSTER\$1ID>***  
L'ID del cluster di destinazione.  
Campo obbligatorio: sì

## Argomenti correlati
<a name="chsm-key-replicate-seealso"></a>
+ [Connessione a più cluster con la CLI CloudhSM](cloudhsm_cli-configs-multi-cluster.md)

# Imposta gli attributi delle chiavi con CloudhSM CLI
<a name="cloudhsm_cli-key-set-attribute"></a>

Usa il **key set-attribute** comando nella CLI di CloudHSM per impostare gli attributi delle chiavi nel tuo cluster. AWS CloudHSM Solo il CU che ha creato la chiave e di conseguenza la possiede può modificare gli attributi della chiave.

Per un elenco degli attributi delle chiavi che possono essere utilizzati nella CLI di CloudHSM, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md).

## Tipo di utente
<a name="chsm-cli-key-set-attribute-user-type"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Gli utenti Crypto (CUs) possono eseguire questo comando.
+ Gli admin possono impostare l'attributo affidabile.

## Requisiti
<a name="chsm-cli-key-set-attribute-requirements"></a>

Per eseguire questo comando, è necessario aver effettuato l'accesso come CU. Per impostare l'attributo affidabile, è necessario aver effettuato l'accesso come utente admin.

## Sintassi
<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
```

## Esempio: impostazione di un attributo della chiave
<a name="chsm-cli-key-set-attribute-examples"></a>

L'esempio seguente mostra come utilizzare il comando **key set-attribute** per impostare l'etichetta.

**Example**  

1. Utilizza la chiave con l'etichetta `my_key`, come mostrato di seguito:

   ```
   aws-cloudhsm > key set-attribute --filter attr.label=my_key --name encrypt --value false
   {
     "error_code": 0,
     "data": {
       "message": "Attribute set successfully"
     }
   }
   ```

1. Utilizza il comando **key list** per confermare che l'attributo `encrypt` è cambiato:

   ```
   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
     }
   }
   ```

## Arguments (Argomenti)
<a name="chsm-cli-key-set-attribute-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<KEY\$1ATTRIBUTE>***  
Specifica il nome dell'attributo della chiave.  
Obbligatorio: sì

***<FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave corrispondente da eliminare.  
Per un elenco degli attributi chiave della CLI di CloudHSM supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)  
Obbligatorio: no

***<KEY\$1ATTRIBUTE\$1VALUE>***  
Specifica il valore dell'attributo della chiave.  
Obbligatorio: sì

***<KEY\$1REFERENCE>***  
Una rappresentazione esadecimale o decimale della chiave. (ad esempio un handle della chiave).  
Obbligatorio: no

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave è maggiore di 1.

## Argomenti correlati
<a name="chsm-cli-key-set-attribute-see-also"></a>
+ [Filtrare le chiavi utilizzando la CLI di CloudHSM](manage-keys-cloudhsm-cli-filtering.md)
+ [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)

# Condividi una chiave utilizzando la CLI di CloudHSM
<a name="cloudhsm_cli-key-share"></a>

Usa il **key share** comando nella CLI di CloudHSM per condividere una chiave CUs con altri membri del tuo cluster. AWS CloudHSM 

Solo il CU che ha creato la chiave e di conseguenza la possiede può condividere la chiave. Gli utenti con cui è condivisa la chiave possono utilizzarla in operazioni di crittografia, ma non possono eliminarla, esportarla, condividerla o annullarne la condivisione. Inoltre, questi utenti non possono modificare gli [attributi della chiave](cloudhsm_cli-key-attributes.md).

## Tipo di utente
<a name="chsm-cli-key-share-user-type"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="chsm-cli-key-share-requirements"></a>

Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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')
```

## Esempio: condividere una chiave con un altro CU
<a name="chsm-cli-key-share-examples"></a>

L'esempio seguente mostra come utilizzare il comando **key share** per condividere una chiave con il CU `alice`.

**Example**  

1. Esegui il comando **key share** per condividere la chiave con `alice`.

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

1. Esegui il comando **key list**.

   ```
   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. Nell'elenco precedente, la verifica `alice` è nell'elenco di `shared-users`

## Arguments (Argomenti)
<a name="chsm-cli-key-share-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave corrispondente da eliminare.  
Per un elenco degli attributi delle chiavi supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md).  
Obbligatorio: sì

***<USERNAME>***  
Specifica un nome intuitivo per l'utente. La lunghezza massima è 31 caratteri. L'unico carattere speciale consentito è il trattino basso (\$1). In questo comando il nome utente non è sensibile alle maiuscole e minuscole, il nome utente viene sempre visualizzato in minuscolo.  
Obbligatorio: sì

***<ROLE>***  
Specifica il ruolo assegnato a questo utente. Questo parametro è obbligatorio. Per ottenere il ruolo dell'utente, utilizzare il comando user list. Per informazioni dettagliate sui tipi di utente su un HSM, vedi [Tipi di utente HSM per CloudHSM CLI](understanding-users.md).  
Obbligatorio: sì

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave è maggiore di 1.

## Argomenti correlati
<a name="chsm-cli-key-share-see-also"></a>
+ [Filtrare le chiavi utilizzando la CLI di CloudHSM](manage-keys-cloudhsm-cli-filtering.md)
+ [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)

# Annullare la condivisione di una chiave utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-unshare"></a>

Utilizza il **key unshare** comando nella CLI di CloudHSM per annullare la condivisione di una chiave con altri membri del cluster. CUs AWS CloudHSM 

Solo il CU che ha creato la chiave e di conseguenza la possiede può annullare la condivisione della chiave. Gli utenti con cui è condivisa la chiave possono utilizzarla in operazioni di crittografia, ma non possono esportarla, eliminarla, condividerla o annullarne la condivisione. Inoltre, questi utenti non possono modificare gli [attributi della chiave](cloudhsm_cli-key-attributes.md).

## Tipo di utente
<a name="chsm-cli-key-unshare-user-type"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="chsm-cli-key-unshare-requirements"></a>

Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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')
```

## Esempio: annullare la condivisione di una chiave con un altro CU
<a name="chsm-cli-key-share-examples"></a>

L'esempio seguente mostra come utilizzare il comando **key unshare** per annullare la condivisione di una chiave con il CU `alice`.

**Example**  

1. Esegui il comando **key list** e filtra in base alla specifica chiave di cui desideri annullare la condivisione con `alice`.

   ```
   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. Conferma che `alice` è presente nell'output `shared-users` ed esegui il seguente comando **key unshare** per annullare la condivisione della chiave con `alice`.

   ```
   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. Esegui nuovamente il comando `key list` per confermare che condivisione della chiave con `alice` è stata annullata.

   ```
   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
     }
   }
   ```

## Arguments (Argomenti)
<a name="chsm-cli-key-unshare-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave corrispondente da eliminare.  
Per un elenco degli attributi delle chiavi supportati, vedi [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md).  
Obbligatorio: sì

***<USERNAME>***  
Specifica un nome intuitivo per l'utente. La lunghezza massima è 31 caratteri. L'unico carattere speciale consentito è il trattino basso (\$1). In questo comando il nome utente non è sensibile alle maiuscole e minuscole, il nome utente viene sempre visualizzato in minuscolo.  
Obbligatorio: sì

***<ROLE>***  
Specifica il ruolo assegnato a questo utente. Questo parametro è obbligatorio. Per ottenere il ruolo dell'utente, utilizzare il comando user list. Per informazioni dettagliate sui tipi di utente su un HSM, vedi [Tipi di utente HSM per CloudHSM CLI](understanding-users.md).  
Obbligatorio: sì

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave è maggiore di 1.

## Argomenti correlati
<a name="chsm-cli-key-unshare-see-also"></a>
+ [Filtrare le chiavi utilizzando la CLI di CloudHSM](manage-keys-cloudhsm-cli-filtering.md)
+ [Attributi chiave per la CLI di CloudHSM](cloudhsm_cli-key-attributes.md)

# Il comando key unwrap nella CLI di CloudhSM
<a name="cloudhsm_cli-key-unwrap"></a>

Il comando **key unwrap** parent nella CLI di CloudHSM importa una chiave privata criptata (avvolta) simmetrica o asimmetrica da un file e nell'HSM. Questo comando è progettato per importare chiavi crittografate che sono state racchiuse dal [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md) comando, ma può anche essere usato per scartare chiavi che sono state racchiuse con altri strumenti. Tuttavia, in tali situazioni, ti consigliamo di utilizzare le librerie software PKCS \$1 11 o JCE per annullare il wrapping della chiave.
+ [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)

# Estrarre una chiave con AES-GCM utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-unwrap-aes-gcm"></a>

Utilizzate il **key unwrap aes-gcm** comando nella CLI di CloudHSM per estrarre una chiave di payload nel cluster utilizzando la chiave di wrapping AES e il meccanismo di unwrapping. `AES-GCM`

Le chiavi non impacchettate possono essere utilizzate nello stesso modo delle chiavi generate da. AWS CloudHSM Per indicare che non sono state generate localmente, il loro `local` attributo è impostato su. `false`

Per utilizzare il **key unwrap aes-gcm** comando, è necessario disporre della chiave di wrapping AES nel AWS CloudHSM cluster e il relativo `unwrap` attributo deve essere impostato su. `true`

## Tipo di utente
<a name="cloudhsm_cli-key-unwrap-aes-gcm-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-unwrap-aes-gcm-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempi
<a name="cloudhsm_cli-key-unwrap-aes-gcm-examples"></a>

Questi esempi mostrano come utilizzare il **key unwrap aes-gcm** comando utilizzando una chiave AES con il valore dell'`unwrap`attributo impostato su`true`.

**Example Esempio: scartare una chiave di payload dai dati chiave avvolti codificati in Base64**  

```
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 Esempio: scartare una chiave di payload fornita tramite un percorso dati**  

```
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
      }
    }
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-unwrap-aes-gcm-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di selezione di una chiave da utilizzare.  
Obbligatorio: sì

***<DATA\$1PATH>***  
Percorso del file binario contenente i dati chiave racchiusi.  
Obbligatorio: Sì (a meno che non sia fornito tramite dati codificati Base64)

***<DATA>***  
Dati chiave avvolti codificati in Base64.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<ATTRIBUTES>***  
Elenco separato da spazi degli attributi chiave sotto forma `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di chiave racchiusa.  
Obbligatorio: no

***<AAD>***  
Come valore AAD (Additional Authenticated Data) di GCM, in esadecimale.  
Obbligatorio: no

***<TAG\$1LENGTH\$1BITS>***  
Lunghezza del tag Aes GCM in bit.  
Obbligatorio: sì

***<KEY\$1TYPE\$1CLASS>***  
Tipo di chiave e classe di chiave racchiusa [valori possibili:`aes`,,, `des3``ec-private`,`generic-secret`]. `rsa-private`  
Obbligatorio: sì

***<LABEL>***  
Etichetta per la chiave aperta.  
Obbligatorio: sì

***<SESSION>***  
Crea una chiave di sessione che esiste solo nella sessione corrente. La chiave non può essere recuperata dopo la fine della sessione.  
Obbligatorio: no

***<IV>***  
Valore iniziale usato per racchiudere la chiave, in esadecimale.  
Obbligatorio: no

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di unwrapping è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-unwrap-aes-gcm-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Estrarre una chiave AES-NO-PAD utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-unwrap-aes-no-pad"></a>

Utilizzate il **key unwrap aes-no-pad** comando nella CLI di CloudHSM per estrarre una chiave di payload AWS CloudHSM nel cluster utilizzando la chiave di wrapping AES e il meccanismo di unwrapping. `AES-NO-PAD`

Le chiavi non incluse possono essere utilizzate nello stesso modo delle chiavi generate da. AWS CloudHSM Per indicare che non sono state generate localmente, il loro `local` attributo è impostato su. `false`

Per utilizzare il **key unwrap aes-no-pad** comando, è necessario disporre della chiave di wrapping AES nel AWS CloudHSM cluster e il relativo `unwrap` attributo deve essere impostato su. `true`

## Tipo di utente
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempi
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-examples"></a>

Questi esempi mostrano come utilizzare il **key unwrap aes-no-pad** comando utilizzando una chiave AES con il valore dell'`unwrap`attributo impostato su`true`.

**Example Esempio: scartare una chiave di payload dai dati chiave avvolti codificati in Base64**  

```
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 Esempio: scartare una chiave di payload fornita tramite un percorso dati**  

```
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
      }
    }
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di selezione di una chiave da utilizzare.  
Obbligatorio: sì

***<DATA\$1PATH>***  
Percorso del file binario contenente i dati chiave racchiusi.  
Obbligatorio: Sì (a meno che non sia fornito tramite dati codificati Base64)

***<DATA>***  
Dati chiave avvolti codificati in Base64.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<ATTRIBUTES>***  
Elenco separato da spazi degli attributi chiave sotto forma `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di chiave racchiusa.  
Obbligatorio: no

***<KEY\$1TYPE\$1CLASS>***  
Tipo di chiave e classe di chiave racchiusa [valori possibili:`aes`,,, `des3` `ec-private``generic-secret`,`rsa-private`].  
Obbligatorio: sì

***<LABEL>***  
Etichetta per la chiave aperta.  
Obbligatorio: sì

***<SESSION>***  
Crea una chiave di sessione che esiste solo nella sessione corrente. La chiave non può essere recuperata dopo la fine della sessione.  
Obbligatorio: no

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di unwrapping è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Estrarre una chiave con AES- PKCS5 -PAD utilizzando la CLI CloudhSM
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad"></a>

Utilizzate il **key unwrap aes-pkcs5-pad** comando nella CLI di CloudHSM per decomprimere una chiave di payload utilizzando la chiave di wrapping AES e il meccanismo di unwrapping. `AES-PKCS5-PAD`

Le chiavi non impacchettate possono essere utilizzate nello stesso modo delle chiavi generate da. AWS CloudHSM Per indicare che non sono state generate localmente, il loro `local` attributo è impostato su. `false`

Per utilizzare il **key unwrap aes-pkcs5-pad** comando, è necessario disporre della chiave di wrapping AES nel AWS CloudHSM cluster e il relativo `unwrap` attributo deve essere impostato su. `true`

## Tipo di utente
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempi
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-examples"></a>

Questi esempi mostrano come utilizzare il **key unwrap aes-pkcs5-pad** comando utilizzando una chiave AES con il valore dell'`unwrap`attributo impostato su`true`.

**Example Esempio: scartare una chiave di payload dai dati chiave avvolti codificati in Base64**  

```
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 Esempio: scartare una chiave di payload fornita tramite un percorso dati**  

```
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
      }
    }
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di selezione di una chiave da utilizzare.  
Obbligatorio: sì

***<DATA\$1PATH>***  
Percorso del file binario contenente i dati chiave racchiusi.  
Obbligatorio: Sì (a meno che non sia fornito tramite dati codificati Base64)

***<DATA>***  
Dati chiave avvolti codificati in Base64.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<ATTRIBUTES>***  
Elenco separato da spazi degli attributi chiave sotto forma `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di chiave racchiusa.  
Obbligatorio: no

***<KEY\$1TYPE\$1CLASS>***  
Tipo di chiave e classe di chiave racchiusa [valori possibili:`aes`,,, `des3` `ec-private``generic-secret`,`rsa-private`].  
Obbligatorio: sì

***<LABEL>***  
Etichetta per la chiave aperta.  
Obbligatorio: sì

***<SESSION>***  
Crea una chiave di sessione che esiste solo nella sessione corrente. La chiave non può essere recuperata dopo la fine della sessione.  
Obbligatorio: no

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di unwrapping è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Estrarre una chiave AES-ZERO-PAD utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad"></a>

Utilizzate il **key unwrap aes-zero-pad** comando nella CLI di CloudHSM per estrarre una chiave di payload AWS CloudHSM nel cluster utilizzando la chiave di wrapping AES e il meccanismo di unwrapping. `AES-ZERO-PAD`

Le chiavi non incluse possono essere utilizzate nello stesso modo delle chiavi generate da. AWS CloudHSM Per indicare che non sono state generate localmente, il loro `local` attributo è impostato su. `false`

Per utilizzare il **key unwrap aes-no-pad** comando, è necessario disporre della chiave di wrapping AES nel AWS CloudHSM cluster e il relativo `unwrap` attributo deve essere impostato su. `true`

## Tipo di utente
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempi
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-examples"></a>

Questi esempi mostrano come utilizzare il **key unwrap aes-zero-pad** comando utilizzando una chiave AES con il valore dell'`unwrap`attributo impostato su`true`.

**Example Esempio: scartare una chiave di payload dai dati chiave avvolti codificati in Base64**  

```
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 Esempio: scartare una chiave di payload fornita tramite un percorso dati**  

```
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
      }
    }
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di selezione di una chiave da utilizzare.  
Obbligatorio: sì

***<DATA\$1PATH>***  
Percorso del file binario contenente i dati chiave racchiusi.  
Obbligatorio: Sì (a meno che non sia fornito tramite dati codificati Base64)

***<DATA>***  
Dati chiave avvolti codificati in Base64.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<ATTRIBUTES>***  
Elenco separato da spazi degli attributi chiave sotto forma `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di chiave racchiusa.  
Obbligatorio: no

***<KEY\$1TYPE\$1CLASS>***  
Tipo di chiave e classe di chiave racchiusa [valori possibili:`aes`,,, `des3` `ec-private``generic-secret`,`rsa-private`].  
Obbligatorio: sì

***<LABEL>***  
Etichetta per la chiave aperta.  
Obbligatorio: sì

***<SESSION>***  
Crea una chiave di sessione che esiste solo nella sessione corrente. La chiave non può essere recuperata dopo la fine della sessione.  
Obbligatorio: no

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di unwrapping è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Estrarre una chiave CLOUDHSM-AES-GCM utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm"></a>

Utilizzate il **key unwrap cloudhsm-aes-gcm** comando nella CLI di CloudHSM per estrarre una chiave di payload AWS CloudHSM nel cluster utilizzando la chiave di wrapping AES e il meccanismo di unwrapping. `CLOUDHSM-AES-GCM`

Le chiavi non impacchettate possono essere utilizzate nello stesso modo delle chiavi generate da. AWS CloudHSM Per indicare che non sono state generate localmente, il loro `local` attributo è impostato su. `false`

Per utilizzare il **key unwrap cloudhsm-aes-gcm** comando, è necessario disporre della chiave di wrapping AES nel AWS CloudHSM cluster e il relativo `unwrap` attributo deve essere impostato su. `true`

## Tipo di utente
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempi
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-examples"></a>

Questi esempi mostrano come utilizzare il **key unwrap cloudhsm-aes-gcm** comando utilizzando una chiave AES con il valore dell'`unwrap`attributo impostato su`true`.

**Example Esempio: scartare una chiave di payload dai dati chiave avvolti codificati in Base64**  

```
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 Esempio: scartare una chiave di payload fornita tramite un percorso dati**  

```
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
      }
    }
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di selezione di una chiave da utilizzare.  
Obbligatorio: sì

***<DATA\$1PATH>***  
Percorso del file binario contenente i dati chiave racchiusi.  
Obbligatorio: Sì (a meno che non sia fornito tramite dati codificati Base64)

***<DATA>***  
Dati chiave avvolti codificati in Base64.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<ATTRIBUTES>***  
Elenco separato da spazi degli attributi chiave sotto forma `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di chiave racchiusa.  
Obbligatorio: no

***<AAD>***  
Come valore AAD (Additional Authenticated Data) di GCM, in esadecimale.  
Obbligatorio: no

***<TAG\$1LENGTH\$1BITS>***  
Lunghezza del tag Aes GCM in bit.  
Obbligatorio: sì

***<KEY\$1TYPE\$1CLASS>***  
Tipo di chiave e classe di chiave racchiusa [valori possibili:`aes`,,, `des3``ec-private`,`generic-secret`]. `rsa-private`  
Obbligatorio: sì

***<LABEL>***  
Etichetta per la chiave aperta.  
Obbligatorio: sì

***<SESSION>***  
Crea una chiave di sessione che esiste solo nella sessione corrente. La chiave non può essere recuperata dopo la fine della sessione.  
Obbligatorio: no

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di unwrapping è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Estrarre una chiave con RSA-AES utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-unwrap-rsa-aes"></a>

Utilizzate il **key unwrap rsa-aes** comando nella CLI di CloudHSM per decomprimere una chiave di payload utilizzando una chiave privata RSA e il meccanismo di unwrapping. `RSA-AES`

Le chiavi aperte possono essere utilizzate nello stesso modo delle chiavi generate da. AWS CloudHSM Per indicare che non sono state generate localmente, il loro `local` attributo è impostato su. `false`

Per utilizzare il**key unwrap rsa-aes**, è necessario disporre della chiave privata RSA della chiave di wrapping pubblica RSA nel AWS CloudHSM cluster e il relativo `unwrap` attributo deve essere impostato su. `true` 

**Nota**  
Questo comando è disponibile solo con CloudHSM CLI 5.11\$1.

## Tipo di utente
<a name="cloudhsm_cli-key-unwrap-rsa-aes-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti CUs Crypto ()

## Requisiti
<a name="cloudhsm_cli-key-unwrap-rsa-aes-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempio
<a name="cloudhsm_cli-key-unwrap-rsa-aes-examples"></a>

Questi esempi mostrano come utilizzare il **key unwrap rsa-aes** comando utilizzando la chiave privata RSA con il valore dell'`unwrap`attributo `true` impostato su.

**Example Esempio: scartare una chiave di payload dai dati chiave avvolti codificati in Base64**  

```
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 Esempio: scartare una chiave di payload fornita tramite un percorso dati**  

```
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
      }
    }
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-unwrap-rsa-aes-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di selezione di una chiave da utilizzare.  
Obbligatorio: sì

***<DATA\$1PATH>***  
Percorso del file binario contenente i dati chiave racchiusi.  
Obbligatorio: Sì (a meno che non sia fornito tramite dati codificati Base64)

***<DATA>***  
Dati chiave avvolti codificati in Base64.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<ATTRIBUTES>***  
Elenco separato da spazi degli attributi chiave sotto forma `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di chiave racchiusa.  
Obbligatorio: no

***<KEY\$1TYPE\$1CLASS>***  
Tipo di chiave e classe di chiave racchiusa [valori possibili:`aes`,,, `des3` `ec-private``generic-secret`,`rsa-private`].  
Obbligatorio: sì

***<HASH\$1FUNCTION>***  
Specifica la funzione hash.  
Valori validi:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Obbligatorio: sì

***<MGF>***  
Specifica la funzione di generazione della maschera.   
La funzione hash della funzione di generazione della maschera deve corrispondere alla funzione hash del meccanismo di firma.
Valori validi:  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Obbligatorio: sì

***<LABEL>***  
Etichetta per la chiave aperta.  
Obbligatorio: sì

***<SESSION>***  
Crea una chiave di sessione che esiste solo nella sessione corrente. La chiave non può essere recuperata dopo la fine della sessione.  
Obbligatorio: no

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di unwrapping è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-unwrap-rsa-aes-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Estrarre una chiave con RSA-OAEP utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-unwrap-rsa-oaep"></a>

Utilizzate il **key unwrap rsa-oaep** comando nella CLI di CloudHSM per decomprimere una chiave di payload utilizzando la chiave privata RSA e il meccanismo di unwrapping. `RSA-OAEP`

Le chiavi aperte possono essere utilizzate nello stesso modo delle chiavi generate da. AWS CloudHSM Per indicare che non sono state generate localmente, il loro `local` attributo è impostato su. `false`

Per utilizzare il **key unwrap rsa-oaep** comando, è necessario disporre della chiave privata RSA della chiave di wrapping pubblica RSA nel AWS CloudHSM cluster e il relativo `unwrap` attributo deve essere impostato su. `true`

## Tipo di utente
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti crittografici () CUs

## Requisiti
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempi
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-examples"></a>

Questi esempi mostrano come utilizzare il **key unwrap rsa-oaep** comando utilizzando la chiave privata RSA con il valore dell'`unwrap`attributo `true` impostato su.

**Example Esempio: scartare una chiave di payload dai dati chiave avvolti codificati in Base64**  

```
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 Esempio: scartare una chiave di payload fornita tramite un percorso dati**  

```
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
      }
    }
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di selezione di una chiave da utilizzare.  
Obbligatorio: sì

***<DATA\$1PATH>***  
Percorso del file binario contenente i dati chiave racchiusi.  
Obbligatorio: Sì (a meno che non sia fornito tramite dati codificati Base64)

***<DATA>***  
Dati chiave avvolti codificati in Base64.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<ATTRIBUTES>***  
Elenco separato da spazi degli attributi chiave sotto forma `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di chiave racchiusa.  
Obbligatorio: no

***<KEY\$1TYPE\$1CLASS>***  
Tipo di chiave e classe di chiave racchiusa [valori possibili:`aes`,,, `des3` `ec-private``generic-secret`,`rsa-private`].  
Obbligatorio: sì

***<HASH\$1FUNCTION>***  
Specifica la funzione hash.  
Valori validi:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Obbligatorio: sì

***<MGF>***  
Specifica la funzione di generazione della maschera.   
La funzione hash della funzione di generazione della maschera deve corrispondere alla funzione hash del meccanismo di firma.
Valori validi:  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Obbligatorio: sì

***<LABEL>***  
Etichetta per la chiave aperta.  
Obbligatorio: sì

***<SESSION>***  
Crea una chiave di sessione che esiste solo nella sessione corrente. La chiave non può essere recuperata dopo la fine della sessione.  
Obbligatorio: no

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di unwrapping è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Estrarre una chiave con RSA-PKCS utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs"></a>

Utilizzate il **key unwrap rsa-pkcs** comando nella CLI di CloudHSM per decomprimere una chiave di payload utilizzando la chiave privata RSA e il meccanismo di unwrapping. `RSA-PKCS`

Le chiavi decomposte possono essere utilizzate nello stesso modo delle chiavi generate da. AWS CloudHSM Per indicare che non sono state generate localmente, il loro `local` attributo è impostato su. `false`

Per utilizzare il **unwrap rsa-pkcs** comando da tastiera, è necessario disporre della chiave privata RSA della chiave di wrapping pubblica RSA nel AWS CloudHSM cluster e il relativo `unwrap` attributo deve essere impostato su. `true`

## Tipo di utente
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempi
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-examples"></a>

Questi esempi mostrano come utilizzare il **key unwrap rsa-oaep** comando utilizzando una chiave AES con il valore dell'`unwrap`attributo impostato su`true`.

**Example Esempio: scartare una chiave di payload dai dati chiave avvolti codificati in Base64**  

```
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 Esempio: scartare una chiave di payload fornita tramite un percorso dati**  

```
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
      }
    }
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di selezione di una chiave da utilizzare.  
Obbligatorio: sì

***<DATA\$1PATH>***  
Percorso del file binario contenente i dati chiave racchiusi.  
Obbligatorio: Sì (a meno che non sia fornito tramite dati codificati Base64)

***<DATA>***  
Dati chiave avvolti codificati in Base64.  
Obbligatorio: Sì (a meno che non sia fornito tramite il percorso dati)

***<ATTRIBUTES>***  
Elenco separato da spazi degli attributi chiave sotto forma `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di chiave racchiusa.  
Obbligatorio: no

***<KEY\$1TYPE\$1CLASS>***  
Tipo di chiave e classe di chiave racchiusa [valori possibili:`aes`,,, `des3` `ec-private``generic-secret`,`rsa-private`].  
Obbligatorio: sì

***<LABEL>***  
Etichetta per la chiave aperta.  
Obbligatorio: sì

***<SESSION>***  
Crea una chiave di sessione che esiste solo nella sessione corrente. La chiave non può essere recuperata dopo la fine della sessione.  
Obbligatorio: no

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di unwrapping è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Il comando key wrap nella CLI di CloudHSM
<a name="cloudhsm_cli-key-wrap"></a>

Il **key wrap** comando nella CLI di CloudHSM esporta una copia crittografata di una chiave privata simmetrica o asimmetrica dal modulo di sicurezza hardware (HSM) in un file. Quando si esegue**key wrap**, si specificano due cose: la chiave da esportare e il file di output. La chiave da esportare è una chiave sull'HSM che crittograferà (avvolgerà) la chiave da esportare.

Il **key wrap** comando non rimuove la chiave dall'HSM né impedisce di utilizzarla nelle operazioni crittografiche. È possibile esportare la stessa chiave più volte. Per reimportare la chiave crittografata nell'HSM, utilizzare. [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md) Solo il proprietario di una chiave, ovvero l'utente crittografico (CU) che ha creato la chiave, può impacchettare la chiave. Gli utenti con cui la chiave è condivisa possono utilizzarla solo per operazioni crittografiche.

Il **key wrap** comando è composto dai seguenti sottocomandi:
+ [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)

# Inserisci una chiave con AES-GCM utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-wrap-aes-gcm"></a>

Utilizzate il **key wrap aes-gcm** comando nella CLI di CloudHSM per eseguire il wrapping di una chiave di payload utilizzando una chiave AES sul modulo di sicurezza hardware (HSM) e sul meccanismo di wrapping. `AES-GCM` L'attributo della chiave di payload deve essere impostato su. `extractable` `true`

Solo il proprietario di una chiave, ovvero l'utente crittografico (CU) che ha creato la chiave, può impacchettare la chiave. Gli utenti che condividono la chiave possono utilizzarla nelle operazioni crittografiche.

Per utilizzare il **key wrap aes-gcm** comando, è necessario innanzitutto disporre di una chiave AES nel AWS CloudHSM cluster. È possibile generare una chiave AES per il wrapping con il [Genera una chiave AES simmetrica con CloudhSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) comando e l'`wrap`attributo `true` impostati su.

## Tipo di utente
<a name="cloudhsm_cli-key-wrap-aes-gcm-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-wrap-aes-gcm-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempio
<a name="cloudhsm_cli-key-wrap-aes-gcm-examples"></a>

Questo esempio mostra come utilizzare il **key wrap aes-gcm** comando utilizzando una chiave AES.

**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"
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-wrap-aes-gcm-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<PAYLOAD\$1FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di payload.  
Obbligatorio: sì

***<PATH>***  
Percorso del file binario in cui verranno salvati i dati chiave racchiusi.  
Obbligatorio: no

***<WRAPPING\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di avvolgimento.   
Obbligatorio: sì

***<AAD>***  
Valore AES GCM Additional Authenticated Data (AAD), in esadecimale.   
Obbligatorio: no

***<TAG\$1LENGTH\$1BITS>***  
Lunghezza del tag AES GCM in bit.  
Obbligatorio: sì

***<WRAPPING\$1APPROVALR>***  
Speciifica il percorso del file di un token quorum firmato per approvare l'operazione di wrapping key. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di wrapping è maggiore di 1.

***<PAYLOAD\$1APPROVALR>***  
Speciifica il percorso del file di un file di token quorum firmato per approvare l'operazione per la chiave di payload. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di payload è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-wrap-aes-gcm-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Avvolgi una chiave AES-NO-PAD utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-wrap-aes-no-pad"></a>

Utilizzate il **key wrap aes-no-pad** comando nella CLI di CloudHSM per eseguire il wrapping di una chiave di payload utilizzando una chiave AES sul modulo di sicurezza hardware (HSM) e sul meccanismo di wrapping. `AES-NO-PAD` L'attributo della chiave di payload deve essere impostato su. `extractable` `true`

Solo il proprietario di una chiave, ovvero l'utente crittografico (CU) che ha creato la chiave, può impacchettare la chiave. Gli utenti che condividono la chiave possono utilizzarla nelle operazioni crittografiche.

Per utilizzare il **key wrap aes-no-pad** comando, è necessario innanzitutto disporre di una chiave AES nel AWS CloudHSM cluster. È possibile generare una chiave AES per il wrapping utilizzando il [Genera una chiave AES simmetrica con CloudhSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) comando e l'`wrap`attributo `true` impostati su.

## Tipo di utente
<a name="cloudhsm_cli-key-wrap-aes-no-pad-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-wrap-aes-no-pad-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempio
<a name="cloudhsm_cli-key-wrap-aes-no-pad-examples"></a>

Questo esempio mostra come utilizzare il **key wrap aes-no-pad** comando utilizzando una chiave AES con il valore dell'`wrap`attributo impostato su`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"
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-wrap-aes-no-pad-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<PAYLOAD\$1FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di payload.  
Obbligatorio: sì

***<PATH>***  
Percorso del file binario in cui verranno salvati i dati chiave racchiusi.  
Obbligatorio: no

***<WRAPPING\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di avvolgimento.   
Obbligatorio: sì

***<WRAPPING\$1APPROVALR>***  
Specificate il percorso del file di un file token quorum firmato per approvare l'operazione di wrapping key. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di wrapping è maggiore di 1.

***<PAYLOAD\$1APPROVALR>***  
Speciifica il percorso del file di un file di token quorum firmato per approvare l'operazione per la chiave di payload. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di payload è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-wrap-aes-no-pad-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Avvolgi una chiave con AES- PKCS5 -PAD utilizzando la CLI CloudhSM
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad"></a>

Utilizzate il **key wrap aes-pkcs5-pad** comando nella CLI di CloudHSM per eseguire il wrapping di una chiave di payload utilizzando una chiave AES sul modulo di sicurezza hardware (HSM) e sul meccanismo di wrapping. `AES-PKCS5-PAD` L'attributo della chiave di payload deve essere impostato su. `extractable` `true`

Solo il proprietario di una chiave, ovvero l'utente crittografico (CU) che ha creato la chiave, può impacchettare la chiave. Gli utenti che condividono la chiave possono utilizzarla nelle operazioni crittografiche.

Per utilizzare il **key wrap aes-pkcs5-pad** comando, è necessario innanzitutto disporre di una chiave AES nel AWS CloudHSM cluster. È possibile generare una chiave AES per il wrapping utilizzando il [Genera una chiave AES simmetrica con CloudhSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) comando e l'`wrap`attributo `true` impostati su.

## Tipo di utente
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempio
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-examples"></a>

Questo esempio mostra come utilizzare il **key wrap aes-pkcs5-pad** comando utilizzando una chiave AES con il valore dell'`wrap`attributo impostato su`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="
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<PAYLOAD\$1FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di payload.  
Obbligatorio: sì

***<PATH>***  
Percorso del file binario in cui verranno salvati i dati chiave racchiusi.  
Obbligatorio: no

***<WRAPPING\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di avvolgimento.   
Obbligatorio: sì

***<WRAPPING\$1APPROVALR>***  
Specificate il percorso del file di un file token quorum firmato per approvare l'operazione di wrapping key. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di wrapping è maggiore di 1.

***<PAYLOAD\$1APPROVALR>***  
Speciifica il percorso del file di un file di token quorum firmato per approvare l'operazione per la chiave di payload. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di payload è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Avvolgi una chiave AES-ZERO-PAD utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-wrap-aes-zero-pad"></a>

Utilizzate il **key wrap aes-zero-pad** comando nella CLI di CloudHSM per eseguire il wrapping di una chiave di payload utilizzando una chiave AES sul modulo di sicurezza hardware (HSM) e sul meccanismo di wrapping. `AES-ZERO-PAD` L'attributo della chiave di payload deve essere impostato su. `extractable` `true`

Solo il proprietario di una chiave, ovvero l'utente crittografico (CU) che ha creato la chiave, può impacchettare la chiave. Gli utenti che condividono la chiave possono utilizzarla nelle operazioni crittografiche.

Per utilizzare il **key wrap aes-zero-pad** comando, è necessario innanzitutto disporre di una chiave AES nel AWS CloudHSM cluster. È possibile generare una chiave AES per il wrapping utilizzando il [Genera una chiave AES simmetrica con CloudhSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) comando con l'`wrap`attributo `true` impostato su.

## Tipo di utente
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempio
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-examples"></a>

Questo esempio mostra come utilizzare il **key wrap aes-zero-pad ** comando utilizzando una chiave AES con il valore dell'`wrap`attributo impostato su`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"
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<PAYLOAD\$1FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di payload.  
Obbligatorio: sì

***<PATH>***  
Percorso del file binario in cui verranno salvati i dati chiave racchiusi.  
Obbligatorio: no

***<WRAPPING\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di avvolgimento.   
Obbligatorio: sì

***<WRAPPING\$1APPROVALR>***  
Specificate il percorso del file di un file token quorum firmato per approvare l'operazione di wrapping key. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di wrapping è maggiore di 1.

***<PAYLOAD\$1APPROVALR>***  
Speciifica il percorso del file di un file di token quorum firmato per approvare l'operazione per la chiave di payload. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di payload è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Avvolgi una chiave CLOUDHSM-AES-GCM utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm"></a>

Utilizzate il **key wrap cloudhsm-aes-gcm** comando nella CLI di CloudHSM per eseguire il wrapping di una chiave di payload utilizzando una chiave AES sul modulo di sicurezza hardware (HSM) e sul meccanismo di wrapping. `CLOUDHSM-AES-GCM` L'attributo della chiave di payload deve essere impostato su. `extractable` `true`

Solo il proprietario di una chiave, ovvero l'utente crittografico (CU) che ha creato la chiave, può impacchettare la chiave. Gli utenti che condividono la chiave possono utilizzarla nelle operazioni crittografiche.

Per utilizzare il **key wrap cloudhsm-aes-gcm** comando, è necessario innanzitutto disporre di una chiave AES nel AWS CloudHSM cluster. È possibile generare una chiave AES per il wrapping con il [Genera una chiave AES simmetrica con CloudhSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) comando e l'`wrap`attributo `true` impostati su.

## Tipo di utente
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempio
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-examples"></a>

Questo esempio mostra come utilizzare il **key wrap cloudhsm-aes-gcm** comando utilizzando una chiave AES.

**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"
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<PAYLOAD\$1FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di payload.  
Obbligatorio: sì

***<PATH>***  
Percorso del file binario in cui verranno salvati i dati chiave racchiusi.  
Obbligatorio: no

***<WRAPPING\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di avvolgimento.   
Obbligatorio: sì

***<AAD>***  
Valore AES GCM Additional Authenticated Data (AAD), in esadecimale.   
Obbligatorio: no

***<TAG\$1LENGTH\$1BITS>***  
Lunghezza del tag AES GCM in bit.  
Obbligatorio: sì

***<WRAPPING\$1APPROVALR>***  
Speciifica il percorso del file di un token quorum firmato per approvare l'operazione di wrapping key. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di wrapping è maggiore di 1.

***<PAYLOAD\$1APPROVALR>***  
Speciifica il percorso del file di un file di token quorum firmato per approvare l'operazione per la chiave di payload. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di payload è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Inserisci una chiave con RSA-AES utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-wrap-rsa-aes"></a>

Utilizzate il **key wrap rsa-aes** comando nella CLI di CloudHSM per eseguire il wrapping di una chiave di payload utilizzando una chiave pubblica RSA sul modulo di sicurezza hardware (HSM) e sul meccanismo di wrapping RSA-AES. L'attributo della chiave payload deve essere impostato su. `extractable` `true`

Solo il proprietario di una chiave, ovvero l'utente crittografico (CU) che ha creato la chiave, può impacchettare la chiave. Gli utenti che condividono la chiave possono utilizzarla nelle operazioni crittografiche.

Per utilizzare il **key wrap rsa-aes** comando, è necessario innanzitutto disporre di una chiave RSA nel cluster AWS CloudHSM . È possibile generare una coppia di chiavi RSA utilizzando il [La generate-asymmetric-pair categoria nella CLI di CloudHSM](cloudhsm_cli-key-generate-asymmetric-pair.md) comando e l'`wrap`attributo `true` impostati su.

## Tipo di utente
<a name="cloudhsm_cli-key-wrap-rsa-aes-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-wrap-rsa-aes-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempio
<a name="cloudhsm_cli-key-wrap-rsa-aes-examples"></a>

Questo esempio mostra come utilizzare il **key wrap rsa-ae** comando utilizzando una chiave pubblica RSA con il valore dell'`wrap`attributo `true` impostato su.

**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=="
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-wrap-rsa-aes-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<PAYLOAD\$1FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di payload.  
Obbligatorio: sì

***<PATH>***  
Percorso del file binario in cui verranno salvati i dati chiave racchiusi.  
Obbligatorio: no

***<WRAPPING\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di avvolgimento.   
Obbligatorio: sì

***<MGF>***  
Specifica la funzione di generazione della maschera.  
La funzione hash della funzione di generazione della maschera deve corrispondere alla funzione hash del meccanismo di firma.
Valori validi  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Obbligatorio: sì

***<WRAPPING\$1APPROVALR>***  
Speciifica il percorso del file di un token quorum firmato per approvare l'operazione di wrapping key. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di wrapping è maggiore di 1.

***<PAYLOAD\$1APPROVALR>***  
Speciifica il percorso del file di un file di token quorum firmato per approvare l'operazione per la chiave di payload. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di payload è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-wrap-rsa-aes-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Inserisci una chiave con RSA-OAEP utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-wrap-rsa-oaep"></a>

Utilizzate il **key wrap rsa-oaep** comando nella CLI di CloudHSM per eseguire il wrapping di una chiave di payload utilizzando una chiave pubblica RSA sul modulo di sicurezza hardware (HSM) e sul meccanismo di wrapping. `RSA-OAEP` L'attributo della chiave di payload deve essere impostato su. `extractable` `true`

Solo il proprietario di una chiave, ovvero l'utente crittografico (CU) che ha creato la chiave, può impacchettare la chiave. Gli utenti che condividono la chiave possono utilizzarla nelle operazioni crittografiche.

Per utilizzare il **key wrap rsa-oaep** comando, è necessario innanzitutto disporre di una chiave RSA nel cluster AWS CloudHSM . È possibile generare una coppia di chiavi RSA utilizzando il [La generate-asymmetric-pair categoria nella CLI di CloudHSM](cloudhsm_cli-key-generate-asymmetric-pair.md) comando e l'`wrap`attributo `true` impostati su.

## Tipo di utente
<a name="cloudhsm_cli-key-unwrap-rsa-aes-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-unwrap-rsa-aes-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempio
<a name="cloudhsm_cli-key-unwrap-rsa-aes-examples"></a>

Questo esempio mostra come utilizzare il **key wrap rsa-oaep** comando utilizzando una chiave pubblica RSA con il valore dell'`wrap`attributo `true` impostato su.

**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=="
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-unwrap-rsa-aes-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<PAYLOAD\$1FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di payload.  
Obbligatorio: sì

***<PATH>***  
Percorso del file binario in cui verranno salvati i dati chiave racchiusi.  
Obbligatorio: no

***<WRAPPING\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di avvolgimento.   
Obbligatorio: sì

***<MGF>***  
Specifica la funzione di generazione della maschera.  
La funzione hash della funzione di generazione della maschera deve corrispondere alla funzione hash del meccanismo di firma.
Valori validi  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Obbligatorio: sì

***<WRAPPING\$1APPROVALR>***  
Speciifica il percorso del file di un token quorum firmato per approvare l'operazione di wrapping key. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di wrapping è maggiore di 1.

***<PAYLOAD\$1APPROVALR>***  
Speciifica il percorso del file di un file di token quorum firmato per approvare l'operazione per la chiave di payload. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di payload è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-unwrap-rsa-aes-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Inserisci una chiave con RSA-PKCS utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-key-wrap-rsa-pkcs"></a>

Utilizzate il **key wrap rsa-pkcs** comando nella CLI di CloudHSM per eseguire il wrapping di una chiave di payload utilizzando una chiave pubblica RSA sul modulo di sicurezza hardware (HSM) e sul meccanismo di wrapping. `RSA-PKCS` L'attributo della chiave di payload deve essere impostato su. `extractable` `true`

Solo il proprietario di una chiave, ovvero l'utente crittografico (CU) che ha creato la chiave, può impacchettare la chiave. Gli utenti che condividono la chiave possono utilizzarla nelle operazioni crittografiche.

Per utilizzare il **key wrap rsa-pkcs** comando, è necessario innanzitutto disporre di una chiave RSA nel cluster AWS CloudHSM . È possibile generare una coppia di chiavi RSA utilizzando il [La generate-asymmetric-pair categoria nella CLI di CloudHSM](cloudhsm_cli-key-generate-asymmetric-pair.md) comando e l'`wrap`attributo `true` impostati su.

## Tipo di utente
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Utenti Crypto () CUs

## Requisiti
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-requirements"></a>
+ Per eseguire questo comando, è necessario aver effettuato l'accesso come CU.

## Sintassi
<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
```

## Esempio
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-examples"></a>

Questo esempio mostra come utilizzare il **key wrap rsa-pkcs** comando utilizzando una chiave pubblica RSA.

**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=="
  }
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<PAYLOAD\$1FILTER>***  
Riferimento alla chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi degli attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di payload.  
Obbligatorio: sì

***<PATH>***  
Percorso del file binario in cui verranno salvati i dati chiave racchiusi.  
Obbligatorio: no

***<WRAPPING\$1FILTER>***  
Riferimento chiave (ad esempio,`key-reference=0xabc`) o elenco separato da spazi di attributi chiave sotto forma di selezione `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` di una chiave di avvolgimento.   
Obbligatorio: sì

***<WRAPPING\$1APPROVALR>***  
Specificate il percorso del file di un file token quorum firmato per approvare l'operazione di wrapping key. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di wrapping è maggiore di 1.

***<PAYLOAD\$1APPROVALR>***  
Speciifica il percorso del file di un file di token quorum firmato per approvare l'operazione per la chiave di payload. Richiesto solo se il valore del quorum del servizio di gestione delle chiavi della chiave di payload è maggiore di 1.

## Argomenti correlati
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-seealso"></a>
+ [Il comando key wrap nella CLI di CloudHSM](cloudhsm_cli-key-wrap.md)
+ [Il comando key unwrap nella CLI di CloudhSM](cloudhsm_cli-key-unwrap.md)

# Accedi a un HSM utilizzando CloudHSM CLI
<a name="cloudhsm_cli-login"></a>

È possibile utilizzare il **login** comando nella CLI di CloudHSM per accedere e disconnettersi da ogni sicurezza hardware (HSM) in un cluster. AWS CloudHSM Questo comando ha il seguente sottocomando:
+ [mfa-token-sign](cloudhsm_cli-login-mfa-token-sign.md)

**Nota**  
Se superi cinque tentativi di accesso errati, il tuo account viene bloccato. Per sbloccare l'account, un admin deve reimpostare la password utilizzando il comando [user change-password](cloudhsm_cli-user-change-password.md) nella cloudhsm\$1cli.

## Per risolvere i problemi di accesso e disconnessione
<a name="troubleshoot-login-logout"></a>

Se disponi di più HSM nel cluster, potresti avere consentiti più tentativi di accesso errati prima che l'account venga bloccato. Questo perché il client CloudHSM bilancia il carico tra diversi tipi. HSMs Pertanto, il tentativo di accesso potrebbe non iniziare sullo stesso HSM ogni volta. Se stai testando questa funzionalità, ti consigliamo di farlo su un cluster con un solo HSM attivo. 

Se il cluster è stato creato prima di febbraio 2018, l'account viene bloccato dopo 20 tentativi di accesso errati. 

## Tipo di utente
<a name="chsm-cli-login-logout-userType"></a>

Gli utenti seguenti possono eseguire questi comandi.
+ Admin non attivato
+ Admin
+ Crypto user (CU)

## Sintassi
<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')
```

## Esempio
<a name="chsm-cli-login-example"></a>

**Example**  
Questo comando consente di accedere a tutti gli HSMs utenti di un cluster con le credenziali di un utente amministratore denominato. `admin1`  

```
aws-cloudhsm > login --username admin1 --role admin
Enter password:
{
  "error_code": 0,
  "data": {
    "username": "admin1",
    "role": "admin"
  }
}
```

## Arguments (Argomenti)
<a name="login-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire l'operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<USERNAME>***  
Specifica un nome intuitivo per l'utente. La lunghezza massima è 31 caratteri. L'unico carattere speciale consentito è il trattino basso (\$1). In questo comando il nome utente non è sensibile alle maiuscole e minuscole, il nome utente viene sempre visualizzato in minuscolo.  
Obbligatorio: sì

***<ROLE>***  
Specifica il ruolo assegnato a questo utente. I valori validi sono **admin**, **crypto-user**.  
Per ottenere il ruolo dell'utente, usa il **user list** comando. Per informazioni dettagliate sui tipi di utente su un HSM, vedi [Capire gli utenti dell'HSM](manage-hsm-users.md).  
Obbligatorio: sì

***<PASSWORD>***  
Speciifica la password dell'utente che accede a. HSMs  
Obbligatorio: i clienti devono fornire la password tramite l'argomento della `--password` riga di comando o ometterla per richiederla in modo interattivo.  
L'uso dell'`--password`argomento sulla riga di comando può esporre le credenziali nella cronologia della shell. Valuta la possibilità di richiedere la password in modo interattivo o di cancellare la cronologia della shell dopo l'uso.

## Argomenti correlati
<a name="login-seeAlso"></a>
+ [Guida introduttiva alla CLI di CloudHSM](cloudhsm_cli-getting-started.md)
+ [Attivazione del cluster](activate-cluster.md)

# Accedi con MFA a un HSM utilizzando CloudHSM CLI
<a name="cloudhsm_cli-login-mfa-token-sign"></a>

Utilizza il **login mfa-token-sign** comando nella AWS CloudHSM CLI di CloudHSM per accedere a un modulo di sicurezza hardware (HSM) utilizzando l'autenticazione a più fattori (MFA). Per utilizzare questo comando, devi prima configurare [MFA per la CLI del CloudHSM](login-mfa-token-sign.md).

## Tipo di utente
<a name="cloudhsm_cli-login-mfa-token-userType"></a>

Gli utenti seguenti possono eseguire questi comandi.
+ Admin
+ Crypto user (CU)

## Sintassi
<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
```

## Esempio
<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"
  }
}
```

## Arguments (Argomenti)
<a name="cloudhsm_cli-login-mfa-token-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<TOKEN>***  
Percorso del file in cui verrà scritto il file token non firmato.  
Campo obbligatorio: sì

## Argomenti correlati
<a name="cloudhsm_cli-login-mfa-token-seeAlso"></a>
+ [Guida introduttiva alla CLI di CloudHSM](cloudhsm_cli-getting-started.md)
+ [Attivazione del cluster](activate-cluster.md)
+ [Utilizzare la CLI di CloudHSM per gestire l'MFA](login-mfa-token-sign.md)

# Esci da un HSM utilizzando CloudHSM CLI
<a name="cloudhsm_cli-logout"></a>

Usa il **logout** comando nella CLI di CloudHSM per disconnetterti da ogni modulo di sicurezza hardware (HSM) in un cluster. AWS CloudHSM 

## Tipo di utente
<a name="chsm-cli-logout-userType"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Admin
+ Crypto user (CU)

## Sintassi
<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
```

## Esempio
<a name="chsm-cli-logout-example"></a>

**Example**  
Questo comando ti disconnette da tutti gli utenti di un cluster. HSMs   

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

## Argomenti correlati
<a name="logout-seeAlso"></a>
+ [Guida introduttiva alla CLI di CloudHSM](cloudhsm_cli-getting-started.md)
+ [Attivazione del cluster](activate-cluster.md)

# La categoria di utenti nella CLI di CloudHSM
<a name="cloudhsm_cli-user"></a>

Nella **user** CLI di CloudHSM, è una categoria principale per un gruppo di comandi che, se combinati con la categoria principale, creano un comando specifico per gli utenti. Attualmente, la categoria utente è composta dai seguenti comandi:
+ [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)
+ [replica utente](cloudhsm_cli-user-replicate.md)

# La categoria user change-mfa nella CLI di CloudhSM
<a name="cloudhsm_cli-user-change-mfa"></a>

Nella **user change-mfa** CLI di CloudHSM, è una categoria principale per un gruppo di comandi che, se combinati con la categoria principale, creano un comando specifico per modificare l'autenticazione a più fattori (MFA) per gli utenti.

Attualmente, questa categoria è composta dal seguente sottocomando:
+ [token-sign](cloudhsm_cli-user-change-mfa-token-sign.md)

# Modificare la configurazione MFA di un utente con CloudhSM CLI
<a name="cloudhsm_cli-user-change-mfa-token-sign"></a>

Utilizza il **user change-mfa token-sign** comando nella CLI di CloudHSM per aggiornare la configurazione dell'autenticazione a più fattori (MFA) di un account utente. Qualsiasi account utente può eseguire questo comando. Gli account con il ruolo di admin possono eseguire questo comando per altri utenti.

## Tipo di utente
<a name="user-change-mfa-type"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Admin
+ Crypto user

## Sintassi
<a name="user-change-mfa-syntax"></a>

Attualmente, è disponibile una sola strategia a più fattori per gli utenti: 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)
```

La strategia Token Firma richiede un file Token su cui scrivere token non firmati.

```
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')
```

## Esempio
<a name="user-change-mfa-examples"></a>

Questo comando scriverà un token non firmato per HSM nel cluster nel file specificato da `token`. Quando ti viene richiesto, firma i token presenti nel file.

**Example : Scrive un token non firmato per HSM nel tuo 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"
  }
}
```

### Arguments (Argomenti)
<a name="user-change-mfa-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<ROLE>***  
Specifica il ruolo assegnato all'account utente. Questo parametro è obbligatorio. Per informazioni dettagliate sui tipi di utente su un HSM, vedi [Capire gli utenti dell'HSM](manage-hsm-users.md).  
**Valori validi**  
+ **Admin**: gli admin possono gestire gli utenti, ma non possono gestire le chiavi.
+ **Crypto user**: gli utenti di crittografia possono creare e gestire le chiavi e utilizzarle nelle operazioni di crittografia.

***<USERNAME>***  
Specifica un nome intuitivo per l'utente. La lunghezza massima è 31 caratteri. L'unico carattere speciale consentito è un trattino basso (\$1).  
Non puoi modificare il nome di un utente dopo che è stato creato. Nei comandi della CLI di CloudHSM, il ruolo e la password sono sensibili alle maiuscole e alle minuscole, il nome utente no.  
**Campo obbligatorio**: sì

***<CHANGE\$1PASSWORD>***  
Specifica in testo semplice la nuova password dell'utente la cui MFA viene registrata/annullata.  
**Obbligatorio:** sì

***<TOKEN>***  
Percorso del file in cui verrà scritto il file token non firmato.  
**Campo obbligatorio**: sì

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio utenti è maggiore di 1.

***<DEREGISTER>***  
Annulla la registrazione della chiave pubblica MFA, se presente.

***<CHANGE-QUORUM>***  
Modifica la chiave pubblica del quorum insieme alla chiave MFA.

## Argomenti correlati
<a name="user-change-mfa-seealso"></a>
+ [Capire la 2FA per gli utenti dell'HSM](login-mfa-token-sign.md)

# Modifica della password di un utente con CloudhSM CLI
<a name="cloudhsm_cli-user-change-password"></a>

Utilizza il **user change-password** comando nella CLI di CloudHSM per modificare la password di un utente esistente nel cluster. AWS CloudHSM Per abilitare l'MFA per un utente, utilizzare il comando `user change-mfa`.

Qualsiasi utente può modificare la propria password. Inoltre, gli utenti con il ruolo di admin possono modificare la password di un altro utente nel cluster. Non è necessario immettere la password attuale per effettuare la modifica.

**Nota**  
Tuttavia, non potrai modificare la password di un utente che è attualmente connesso al cluster.

## Tipo di utente
<a name="change-password-user-type"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Admin
+ Crypto user (CU)

## Sintassi
<a name="change-password-syntax"></a>

**Nota**  
 Per abilitare l'autenticazione a più fattori (MFA) per un utente, usa **user change-mfa** il comando.

```
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')
```

## Esempio
<a name="change-password-examples"></a>

I seguenti esempi mostrano come utilizzare **user change-password** per reimpostare la password per l'utente corrente o qualsiasi altro utente nel cluster.

**Example : modifica la tua password**  
Qualsiasi utente del cluster può utilizzare il comando **user change-password** per modificare la propria password.  
Il seguente output indica che Bob è attualmente connesso come crypto user (CU).  

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

## Arguments (Argomenti)
<a name="change-password-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio utenti è maggiore di 1.

***<DEREGISTER-MFA>***  
Annulla la registrazione della chiave pubblica MFA, se presente.

***<DEREGISTER-QUORUM>***  
Annulla la registrazione della chiave pubblica del quorum, se presente.

***<PASSWORD>***  
Specifica la nuova password dell'utente in testo semplice. I seguenti caratteri non sono consentiti ':'  
**Obbligatorio:** sì

***<ROLE>***  
Specifica il ruolo assegnato all'account utente. Questo parametro è obbligatorio. Per informazioni dettagliate sui tipi di utente su un HSM, vedi [Capire gli utenti dell'HSM](manage-hsm-users.md).  
**Valori validi**  
+ **Admin**: gli admin possono gestire gli utenti, ma non possono gestire le chiavi.
+ **Crypto user**: gli utenti di crittografia possono creare e gestire le chiavi e utilizzarle nelle operazioni di crittografia.

***<USERNAME>***  
Specifica un nome intuitivo per l'utente. La lunghezza massima è 31 caratteri. L'unico carattere speciale consentito è un trattino basso (\$1).  
Non puoi modificare il nome di un utente dopo che è stato creato. Nei comandi della CLI di CloudHSM, il ruolo e la password sono sensibili alle maiuscole e alle minuscole, il nome utente no.  
**Campo obbligatorio**: sì

## Argomenti correlati
<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)

# La categoria del quorum di modifica degli utenti nella CLI di CloudhSM
<a name="cloudhsm_cli-user-chqm"></a>

Nella **user change-quorum** CLI di CloudHSM, è una categoria principale per un gruppo di comandi che, se combinati con la categoria principale, creano un comando specifico per la modifica del quorum per gli utenti.

**user change-quorum** viene utilizzato per registrare l'autenticazione del quorum degli utenti utilizzando una specifica strategia di quorum. A partire da SDK 5.8.0, è disponibile una sola strategia di quorum per gli utenti, come illustrato di seguito.

Attualmente, questa categoria è composta dalla seguente categoria e sottocomando:
+ [Token-firma](cloudhsm_cli-user-chqm-token.md)
  + [Registra](cloudhsm_cli-user-chqm-token-reg.md)

# La categoria token-sign per la modifica del quorum degli utenti nella CLI di CloudHSM
<a name="cloudhsm_cli-user-chqm-token"></a>

Nella **user change-quorum token-sign** CLI di CloudHSM, è presente una categoria principale per i comandi che, se combinati con questa categoria principale, creano un comando specifico per le operazioni quorum con firma token.

Attualmente, questa categoria comprende i seguenti comandi:
+ [Registra](cloudhsm_cli-user-chqm-token-reg.md)

# Registra la strategia del quorum di firma dei token di un utente utilizzando la CLI di CloudHSM
<a name="cloudhsm_cli-user-chqm-token-reg"></a>

Utilizza il comando **user change-quorum token-sign register** nella CLI di CloudHSM per registrare la strategia del quorum token-firma per un utente admin.

## Tipo di utente
<a name="token-register-user-type"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Admin

## Sintassi
<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')
```

## Esempio
<a name="token-register-examples"></a>

**Example**  
Per eseguire questo comando devi accedere come l' utente per il quale desideri **register quorum token-sign**.  

```
aws-cloudhsm > login --username admin1 --role admin
Enter password:
{
  "error_code": 0,
  "data": {
    "username": "admin1",
    "role": "admin"
  }
}
```
Il comando **user change-quorum token-sign register** registrerà la tua chiave pubblica con l'HSM. Di conseguenza, ti qualificherà come approvatore per le operazioni richieste dal quorum che richiedono che un utente ottenga le firme del quorum per raggiungere la soglia del quorum necessaria.  

```
aws-cloudhsm > user change-quorum token-sign register \
    --public-key /home/mypemfile \
    --signed-token /home/mysignedtoken
{
  "error_code": 0,
  "data": {
    "username": "admin1",
    "role": "admin"
  }
}
```
Ora puoi eseguire il comando **user list** e confermare che il quorum del token-firma è stato registrato per questo utente.  

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

## Arguments (Argomenti)
<a name="token-register-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<PUBLIC-KEY>***  
Percorso del file PEM della chiave pubblica.  
**Campo obbligatorio**: sì

***<SIGNED-TOKEN>***  
Percorso del file della chiave privata dell'utente con token firmato.  
**Campo obbligatorio**: sì

## Argomenti correlati
<a name="token-register-seealso"></a>
+ [Utilizzo della CLI di CloudHSM per la gestione dell'autenticazione del quorum](quorum-auth-chsm-cli.md)
+ [Utilizzo dell'autenticazione del quorum per admin: prima configurazione](quorum-auth-chsm-cli-first-time.md)
+ [Modifica del valore minimo del quorum per gli amministratori](quorum-auth-chsm-cli-min-value.md)
+ [Nomi e tipi di servizi che supportano l'autenticazione del quorum](quorum-auth-chsm-cli-service-names.md)

# Crea un AWS CloudHSM utente con CloudHSM CLI
<a name="cloudhsm_cli-user-create"></a>

Il **user create** comando nella CLI di CloudHSM crea un utente nel cluster. AWS CloudHSM Solo gli account utente con ruolo di admin possono eseguire questo comando.

## Tipo di utente
<a name="user-create-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Admin

## Requisiti
<a name="user-create-requirements"></a>

Per eseguire questo comando, è necessario aver effettuato l'accesso come admin

## Sintassi
<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')
```

## Esempio
<a name="user-create-examples"></a>

Questi esempi mostrano come utilizzare per **user create** creare nuovi utenti nel tuo. HSMs

**Example : creare un crypto user**  
Questo esempio crea un account nel AWS CloudHSM cluster con il ruolo di utente crittografico.  

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

## Arguments (Argomenti)
<a name="user-create-arguments"></a>

*<CLUSTER\$1ID>*  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

*<USERNAME>*  
Specifica un nome intuitivo per l'utente. La lunghezza massima è 31 caratteri. L'unico carattere speciale consentito è il trattino basso (\$1). In questo comando il nome utente non è sensibile alle maiuscole e minuscole, il nome utente viene sempre visualizzato in minuscolo.  
Obbligatorio: sì

*<ROLE>*  
Specifica il ruolo assegnato a questo utente. Questo parametro è obbligatorio. I valori validi sono **admin**, **crypto-user**.  
Per ottenere il ruolo dell'utente, usa il comando **user list**. Per informazioni dettagliate sui tipi di utente su un HSM, vedi [Capire gli utenti dell'HSM](manage-hsm-users.md).

*<PASSWORD>*  
Speciifica la password dell'utente che accede a. HSMs I seguenti caratteri non sono consentiti ':'  
Obbligatorio: sì

*<APPROVAL>*  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio utenti è maggiore di 1.

## Argomenti correlati
<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)

# Eliminare un AWS CloudHSM utente con CloudHSM CLI
<a name="cloudhsm_cli-user-delete"></a>

Il **user delete** comando nella CLI di CloudHSM elimina un utente dal cluster. AWS CloudHSM Solo gli account utente con ruolo di admin possono eseguire questo comando. Non è possibile eliminare un utente che è attualmente connesso a un HSM. 

## Tipo di utente
<a name="user-delete-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Admin

## Requisiti
<a name="user-delete-requirements"></a>
+ Non è possibile eliminare gli account utente che possiedono chiavi.
+ Il tuo account utente deve avere il ruolo di admin per eseguire questo comando.

## Sintassi
<a name="user-delete-syntax"></a>

Poiché questi comandi non dispongono di parametri denominati, è necessario immettere gli argomenti nell'ordine specificato nei diagrammi sintattici.

```
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
```

## Esempio
<a name="user-delete-examples"></a>

```
aws-cloudhsm > user delete --username alice --role crypto-user
{
  "error_code": 0,
  "data": {
    "username": "alice",
    "role": "crypto-user"
  }
}
```

## Arguments (Argomenti)
<a name="user-delete-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<USERNAME>***  
Specifica un nome intuitivo per l'utente. La lunghezza massima è 31 caratteri. L'unico carattere speciale consentito è il trattino basso (\$1). In questo comando il nome utente non è sensibile alle maiuscole e minuscole, il nome utente viene sempre visualizzato in minuscolo.  
Obbligatorio: sì

***<ROLE>***  
Specifica il ruolo assegnato a questo utente. Questo parametro è obbligatorio. I valori validi sono **admin**, **crypto-user**.  
Per ottenere il ruolo dell'utente, usa il comando **user list**. Per informazioni dettagliate sui tipi di utente su un HSM, vedi [Capire gli utenti dell'HSM](manage-hsm-users.md).  
Obbligatorio: sì

***<APPROVAL>***  
Specifica il percorso del file di un token firmato del quorum per approvare l'operazione. Richiesto solo se il valore del quorum del servizio utenti è maggiore di 1.  
Campo obbligatorio: sì

## Argomenti correlati
<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)

# Elenca tutti gli AWS CloudHSM utenti con CLI CloudHSM
<a name="cloudhsm_cli-user-list"></a>

Il **user list** comando nella CLI di CloudHSM elenca gli account utente presenti nel cluster. AWS CloudHSM Non è necessario che tu abbia eseguito l'accesso alla CLI di CloudHSM per eseguire questo comando.

**Nota**  
Se aggiungi o elimini HSMs, aggiorna i file di configurazione utilizzati dal AWS CloudHSM client e dagli strumenti della riga di comando. In caso contrario, le modifiche apportate potrebbero non essere valide per tutti HSMs gli utenti del cluster.

## Tipo di utente
<a name="user-list-userType"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Tutti gli utenti. Non è necessario che tu abbia eseguito l'accesso per eseguire questo comando.

## Sintassi
<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
```

## Esempio
<a name="chsm-cli-user-list-examples"></a>

Questo comando elenca gli utenti presenti nel cluster CloudHSM.

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

L'output include i seguenti attributi degli utenti:
+ **Nome utente**: Visualizza il nome intuitivo definito dall'utente. Il nome utente viene sempre visualizzato in lettere minuscole. 
+ **Ruolo**: stabilisce quali operazioni può eseguire l'utente sull'HSM.
+ **Bloccato**: indica se questo account utente è stato bloccato.
+ **MFA**: indica i meccanismi di autenticazione a più fattori supportati per questo account utente.
+ **Copertura del cluster**: Indica la disponibilità a livello di cluster di questo account utente.

## Argomenti correlati
<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)

# Replica un utente con CloudHSM CLI
<a name="cloudhsm_cli-user-replicate"></a>

Utilizza il **user replicate** comando nella CLI di CloudHSM per replicare un utente da AWS CloudHSM un cluster di origine a un cluster di destinazione. AWS CloudHSM 

## Tipo di utente
<a name="chsm-cli-user-replicate-user-type"></a>

I seguenti tipi di utenti possono eseguire questo comando.
+ Amministratori () COs

## Requisiti
<a name="cloudhsm_cli-user-replicate-requirements"></a>
+ I cluster di origine e di destinazione devono essere cloni. Ciò significa che uno è stato creato da un backup dell'altro o entrambi sono stati creati da un backup comune. Per ulteriori informazioni, consulta [Creazione di cluster dai backup](create-cluster-from-backup.md).
+ Per eseguire questo comando, è necessario accedere come amministratore sia nel cluster di origine che in quello di destinazione.
  +  In modalità a comando singolo, il comando utilizzerà le variabili ambientali CLOUDHSM\$1PIN e CLOUDHSM\$1ROLE per l'autenticazione nel cluster di origine. Per ulteriori informazioni, consulta [Modalità di comando singolo](cloudhsm_cli-modes.md#cloudhsm_cli-mode-single-command). Per fornire le credenziali per il cluster di destinazione, è necessario impostare due variabili ambientali aggiuntive: DESTINATION\$1CLOUDHSM\$1PIN e DESTINATION\$1CLOUDHSM\$1ROLE:

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

    ```
    $ export DESTINATION_CLOUDHSM_PIN=<username:password>
    ```
  +  In modalità interattiva, gli utenti dovranno accedere in modo esplicito ai cluster di origine e di destinazione.

## Sintassi
<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')
```

## Esempi
<a name="chsm-cli-user-replicate-examples"></a>

**Example Esempio: utente replicato**  
Questo comando replica un utente da un cluster di origine a un cluster di destinazione clonato. L'esempio seguente mostra l'output quando si accede come amministratore su entrambi i cluster.  

```
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"
  }
}
```

## Arguments (Argomenti)
<a name="user-replicate-arguments"></a>

***<USERNAME>***  
Speciifica il nome utente dell'utente da replicare nel cluster di origine.  
Obbligatorio: sì

***<ROLE>***  
Specifica il ruolo assegnato a questo utente. Questo parametro è obbligatorio. I valori validi sono **admin**, **crypto-user**.  
Per ottenere il ruolo dell'utente, usa il comando **user list**. Per informazioni dettagliate sui tipi di utente su un HSM, vedi [Capire gli utenti dell'HSM](manage-hsm-users.md).  
Obbligatorio: sì

***<SOURCE\$1CLUSTER\$1ID>***  
L'ID del cluster di origine.  
Obbligatorio: sì

***<DESTINATION\$1CLUSTER\$1ID>***  
L'ID del cluster di destinazione.  
Campo obbligatorio: sì

## Argomenti correlati
<a name="chsm-user-replicate-seealso"></a>
+ [Connessione a più cluster con la CLI CloudhSM](cloudhsm_cli-configs-multi-cluster.md)

# La categoria quorum nella CLI di CloudhSM
<a name="cloudhsm_cli-qm"></a>

Nella **quorum** CLI di CloudHSM, è una categoria principale per un gruppo di comandi che, se **quorum** combinato con, crea un comando specifico per l'autenticazione quorum, o operazioni M of N.. Attualmente, questa categoria è costituita dalla sottocategoria **token-sign** che comprende i propri comandi. Per informazioni dettagliate, clicca sul seguente link.
+ [token-sign](cloudhsm_cli-qm-token.md)

**Servizi admin**: l'autenticazione del quorum viene utilizzata per servizi che necessitano dei privilegi dell'admin come la creazione e l'eliminazione di utenti, la modifica delle password degli utenti, l'impostazione dei valori del quorum e la disattivazione delle funzionalità quorum e MFA.

**Crypto User Services**: l'autenticazione Quorum viene utilizzata per i servizi privilegiati degli utenti crittografici associati a una chiave specifica, come la firma con una chiave, una chiave, una chiave e l'impostazione dell'attributo di sharing/unsharing una chiave. wrapping/unwrapping Il valore quorum di una chiave associata viene configurato quando la chiave viene generata, importata o aperta. Il valore del quorum deve essere uguale o inferiore al numero di utenti a cui è associata la chiave, che include gli utenti con cui la chiave è condivisa e il proprietario della chiave.

Ogni tipo di servizio è ulteriormente suddiviso in un nome di servizio qualificante, che contiene un set specifico di operazioni di servizio supportate dal quorum che possono essere eseguite.


****  

| Nome del servizio | Tipo di servizio | Operazioni di servizio | 
| --- | --- | --- | 
| Utente | Admin |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-qm.html)  | 
| quorum | Admin |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-qm.html)  | 
| gruppo 1 | Admin |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-qm.html)  | 
| gestione delle chiavi | Utente Crypto |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-qm.html)  | 
| utilizzo delle chiavi | Utente Crypto |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-qm.html)  | 

[1] Il servizio cluster è disponibile esclusivamente su hsm2m.medium

## Argomenti correlati
<a name="cloudhsm_cli-qm-seealso"></a>
+ [Configura l'autenticazione del quorum per gli amministratori utilizzando la CLI AWS CloudHSM CloudhSM](quorum-auth-chsm-cli-first-time.md)
+ [Gestisci l'autenticazione del quorum (controllo degli accessi M of N) utilizzando la CLI CloudhSM](quorum-auth-chsm-cli.md)

# La categoria quorum token-sign nella CLI di CloudhSM
<a name="cloudhsm_cli-qm-token"></a>

Nella **quorum token-sign** CLI di CloudHSM, è una categoria per un gruppo di comandi che, se **quorum token-sign** combinati con, creano un comando specifico per l'autenticazione quorum, o operazioni M of N..

Attualmente, questa categoria comprende i seguenti comandi:
+ [Elimina](cloudhsm_cli-qm-token-del.md)
+ [Generazione](cloudhsm_cli-qm-token-gen.md)
+ [elenco](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)

# Eliminare i token del quorum utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-qm-token-del"></a>

Utilizza il comando **quorum token-sign delete** nella CLI di CloudHSM per eliminare uno o più token per un servizio autorizzato dal quorum.

## Tipo di utente
<a name="quorum-token-delete-user-type"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Admin

## Sintassi
<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')
```

## Esempio
<a name="quorum-token-delete-examples"></a>

L'esempio seguente mostra come utilizzare il comando **quorum token-sign delete** nella CLI di CloudHSM per eliminare uno o più token per un servizio autorizzato dal quorum.

**Example : Eliminare uno o più token per un servizio autorizzato dal quorum**  

```
aws-cloudhsm > quorum token-sign delete --scope all
{
  "error_code": 0,
  "data": "Deletion of quorum token(s) successful"
}
```

## Arguments (Argomenti)
<a name="quorum-token-delete-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<SCOPE>***  
L'ambito in cui i token verranno eliminati nel AWS CloudHSM cluster.  
**Valori validi**  
+ **Utente**: utilizzato per eliminare solo i token di proprietà dell'utente connesso.
+ **Tutti**: utilizzato per eliminare tutti i token nel AWS CloudHSM cluster.

## Argomenti correlati
<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)

# Genera un token di quorum utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-qm-token-gen"></a>

Utilizza il comando **quorum token-sign generate** nella CLI di CloudHSM per generare un token per un servizio autorizzato dal quorum.

Esiste un limite all'ottenimento di un token attivo per utente per servizio su un cluster HSM per i servizi utente e il quorum. Questo limite non si applica ai token relativi ai servizi chiave.

**Nota**  
Solo gli amministratori e gli utenti Crypto possono generare token di servizio specifici. Per ulteriori informazioni sui tipi e sui nomi dei servizi, consulta Nomi e tipi [di servizi che supportano l'autenticazione quorum](quorum-auth-chsm-cli-service-names.md)

**Servizi admin**: l'autenticazione del quorum viene utilizzata per servizi che necessitano dei privilegi dell'admin come la creazione e l'eliminazione di utenti, la modifica delle password degli utenti, l'impostazione dei valori del quorum e la disattivazione delle funzionalità quorum e MFA.

**Crypto User Services**: l'autenticazione quorum viene utilizzata per i servizi privilegiati degli utenti crittografici associati a una chiave specifica, come la firma con una chiave, sharing/unsharing una chiave e l'impostazione dell'attributo di wrapping/unwrapping una chiave. Il valore quorum di una chiave associata viene configurato quando la chiave viene generata, importata o aperta. Il valore del quorum deve essere uguale o inferiore al numero di utenti a cui è associata la chiave, che include gli utenti con cui la chiave è condivisa e il proprietario della chiave.

Ogni tipo di servizio è ulteriormente suddiviso in un nome di servizio qualificante, che contiene un set specifico di operazioni di servizio supportate dal quorum che possono essere eseguite.


****  

| Nome del servizio | Tipo di servizio | Operazioni di servizio | 
| --- | --- | --- | 
| Utente | Admin |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-qm-token-gen.html)  | 
| quorum | Admin |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-qm-token-gen.html)  | 
| gruppo 1 | Admin |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-qm-token-gen.html)  | 
| gestione delle chiavi | Utente Crypto |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-qm-token-gen.html)  | 
| utilizzo delle chiavi | Utente Crypto |  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/cloudhsm_cli-qm-token-gen.html)  | 

[1] Il servizio cluster è disponibile esclusivamente su hsm2m.medium

## Tipo di utente
<a name="quorum-token-generate-user-type"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Admin
+ Crypto user (CU)

## Sintassi
<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
```

## Esempio
<a name="quorum-token-generate-examples"></a>

Questo comando scriverà un token non firmato per HSM nel cluster nel file specificato da `token`.

**Example : Scrive un token non firmato per HSM nel tuo cluster**  

```
aws-cloudhsm > quorum token-sign generate --service user --token /home/tfile
{
  "error_code": 0,
  "data": {
    "filepath": "/home/tfile"
  }
}
```

## Arguments (Argomenti)
<a name="quorum-token-generate-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<SERVICE>***  
Specifica il servizio autorizzato dal quorum per cui generare un token. Questo parametro è obbligatorio.  
**Valori validi**  
+ **Utente**: il servizio di gestione degli utenti utilizzato per eseguire operazioni di gestione degli utenti autorizzati dal quorum.
+ **Quorum**: il servizio di gestione del quorum utilizzato per impostare i valori autorizzati del quorum per qualsiasi servizio autorizzato del quorum.
+ **cluster**: il servizio di gestione del cluster utilizzato per l'esecuzione del quorum per la gestione della configurazione a livello di cluster come mtls enforcement, mtls registration e mtls deregistration.
+ **Registra**: genera un token non firmato da utilizzare per la registrazione di una chiave pubblica per l'autorizzazione del quorum.
+ **key-usage**: genera un token non firmato che viene utilizzato per eseguire operazioni di utilizzo delle chiavi autorizzate dal quorum.
+ **gestione delle chiavi**: genera un token non firmato che viene utilizzato per eseguire operazioni di gestione delle chiavi autorizzate dal quorum.
**Obbligatorio:** sì

***<TOKEN>***  
Percorso del file in cui verrà scritto il file token non firmato.  
**Campo obbligatorio**: sì

## Argomenti correlati
<a name="quorum-token-generate-seealso"></a>
+ [Nomi e tipi di servizi che supportano l'autenticazione del quorum](quorum-auth-chsm-cli-service-names.md)

# Elenca i token del quorum utilizzando la CLI CloudhSM
<a name="cloudhsm_cli-qm-token-list"></a>

Usa il **quorum token-sign list** comando nella CLI di CloudHSM per elencare tutti i token quorum con firma a token presenti nel cluster. AWS CloudHSM Ciò include i token generati da altri utenti. Un token è associato a un utente, quindi, sebbene tu possa vedere i token di altri utenti, potrai utilizzare solo i token associati all'utente attualmente connesso.

Per ulteriori informazioni sui tipi e sui nomi dei servizi, vedi [Nomi e tipi di servizio che supportano l'autenticazione del quorum](quorum-auth-chsm-cli-service-names.md). Per ulteriori informazioni sul contenuto visualizzato dai token elencati, vedere rispettivamente [Gestione e utilizzo delle chiavi con autenticazione quorum abilitata per l'utilizzo della CLI di AWS CloudHSM CloudHSM](key-quorum-auth-chsm-cli-crypto-user.md) i token associati a `key-management` e `key-usage` i servizi e vedere [Gestione degli utenti con autenticazione quorum abilitata per l'utilizzo della CLI AWS CloudHSM CloudhSM](quorum-auth-chsm-cli-admin.md) i token associati `user` a o al servizio. `quorum` `cluster`

## Tipo di utente
<a name="quorum-token-list-user-type"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Admin
+ Crypto user (CU)

## Sintassi
<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
```

## Esempio
<a name="quorum-token-list-examples"></a>

Questo comando elencherà tutti i token token-sign presenti nel cluster. AWS CloudHSM Ciò include i token generati da altri utenti. Un token è associato a un utente, quindi, sebbene tu possa vedere i token di altri utenti, potrai utilizzare solo i token associati all'utente attualmente connesso.

**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
      }
    ]
  }
}
```

## Argomenti correlati
<a name="quorum-token-list-seealso"></a>
+ [quorum token-sign generate](cloudhsm_cli-qm-token-gen.md)

# Mostra i valori del quorum utilizzando la CLI CloudhSM
<a name="cloudhsm_cli-qm-token-list-qm"></a>

Utilizza il **quorum token-sign list-quorum-values** comando nella CLI di CloudHSM per elencare i valori del quorum impostati nel cluster. AWS CloudHSM 

## Tipo di utente
<a name="quorum-token-list-qm-user-type"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Tutti gli utenti. Non è necessario che tu abbia eseguito l'accesso per eseguire questo comando.

## Sintassi
<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
```

## Esempio
<a name="quorum-token-list-qm-examples"></a>

Questo comando elenca i valori di quorum impostati nel cluster per ogni servizio. AWS CloudHSM 

**Example**  
**hsm1.medium:**  

```
aws-cloudhsm > quorum token-sign list-quorum-values
{
  "error_code": 0,
  "data": {
    "user": 1,
    "quorum": 1
  }
}
```
**hsm2m.medium**:  

```
aws-cloudhsm > quorum token-sign list-quorum-values
{
  "error_code": 0,
  "data": {
    "user": 1,
    "quorum": 1,
    "cluster": 1
  }
}
```

## Argomenti correlati
<a name="quorum-token-list-qm-seealso"></a>
+ [Nomi e tipi di servizi che supportano l'autenticazione del quorum](quorum-auth-chsm-cli-service-names.md)
+  [Configurazione MTL (consigliata)](getting-started-setup-mtls.md) 

# Aggiornare un valore di quorum utilizzando la CLI di CloudhSM
<a name="cloudhsm_cli-qm-token-set-qm"></a>

Utilizza il comando **quorum token-sign set-quorum-value** nella CLI di CloudHSM per impostare un nuovo valore di quorum per un servizio autorizzato.

## Tipo di utente
<a name="quorum-token-set-qm-user-type"></a>

Gli utenti seguenti possono eseguire questo comando.
+ Admin

## Sintassi
<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')
```

## Esempio
<a name="quorum-token-set-qm-examples"></a>

**Example**  
Nell'esempio seguente, questo comando scrive un token non firmato per l'HSM nel cluster nel file specificato dal token. Quando ti viene richiesto, firma i token presenti nel file.  

```
aws-cloudhsm > quorum token-sign set-quorum-value --service quorum --value 2
{
  "error_code": 0,
  "data": "Set Quorum Value successful"
}
```
Puoi quindi eseguire il comando **list-quorum-values** per confermare che il valore del quorum per il servizio di gestione del quorum è stato impostato:  
**hsm1.medium:**  

```
aws-cloudhsm > quorum token-sign list-quorum-values
{
  "error_code": 0,
  "data": {
    "user": 1,
    "quorum": 2
  }
}
```
**hsm2m.medium**:  

```
aws-cloudhsm > quorum token-sign list-quorum-values
{
  "error_code": 0,
  "data": {
    "user": 1,
    "quorum": 2,
    "cluster": 1
  }
}
```

## Arguments (Argomenti)
<a name="quorum-token-set-qm-arguments"></a>

***<CLUSTER\$1ID>***  
L'ID del cluster su cui eseguire questa operazione.  
Obbligatorio: se sono stati [configurati](cloudhsm_cli-configs-multi-cluster.md) più cluster.

***<APPROVAL>***  
Il percorso del file token firmato da approvare sull'HSM.

***<SERVICE>***  
Specifica il servizio autorizzato dal quorum per cui generare un token. Questo parametro è obbligatorio. Per ulteriori informazioni sui tipi e sui nomi dei servizi, vedi [Nomi e tipi di servizio che supportano l'autenticazione del quorum](quorum-auth-chsm-cli-service-names.md).  
**Valori validi**  
+ **Utente**: Il servizio di gestione degli utenti. Servizio utilizzato per eseguire operazioni di gestione degli utenti autorizzate dal quorum.
+ **Quorum**: il servizio di gestione del quorum. Servizio utilizzato per impostare i valori autorizzati del quorum per qualsiasi servizio autorizzato dal quorum.
+ **cluster**: il servizio di gestione del cluster utilizzato per l'esecuzione del quorum per la gestione della configurazione a livello di cluster come mtls enforcement, mtls registration e mtls deregistration.
+ **Registra**: genera un token non firmato da utilizzare per registrare una chiave pubblica per l'autorizzazione del quorum.
**Campo obbligatorio**: sì

***<VALUE>***  
Specifica il valore del quorum da impostare. Il valore del quorum massimo è otto (8).  
**Campo obbligatorio**: sì

## Argomenti correlati
<a name="quorum-token-set-qm-seealso"></a>
+ [firma del token del quorum list-quorum-values](cloudhsm_cli-qm-token-list-qm.md)
+ [Nomi e tipi di servizi che supportano l'autenticazione del quorum](quorum-auth-chsm-cli-service-names.md)
+ [Configurazione MTL (consigliata)](getting-started-setup-mtls.md)