As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# A key na CLI do CloudHSM
<a name="cloudhsm_cli-key"></a>

Na CLI do CloudHSM, **key** é uma categoria principal para um grupo de comandos que, quando combinado com a categoria principal, cria um comando específico para chaves. Atualmente, essa categoria consiste nos seguintes comandos:
+ [excluir](cloudhsm_cli-key-delete.md)
+ [generate-file](cloudhsm_cli-key-generate-file.md)
+ [chave generate-asymmetric-pair](cloudhsm_cli-key-generate-asymmetric-pair.md)
  + [chave generate-asymmetric-pair rsa](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md)
  + [chave, generate-asymmetric-pair etc.](cloudhsm_cli-key-generate-asymmetric-pair-ec.md)
+ [key generate-symmetric](cloudhsm_cli-key-generate-symmetric.md)
  + [key generate-symmetric aes](cloudhsm_cli-key-generate-symmetric-aes.md)
  + [key generate-symmetric generic-secret](cloudhsm_cli-key-generate-symmetric-generic-secret.md)
+ [importar pem](cloudhsm_cli-key-import-pem.md)
+ [listar](cloudhsm_cli-key-list.md)
+ [replicar](cloudhsm_cli-key-replicate.md)
+ [set-attribute](cloudhsm_cli-key-set-attribute.md)
+ [compartilhar](cloudhsm_cli-key-share.md)
+ [cancelar compartilhamento](cloudhsm_cli-key-unshare.md)
+ [unwrap](cloudhsm_cli-key-unwrap.md)
+ [wrap](cloudhsm_cli-key-wrap.md)

# Excluir uma chave com a CLI do CloudHSM
<a name="cloudhsm_cli-key-delete"></a>

Use o **key delete** comando na CLI do CloudHSM para excluir uma chave de um cluster. AWS CloudHSM Você só pode excluir uma chave por vez. A exclusão de uma chave em um par de chaves não tem efeito na outra chave do par. 

Somente o CU que criou a chave e, consequentemente, a possui pode excluir a chave. Os usuários que compartilham a chave, mas não a possuem, podem usá-la em operações criptográficas, mas não podem excluí-la.

## Tipo de usuário
<a name="key-delete-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="key-delete-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

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

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

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave correspondente para exclusão.  
Para obter uma lista dos atributos de chave da CLI do CloudHSM com suporte, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md).  
Obrigatório: Sim

## Tópicos relacionados
<a name="key-delete-seealso"></a>
+ [Listar chaves para um usuário com a CloudHSM CLI](cloudhsm_cli-key-list.md)
+ [Exportar uma chave assimétrica com a CloudHSM CLI](cloudhsm_cli-key-generate-file.md)
+ [Cancelar o compartilhamento de uma chave usando a CloudHSM CLI](cloudhsm_cli-key-unshare.md)
+ [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)
+ [Filtrar chaves usando a CLI do CloudHSM](manage-keys-cloudhsm-cli-filtering.md)

# Exportar uma chave assimétrica com a CloudHSM CLI
<a name="cloudhsm_cli-key-generate-file"></a>

Use o comando **key generate-file** na CloudHSM CLI para exportar uma chave assimétrica do módulo de segurança de hardware (HSM). Se o destino for uma chave privada, a referência à chave privada será exportada no formato PEM falso. Se o destino for uma chave pública, os bytes da chave pública serão exportados no formato PEM.

O arquivo PEM falso, que não contém o material real da chave privada, mas faz referência à chave privada no HSM, pode ser usado para estabelecer o SSL/TLS descarregamento do seu servidor web para o. AWS CloudHSM Para obter mais informações, consulte [Descarregamento de SSL/TLS](ssl-offload.md).

## Tipo de usuário
<a name="key-generate-file-user-type"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

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

Para executar esse comando, você deve estar registrado(a) como um CU.

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

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

Este exemplo mostra como usar **key generate-file** para gerar um arquivo de chave em seu 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"
  }
}
```

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

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave correspondente para exclusão.  
Para obter uma lista dos atributos de chave compatíveis com a CloudHSM CLI, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)  
Obrigatório: não

***<ENCODING>***  
Especifica o formato de codificação para o arquivo de chave  
Obrigatório: Sim

***<PATH>***  
Especifica o caminho do arquivo em que o arquivo de chave será gravado  
Obrigatório: Sim

## Gerar referências de chave KSP (Windows)
<a name="key-generate-ksp-key-reference"></a>

**nota**  
Esse atributo só está disponível no SDK versão 5.16.0 e posterior.

### Pré-requisitos
<a name="key-generate-ksp-key-reference-requirements"></a>
+ Você pode gerar referências de chave KSP somente em plataformas Windows.
+ Você deve fazer login como usuário de criptografia (CU).

### Local do arquivo
<a name="key-generate-ksp-key-reference-options"></a>

Por padrão, o AWS CloudHSM armazena arquivos gerados em: `C:\Users\Default\AppData\Roaming\Microsoft\Crypto\CaviumKSP\GlobalPartition`

Para especificar uma localização diferente, use o parâmetro `--path`.

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

### Exemplo: gerar uma referência de chave KSP usando um filtro de atributos de uma chave privada
<a name="key-generate-ksp-key-reference-example1"></a>

O exemplo a seguir gera uma referência de chave KSP para uma chave privada com um rótulo específico.

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

### Exemplo: gerar referências de chave KSP para todos os pares de chaves
<a name="key-generate-ksp-key-reference-example2"></a>

O exemplo a seguir gera referências de chave KSP para todos os pares de chaves em seu cluster.

**Example**  

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

## Tópicos relacionados
<a name="key-generate-file-seealso"></a>
+ [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)
+ [Filtrar chaves usando a CLI do CloudHSM](manage-keys-cloudhsm-cli-filtering.md)
+ [A generate-asymmetric-pair categoria na CLI do CloudHSM](cloudhsm_cli-key-generate-asymmetric-pair.md)
+ [A categoria generate-symmetric na CLI do CloudHSM](cloudhsm_cli-key-generate-symmetric.md)

# A generate-asymmetric-pair categoria na CLI do CloudHSM
<a name="cloudhsm_cli-key-generate-asymmetric-pair"></a>

Na CLI do CloudHSM, **key generate-asymmetric-pair** é uma categoria principal para um grupo de comandos que, quando combinados com a categoria principal, criam um comando que gera pares de chaves assimétricas. Atualmente, essa categoria consiste nos seguintes comandos:
+ [chave generate-asymmetric-pair etc.](cloudhsm_cli-key-generate-asymmetric-pair-ec.md)
+ [chave generate-asymmetric-pair rsa](cloudhsm_cli-key-generate-asymmetric-pair-rsa.md)

# Gerar um par de chaves EC assimétricas com a CloudHSM CLI
<a name="cloudhsm_cli-key-generate-asymmetric-pair-ec"></a>

Use o **key asymmetric-pair ec** comando na CLI do CloudHSM para gerar um par de chaves de curva elíptica (EC) assimétrica em seu cluster. AWS CloudHSM 

## Tipo de usuário
<a name="key-generate-asymmetric-pair-ec-user-type"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

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

Para executar esse comando, você deve estar registrado(a) como um CU.

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

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

Esses exemplos mostram como usar o **key generate-asymmetric-pair ec** comando para criar um par de chaves EC.

**Example Exemplo: criar um par de chaves 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 Exemplo: criar um par de chaves EC com atributos opcionais**  

```
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 Exemplo: criar um par de chaves EC com valores de quórum**  
Ao gerar uma chave com controles de quórum, a chave deve estar associada a um número mínimo de usuários igual ao maior valor de quórum da chave. Os usuários associados incluem o proprietário da chave e os usuários de criptografia com quem essa chave é compartilhada. Para definir o número mínimo de usuários com quem compartilhar a chave, obtenha o maior valor de quórum entre o valor do quórum de uso da chave e o valor do quórum de gerenciamento de chaves e subtraia 1 para contabilizar o proprietário da chave, que, por padrão, está associado à chave. Para compartilhar a chave com mais usuários, use o comando **[Compartilhar uma chave usando a CloudHSM CLI](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"
      }
    }
  }
}
```

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

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<CURVE>***  
Especifica o identificador da curva elíptica.  
+ prime256v1
+ secp256r1
+ secp224r1
+ secp384r1
+ secp256k1
+ secp521r1
+ ed25519 (compatível somente em instâncias hsm2m.medium no modo não FIPS)
Obrigatório: Sim

***<PUBLIC\$1KEY\$1ATTRIBUTES>***  
Especifica uma lista separada por espaços dos principais atributos a serem definidos para a chave pública EC gerada na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (por exemplo, `verify=true`)  
Para obter uma lista dos atributos de chave compatíveis, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md).  
Obrigatório: não

***<PUBLIC\$1LABEL>***  
Especifica um rótulo definido pelo usuário para a chave pública. O tamanho máximo permitido para `label` é de 127 caracteres no Client SDK 5.11 e versões posteriores. O Client SDK 5.10 e versões anteriores têm um limite de 126 caracteres.  
Obrigatório: Sim

***<PRIVATE\$1KEY\$1ATTRIBUTES>***  
Especifica uma lista separada por espaços dos principais atributos a serem definidos para a chave privada EC gerada na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (por exemplo, `sign=true`)  
Para obter uma lista dos atributos de chave compatíveis, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md).  
Obrigatório: não

***<PRIVATE\$1LABEL>***  
Especifica o rótulo da chave privada definida pelo usuário. O tamanho máximo permitido para `label` é de 127 caracteres no Client SDK 5.11 e versões posteriores. O Client SDK 5.10 e versões anteriores têm um limite de 126 caracteres.  
Obrigatório: Sim

***<SESSION>***  
Cria uma chave que existe apenas na sessão atual. A chave não pode ser recuperada após o término da sessão.  
Use esse parâmetro quando precisar de uma chave apenas brevemente, como uma chave de encapsulamento que criptografa e, em seguida, descriptografa rapidamente outra chave. Não use uma chave de sessão para criptografar dados que você talvez precise descriptografar após o término da sessão.  
Por padrão, as chaves geradas são chaves persistentes (tokens). Passar <SESSION> muda isso, garantindo que uma chave gerada com esse argumento seja uma chave de sessão (efêmera).  
Obrigatório: não

***<SHARE\$1CRYPTO\$1USERS>***  
Especifica uma lista separada por espaços de nomes de usuário dos Usuários de criptografia com os quais compartilhar a chave privada EC  
Obrigatório: não

***<MANAGE\$1PRIVATE\$1KEY\$1QUORUM\$1VALUE>***  
O valor do quórum para as operações de gerenciamento da chave privada. Esse valor deve ser menor que ou igual ao número de usuários ao qual essa chave está associada. Isso inclui os usuários com quem a chave é compartilhada e o proprietário da chave. Valor máximo é 8.  
Obrigatório: não

***<USE\$1PRIVATE\$1KEY\$1QUORUM\$1VALUE>***  
O valor do quórum para as operações de uso da chave privada. Esse valor deve ser menor que ou igual ao número de usuários ao qual essa chave está associada. Isso inclui os usuários com quem a chave é compartilhada e o proprietário da chave. Valor máximo é 8.  
Obrigatório: não

## Tópicos relacionados
<a name="key-generate-asymmetric-pair-ec-seealso"></a>
+ [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)
+ [Filtrar chaves usando a CLI do CloudHSM](manage-keys-cloudhsm-cli-filtering.md)

# Gerar um par de chaves assimétricas RSA com a CloudHSM CLI
<a name="cloudhsm_cli-key-generate-asymmetric-pair-rsa"></a>

Use o **key generate-asymmetric-pair rsa** comando na CLI do CloudHSM para gerar um par de chaves RSA assimétrico em seu cluster. AWS CloudHSM 

## Tipo de usuário
<a name="key-generate-asymmetric-pair-rsa-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

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

Para executar esse comando, você deve estar registrado(a) como um CU.

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

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

Esses exemplos mostram como usar `key generate-asymmetric-pair rsa` para criar um par de chaves RSA.

**Example Exemplo: criar um par de chaves 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 Exemplo: criar um par de chaves RSA com atributos opcionais**  

```
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 Exemplo: criar um par de chaves RSA com valores de quórum**  
Ao gerar uma chave com controles de quórum, a chave deve estar associada a um número mínimo de usuários igual ao maior valor de quórum da chave. Os usuários associados incluem o proprietário da chave e os usuários de criptografia com quem essa chave é compartilhada. Para definir o número mínimo de usuários com quem compartilhar a chave, obtenha o maior valor de quórum entre o valor do quórum de uso da chave e o valor do quórum de gerenciamento de chaves e subtraia 1 para contabilizar o proprietário da chave, que, por padrão, está associado à chave. Para compartilhar a chave com mais usuários, use o comando **[Compartilhar uma chave usando a CloudHSM CLI](cloudhsm_cli-key-share.md)**.  

```
aws-cloudhsm > key generate-asymmetric-pair rsa \
--public-exponent 65537 \
--modulus-size-bits 2048 \
--public-label rsa-public-key-example \
--private-label rsa-private-key-example \
--public-attributes verify=true \
--private-attributes sign=true
--share-crypto-users 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
      }
    }
  }
}
```

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

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<MODULUS\$1SIZE\$1BITS>***  
 Especifica o comprimento do módulo em bits. O valor mínimo é 2048.   
Obrigatório: Sim

***<PRIVATE\$1KEY\$1ATTRIBUTES>***  
Especifica uma lista separada por espaços dos atributos de chave a serem definidos para a chave privada RSA gerada na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (por exemplo, `sign=true`)  
Para obter uma lista dos atributos de chave compatíveis, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md).  
Obrigatório: não

***<PRIVATE\$1LABEL>***  
 Especifica o rótulo da chave privada definida pelo usuário. O tamanho máximo permitido para `label` é de 127 caracteres no Client SDK 5.11 e versões posteriores. O Client SDK 5.10 e versões anteriores têm um limite de 126 caracteres.  
Obrigatório: Sim

***<PUBLIC\$1EXPONENT>***  
Especifica o expoente público. O valor deve ser um número ímpar maior que ou igual a 65537.  
Obrigatório: Sim

***<PUBLIC\$1KEY\$1ATTRIBUTES>***  
Especifica uma lista separada por espaços dos atributos de chave a serem definidos para a chave pública RSA gerada na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (por exemplo, `verify=true`)  
Para obter uma lista dos atributos de chave compatíveis, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md).  
Obrigatório: não

***<PUBLIC\$1LABEL>***  
 Especifica um rótulo definido pelo usuário para a chave pública. O tamanho máximo permitido para `label` é de 127 caracteres no Client SDK 5.11 e versões posteriores. O Client SDK 5.10 e versões anteriores têm um limite de 126 caracteres.  
Obrigatório: Sim

***<SESSION>***  
Cria uma chave que existe apenas na sessão atual. A chave não pode ser recuperada após o término da sessão.  
Use esse parâmetro quando precisar de uma chave apenas brevemente, como uma chave de encapsulamento que criptografa e, em seguida, descriptografa rapidamente outra chave. Não use uma chave de sessão para criptografar dados que você talvez precise descriptografar após o término da sessão.  
Por padrão, as chaves geradas são chaves persistentes (tokens). Passar <SESSION> muda isso, garantindo que uma chave gerada com esse argumento seja uma chave de sessão (efêmera).  
Obrigatório: não

***<SHARE\$1CRYPTO\$1USERS>***  
Especifica uma lista separada por espaços de nomes de usuário dos Usuários de criptografia com os quais compartilhar a chave privada RSA  
Obrigatório: não

***<MANAGE\$1PRIVATE\$1KEY\$1QUORUM\$1VALUE>***  
O valor do quórum para as operações de gerenciamento da chave privada. Esse valor deve ser menor que ou igual ao número de usuários ao qual essa chave está associada. Isso inclui os usuários com quem a chave é compartilhada e o proprietário da chave. Valor máximo é 8.  
Obrigatório: não

***<USE\$1PRIVATE\$1KEY\$1QUORUM\$1VALUE>***  
O valor do quórum para as operações de uso da chave privada. Esse valor deve ser menor que ou igual ao número de usuários ao qual essa chave está associada. Isso inclui os usuários com quem a chave é compartilhada e o proprietário da chave. Valor máximo é 8.  
Obrigatório: não

## Tópicos relacionados
<a name="key-generate-asymmetric-pair-rsa-seealso"></a>
+ [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)
+ [Filtrar chaves usando a CLI do CloudHSM](manage-keys-cloudhsm-cli-filtering.md)

# A categoria generate-symmetric na CLI do CloudHSM
<a name="cloudhsm_cli-key-generate-symmetric"></a>

Na CLI do CloudHSM, **key generate-symmetric** é uma categoria principal para um grupo de comandos que, quando combinados com a categoria principal, criam um comando que gera chaves simétricas. Atualmente, essa categoria consiste nos seguintes comandos:
+ [key generate-symmetric aes](cloudhsm_cli-key-generate-symmetric-aes.md)
+ [key generate-symmetric generic-secret](cloudhsm_cli-key-generate-symmetric-generic-secret.md)

# Gerar uma chave AES simétrica com a CloudHSM CLI
<a name="cloudhsm_cli-key-generate-symmetric-aes"></a>

Use o **key generate-symmetric aes** comando na CLI do CloudHSM para gerar uma chave AES simétrica no seu cluster. AWS CloudHSM 

## Tipo de usuário
<a name="key-generate-symmetric-aes-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

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

Para executar esse comando, você deve estar registrado(a) como um CU.

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

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

Esses exemplos mostram como usar o **key generate-symmetric aes** comando para criar uma chave AES.

**Example Exemplo: crie uma chave 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 Exemplo: crie uma chave AES com atributos opcionais**  

```
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 Exemplo: criar uma chave AES com valores de quórum**  
Ao gerar uma chave com controles de quórum, a chave deve estar associada a um número mínimo de usuários igual ao maior valor de quórum da chave. Os usuários associados incluem o proprietário da chave e os usuários de criptografia com quem essa chave é compartilhada. Para definir o número mínimo de usuários com quem compartilhar a chave, obtenha o maior valor de quórum entre o valor do quórum de uso da chave e o valor do quórum de gerenciamento de chaves e subtraia 1 para contabilizar o proprietário da chave, que, por padrão, está associado à chave. Para compartilhar a chave com mais usuários, use o comando **[Compartilhar uma chave usando a CloudHSM CLI](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
      }
    }
  }
}
```

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

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<KEY\$1ATTRIBUTES>***  
Especifica uma lista separada por espaços dos atributos de chave a serem definidos para a chave AES gerada na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (por exemplo, `sign=true`).  
Para obter uma lista dos atributos de chave compatíveis, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md).  
Obrigatório: não

***<KEY-LENGTH-BYTES>***  
Especifica o tamanho da chave em bytes.  

Valores válidos:
+ 16, 24 e 32
Obrigatório: Sim

***<LABEL>***  
Especifica o rótulo da chave privada definida pelo usuário para a chave AES. O tamanho máximo permitido para `label` é de 127 caracteres no Client SDK 5.11 e versões posteriores. O Client SDK 5.10 e versões anteriores têm um limite de 126 caracteres.  
Obrigatório: Sim

***<SESSION>***  
Cria uma chave que existe apenas na sessão atual. A chave não pode ser recuperada após o término da sessão.  
Use esse parâmetro quando precisar de uma chave apenas brevemente, como uma chave de encapsulamento que criptografa e, em seguida, descriptografa rapidamente outra chave. Não use uma chave de sessão para criptografar dados que você talvez precise descriptografar após o término da sessão.  
Por padrão, as chaves geradas são chaves persistentes (tokens). Passar <SESSION> muda isso, garantindo que uma chave gerada com esse argumento seja uma chave de sessão (efêmera).  
Obrigatório: não

***<SHARE\$1CRYPTO\$1USERS>***  
Especifica uma lista separada por espaços de nomes de usuário dos Usuários de criptografia com os quais compartilhar a chave AES  
Obrigatório: não

***<MANAGE\$1KEY\$1QUORUM\$1VALUE>***  
O valor do quórum para as operações de gerenciamento da chave. Esse valor deve ser menor que ou igual ao número de usuários ao qual essa chave está associada. Isso inclui os usuários com quem a chave é compartilhada e o proprietário da chave. Valor máximo é 8.  
Obrigatório: não

***<USE\$1KEY\$1QUORUM\$1VALUE>***  
O valor do quórum para as operações de uso da chave. Esse valor deve ser menor que ou igual ao número de usuários ao qual essa chave está associada. Isso inclui os usuários com quem a chave é compartilhada e o proprietário da chave. Valor máximo é 8.  
Obrigatório: não

## Tópicos relacionados
<a name="key-generate-symmetric-aes-seealso"></a>
+ [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)
+ [Filtrar chaves usando a CLI do CloudHSM](manage-keys-cloudhsm-cli-filtering.md)

# Gerar uma chave secreta genérica simétrica com a CloudHSM CLI
<a name="cloudhsm_cli-key-generate-symmetric-generic-secret"></a>

Use o **key generate-symmetric generic-secret** comando na CLI do CloudHSM para gerar uma chave secreta genérica simétrica em seu cluster. AWS CloudHSM 

## Tipo de usuário
<a name="key-generate-symmetric-generic-secret-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

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

Para executar esse comando, você deve estar registrado(a) como um CU.

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

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

Estes exemplos mostram como usar o comando **key generate-symmetric generic-secret** para criar uma chave secreta genérica.

**Example Exemplo: criar uma chave secreta genérica**  

```
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 Exemplo: criar uma chave secreta genérica com atributos opcionais**  

```
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 Exemplo: criar uma chave secreta genérica com valores de quórum**  
Ao gerar uma chave com controles de quórum, a chave deve estar associada a um número mínimo de usuários igual ao maior valor de quórum da chave. Os usuários associados incluem o proprietário da chave e os usuários de criptografia com quem essa chave é compartilhada. Para definir o número mínimo de usuários com quem compartilhar a chave, obtenha o maior valor de quórum entre o valor do quórum de uso da chave e o valor do quórum de gerenciamento de chaves e subtraia 1 para contabilizar o proprietário da chave, que, por padrão, está associado à chave. Para compartilhar a chave com mais usuários, use o comando **[Compartilhar uma chave usando a CloudHSM CLI](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
      }
    }
  }
}
```

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

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<KEY\$1ATTRIBUTES>***  
Especifica uma lista separada por espaços dos atributos de chave a serem definidos para a chave AES gerada na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (por exemplo, `sign=true`).  
Para obter uma lista dos atributos de chave compatíveis, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md).  
Obrigatório: não

***<KEY-LENGTH-BYTES>***  
Especifica o tamanho da chave em bytes.  

Valores válidos:
+ 1 a 800
Obrigatório: Sim

***<LABEL>***  
Especifica um rótulo definido pelo usuário para a chave secreta genérica. O tamanho máximo permitido para `label` é de 127 caracteres no Client SDK 5.11 e versões posteriores. O Client SDK 5.10 e versões anteriores têm um limite de 126 caracteres.  
Obrigatório: Sim

***<SESSION>***  
Cria uma chave que existe apenas na sessão atual. A chave não pode ser recuperada após o término da sessão.  
Use esse parâmetro quando precisar de uma chave apenas brevemente, como uma chave de encapsulamento que criptografa e, em seguida, descriptografa rapidamente outra chave. Não use uma chave de sessão para criptografar dados que você talvez precise descriptografar após o término da sessão.  
Por padrão, as chaves geradas são chaves persistentes (tokens). Passar <SESSION> muda isso, garantindo que uma chave gerada com esse argumento seja uma chave de sessão (efêmera).  
Obrigatório: não

***<SHARE\$1CRYPTO\$1USERS>***  
Lista separada por espaço de nomes de usuário dos Usuários de criptografia com os quais compartilhar a chave secreta genérica  
Obrigatório: não

***<MANAGE\$1KEY\$1QUORUM\$1VALUE>***  
O valor do quórum para as operações de gerenciamento da chave. Esse valor deve ser menor que ou igual ao número de usuários ao qual essa chave está associada. Isso inclui os usuários com quem a chave é compartilhada e o proprietário da chave. Valor máximo é 8.  
Obrigatório: não

***<USE\$1KEY\$1QUORUM\$1VALUE>***  
O valor do quórum para as operações de uso da chave. Esse valor deve ser menor que ou igual ao número de usuários ao qual essa chave está associada. Isso inclui os usuários com quem a chave é compartilhada e o proprietário da chave. Valor máximo é 8.  
Obrigatório: não

## Tópicos relacionados
<a name="key-generate-symmetric-generic-secret-seealso"></a>
+ [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)
+ [Filtrar chaves usando a CLI do CloudHSM](manage-keys-cloudhsm-cli-filtering.md)

# Importar uma chave no formato PEM com a CLI do CloudHSM
<a name="cloudhsm_cli-key-import-pem"></a>

Use o **key import pem** comando in AWS CloudHSM para importar uma chave de formato PEM para um módulo de segurança de hardware (HSM). Você pode usá-lo para importar chaves públicas que foram geradas fora do HSM.

**nota**  
Use o comando [Exportar uma chave assimétrica com a CloudHSM CLI](cloudhsm_cli-key-generate-file.md) para criar um arquivo PEM padrão a partir de uma chave pública ou para criar um arquivo PEM de referência a partir de uma chave privada.

## Tipo de usuário
<a name="cloudhsm_cli-key-import-pem-user-type"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-import-pem-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

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

Este exemplo mostra como usar o comando **key import pem** para importar uma chave pública RSA de um arquivo no formato PEM.

**Example Exemplo: importar uma chave pública 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 Exemplo: importar uma chave pública RSA com atributos opcionais**  

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

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

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<PATH>***  
Especifica o caminho em que o arquivo de chave está localizado.  
Obrigatório: Sim

***<LABEL>***  
Especifica o rótulo definido pelo usuário para a chave importada. O tamanho máximo para `label` é de 126 caracteres.  
Obrigatório: Sim

***<KEY\$1TYPE\$1CLASS>***  
Tipo e classe da chave encapsulada.  
Possíveis valores:  
+ ec-public
+ rsa-public
Obrigatório: Sim

***<IMPORT\$1KEY\$1ATTRIBUTES>***  
Especifica uma lista separada por espaços dos atributos de chave a serem definidos para a chave importada na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` (por exemplo, `sign=true`). Para obter uma lista dos atributos de chave compatíveis, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md).  
Obrigatório: não

## Tópicos relacionados
<a name="cloudhsm_cli-key-import-pem-seealso"></a>
+ [A categoria de assinatura criptográfica na CLI do CloudHSM](cloudhsm_cli-crypto-sign.md)
+ [A categoria de verificação de criptografia na CLI do CloudHSM](cloudhsm_cli-crypto-verify.md)

# Listar chaves para um usuário com a CloudHSM CLI
<a name="cloudhsm_cli-key-list"></a>

Use o **key list** comando na CLI do CloudHSM para encontrar todas as chaves do usuário atual presente em seu cluster. AWS CloudHSM A saída inclui chaves que o usuário possui e compartilha, bem como todas as chaves públicas no cluster CloudHSM.

## Tipo de usuário
<a name="chsm-cli-key-list-user-type"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Administradores () COs
+ Usuários de criptomoedas (CUs)

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

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

Os exemplos a seguir mostram as diferentes maneiras de executar o comando **key list**. Os exemplos a seguir mostram as saídas como um usuário de criptografia.

**Example Exemplo: descobrir todas as chaves – padrão**  
Esse comando lista as chaves do usuário conectado presente no AWS CloudHSM cluster.  
Por padrão, somente 10 chaves do usuário atualmente conectado são exibidas, e somente o `key-reference` e `label` são exibidos como saída. Use as opções de paginação apropriadas para exibir mais ou menos teclas como saída.

```
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 Exemplo: encontrar todas as chaves – detalhado**  
A saída inclui chaves que o usuário possui e compartilha, bem como todas as chaves públicas no HSMs.  
Observação: por padrão, somente 10 chaves do usuário atualmente conectado são exibidas. Use as opções de paginação apropriadas para exibir mais ou menos teclas como saída.

```
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 Exemplo: retorno paginado**  
O exemplo a seguir exibe um subconjunto paginado das chaves que mostra somente duas chaves. Em seguida, o exemplo fornece uma chamada subsequente para exibir as próximas duas teclas.  

```
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"
  }
}
```
Para exibir as próximas 2 teclas, uma chamada subsequente pode ser feita:  

```
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"
  }
}
```
Para ver mais exemplos que demonstram como o mecanismo de filtragem de chaves funciona na CloudHSM CLI, consulte [Filtrar chaves usando a CLI do CloudHSM](manage-keys-cloudhsm-cli-filtering.md).

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

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chaves na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar chaves correspondentes à lista.  
Para obter uma lista dos atributos de chave compatíveis com a CloudHSM CLI, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)  
Obrigatório: não

***<MAX\$1ITEMS>***  
O número total de itens para retornar na saída do comando. Se o número total de itens disponíveis for maior que o valor especificado, um NextToken é fornecido na saída do comando. Para retomar a paginação, forneça o valor do NextToken no argumento starting-token de um comando subsequente.  
Obrigatório: não

***<STARTING\$1TOKEN>***  
Um token para especificar onde iniciar a paginação. Esse é o NextToken de uma resposta truncada anteriormente.  
Obrigatório: não

***<VERBOSE>***  
Se incluído, imprime todos os atributos e as principais informações de cada chave correspondente. Por padrão, cada chave correspondente exibe apenas sua referência de chave e atributo de rótulo. Esse sinalizador, quando usado por administradores, não tem efeito.  
Obrigatório: não

## Tópicos relacionados
<a name="chsm-key-list-seealso"></a>
+ [Excluir uma chave com a CLI do CloudHSM](cloudhsm_cli-key-delete.md)
+ [Exportar uma chave assimétrica com a CloudHSM CLI](cloudhsm_cli-key-generate-file.md)
+ [Cancelar o compartilhamento de uma chave usando a CloudHSM CLI](cloudhsm_cli-key-unshare.md)
+ [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)
+ [Filtrar chaves usando a CLI do CloudHSM](manage-keys-cloudhsm-cli-filtering.md)

# Replicar uma chave com a CLI do CloudHSM
<a name="cloudhsm_cli-key-replicate"></a>

Use o **key replicate** comando na CLI do CloudHSM para replicar uma chave de um cluster de origem para um cluster de destino AWS CloudHSM . AWS CloudHSM 

## Tipo de usuário
<a name="chsm-cli-key-replicate-user-type"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Administradores () COs
+ Usuários de criptomoedas (CUs)
**nota**  
Os usuários criptográficos devem possuir a chave para usar esse comando.

## Requisitos
<a name="cloudhsm_cli-key-replicate-requirements"></a>
+ Os clusters de origem e destino devem ser clones. Isso significa que um foi criado a partir de um backup do outro, ou ambos foram criados a partir de um backup comum. Consulte [Criar clusters de backups](create-cluster-from-backup.md) para obter mais informações.
+ O proprietário da chave deve existir no cluster de destino. Além disso, se a chave for compartilhada com quaisquer usuários, esses usuários também deverão existir no cluster de destino.
+ Para executar esse comando, é necessário estar registrado como usuário de criptografia ou administrador nos clusters de origem e de destino.
  +  No modo de comando único, o comando usará as variáveis ambientais CLOUDHSM\$1PIN e CLOUDHSM\$1ROLE para se autenticar no cluster de origem. Consulte [Modo de comando único](cloudhsm_cli-modes.md#cloudhsm_cli-mode-single-command) para obter mais informações. Para fornecer credenciais ao cluster de destino, é preciso definir duas variáveis ambientais adicionais: DESTINATION\$1CLOUDHSM\$1PIN e DESTINATION\$1CLOUDHSM\$1ROLE:

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

    ```
    $ export DESTINATION_CLOUDHSM_PIN=<username:password>
    ```
  +  No modo interativo, os usuários precisarão fazer login explícito nos clusters de origem e de destino.

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

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

**Example Exemplo: replicar chave**  
Esse comando replica uma chave de um cluster de origem para um cluster de destino clonado. O exemplo abaixo demonstra a saída quando conectado como usuário criptográfico em ambos os clusters.  

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

## Argumentos
<a name="key-replicate-arguments"></a>

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave correspondente no cluster de origem.  
Para obter uma lista dos atributos de chave compatíveis com a CloudHSM CLI, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)  
Obrigatório: Sim

***<SOURCE\$1CLUSTER\$1ID>***  
O ID do cluster de origem.  
Obrigatório: Sim

***<DESTINATION\$1CLUSTER\$1ID>***  
O ID do cluster de destino.  
Obrigatório: Sim

## Tópicos relacionados
<a name="chsm-key-replicate-seealso"></a>
+ [Conectar-se a vários clusters com a CLI do CloudHSM](cloudhsm_cli-configs-multi-cluster.md)

# Definir os atributos das chaves com a CloudHSM CLI
<a name="cloudhsm_cli-key-set-attribute"></a>

Use o **key set-attribute** comando na CLI do CloudHSM para definir os atributos das chaves no seu cluster. AWS CloudHSM Somente o CU que criou a chave e, consequentemente, a possui pode alterar os atributos da chave.

Para obter uma lista dos principais atributos que podem ser usados na CloudHSM CLI, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md).

## Tipo de usuário
<a name="chsm-cli-key-set-attribute-user-type"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários criptográficos (CUs) podem executar esse comando.
+ Os administradores podem definir o atributo confiável.

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

Para executar esse comando, você deve estar registrado como um CU. Para definir o atributo confiável, você deve estar logado como um usuário administrador.

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

## Exemplo: configuração de um atributo de chave
<a name="chsm-cli-key-set-attribute-examples"></a>

O exemplo a seguir mostra como usar o comando **key set-attribute** para definir o rótulo.

**Example**  

1. Use a chave com o rótulo `my_key`, conforme mostrado aqui:

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

1. Use o comando **key list** para confirmar que o atributo `encrypt` foi alterado:

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

## Argumentos
<a name="chsm-cli-key-set-attribute-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<KEY\$1ATTRIBUTE>***  
Especifica o nome do atributo de chave.  
Obrigatório: Sim

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave correspondente para exclusão.  
Para obter uma lista dos atributos de chave compatíveis com a CloudHSM CLI, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)  
Obrigatório: não

***<KEY\$1ATTRIBUTE\$1VALUE>***  
A chave especifica o nome do atributo.  
Obrigatório: Sim

***<KEY\$1REFERENCE>***  
Uma representação hexadecimal ou decimal da chave. (como uma alça de chave).  
Obrigatório: não

***<APPROVAL>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave for maior do que 1.

## Tópicos relacionados
<a name="chsm-cli-key-set-attribute-see-also"></a>
+ [Filtrar chaves usando a CLI do CloudHSM](manage-keys-cloudhsm-cli-filtering.md)
+ [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)

# Compartilhar uma chave usando a CloudHSM CLI
<a name="cloudhsm_cli-key-share"></a>

Use o **key share** comando na CLI do CloudHSM para compartilhar uma chave CUs com outras pessoas em seu cluster. AWS CloudHSM 

Somente a UC que criou a chave e, consequentemente, a possui pode cancelar o compartilhamento da chave. Os usuários com quem a chave é compartilhada podem usá-la em operações criptográficas, mas não podem excluí-la, exportá-la, compartilhá-la nem descompartilhá-la. Além disso, esses usuários não podem alterar [os principais atributos](cloudhsm_cli-key-attributes.md).

## Tipo de usuário
<a name="chsm-cli-key-share-user-type"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

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

Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplo: compartilhar uma chave com outro CU
<a name="chsm-cli-key-share-examples"></a>

O exemplo a seguir mostra como usar o comando **key share** para compartilhar uma chave com a CU `alice`.

**Example**  

1. Execute o comando **key share** com o qual compartilhar a chave `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. Execute o 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. Na lista acima, verifique se `alice` está na lista de `shared-users`

## Argumentos
<a name="chsm-cli-key-share-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave correspondente para exclusão.  
Para obter uma lista dos atributos de chave compatíveis, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md).  
Obrigatório: Sim

***<USERNAME>***  
Especifica um nome amigável para o usuário. O tamanho máximo é de 31 caracteres. O único caractere especial permitido é um sublinhado ( \$1 ). O nome de usuário não diferencia maiúsculas de minúsculas neste comando. O nome de usuário é sempre exibido em minúsculas.  
Obrigatório: Sim

***<ROLE>***  
Especifica a função atribuída a esse usuário. Esse parâmetro é obrigatório. Para obter a função do usuário, use o comando lista de usuário. Para obter informações detalhadas sobre os tipos de usuários em um HSM, consulte [Tipos de usuários do HSM para a CLI do CloudHSM](understanding-users.md).  
Obrigatório: Sim

***<APPROVAL>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave for maior do que 1.

## Tópicos relacionados
<a name="chsm-cli-key-share-see-also"></a>
+ [Filtrar chaves usando a CLI do CloudHSM](manage-keys-cloudhsm-cli-filtering.md)
+ [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)

# Cancelar o compartilhamento de uma chave usando a CloudHSM CLI
<a name="cloudhsm_cli-key-unshare"></a>

Use o **key unshare** comando na CLI do CloudHSM para cancelar o compartilhamento de uma chave com outras pessoas em seu cluster. CUs AWS CloudHSM 

Somente o CU que criou a chave e, consequentemente, a possui pode cancelar o compartilhamento da chave. Os usuários com quem a chave é compartilhada podem usá-la em operações criptográficas, mas não podem excluí-la, exportá-la, compartilhá-la nem descompartilhá-la. Além disso, esses usuários não podem alterar [os principais atributos](cloudhsm_cli-key-attributes.md).

## Tipo de usuário
<a name="chsm-cli-key-unshare-user-type"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

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

Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplo: cancelar o compartilhamento de uma chave com outro CU
<a name="chsm-cli-key-share-examples"></a>

O exemplo a seguir mostra como usar o comando **key unshare** para descompartilhar uma chave com a CU `alice`.

**Example**  

1. Execute o comando **key list** e filtre pela chave específica com a qual você deseja cancelar o compartilhamento com `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. Confirme que `alice` está na saída `shared-users` e execute o comando **key unshare** a seguir para cancelar o compartilhamento da chave com `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. Execute o comando `key list` novamente para confirmar que a chave não foi compartilhada com `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"
               },
             ],
             "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
     }
   }
   ```

## Argumentos
<a name="chsm-cli-key-unshare-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave correspondente para exclusão.  
Para obter uma lista dos atributos de chave compatíveis, consulte [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md).  
Obrigatório: Sim

***<USERNAME>***  
Especifica um nome amigável para o usuário. O tamanho máximo é de 31 caracteres. O único caractere especial permitido é um sublinhado ( \$1 ). O nome de usuário não diferencia maiúsculas de minúsculas neste comando. O nome de usuário é sempre exibido em minúsculas.  
Obrigatório: Sim

***<ROLE>***  
Especifica a função atribuída a esse usuário. Esse parâmetro é obrigatório. Para obter a função do usuário, use o comando lista de usuário. Para obter informações detalhadas sobre os tipos de usuários em um HSM, consulte [Tipos de usuários do HSM para a CLI do CloudHSM](understanding-users.md).  
Obrigatório: Sim

***<APPROVAL>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave for maior do que 1.

## Tópicos relacionados
<a name="chsm-cli-key-unshare-see-also"></a>
+ [Filtrar chaves usando a CLI do CloudHSM](manage-keys-cloudhsm-cli-filtering.md)
+ [Atributos de chave da CloudHSM CLI](cloudhsm_cli-key-attributes.md)

# O comando key unwrap na CLI do CloudHSM
<a name="cloudhsm_cli-key-unwrap"></a>

O comando principal **key unwrap** na CLI do CloudHSM importa uma chave privada simétrica ou assimétrica criptografada (encapsulada) de um arquivo para o Hardware Security Module (HSM – Módulo de segurança de hardware). Esse comando é projetado para importar chaves criptografadas que foram encapsuladas pelo comando [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md), mas também pode ser usado para desencapsular chaves que foram encapsuladas com outras ferramentas. No entanto, nessas situações, recomendamos usar as bibliotecas de software PKCS\$111 ou JCE para desencapsular a chave.
+ [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)

# Desencapsular uma chave com o AES-GCM usando a CloudHSM CLI
<a name="cloudhsm_cli-key-unwrap-aes-gcm"></a>

Use o comando **key unwrap aes-gcm** na CloudHSM CLI para desencapsular uma chave de carga útil no cluster usando a chave de encapsulamento AES e o mecanismo de desencapsulamento `AES-GCM`.

As chaves desembrulhadas podem ser usadas da mesma forma que as chaves geradas pelo AWS CloudHSM. Para indicar que elas não foram geradas localmente, o atributo `local` é definido como `false`.

Para usar o **key unwrap aes-gcm** comando, você deve ter a chave de encapsulamento AES em seu AWS CloudHSM cluster e seu `unwrap` atributo deve estar definido como. `true`

## Tipo de usuário
<a name="cloudhsm_cli-key-unwrap-aes-gcm-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-unwrap-aes-gcm-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

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

Esses exemplos mostram como usar o comando **key unwrap aes-gcm** usando uma chave AES com o valor do atributo `unwrap` definido como `true`.

**Example Exemplo: desencapsular uma chave de carga útil dos dados da chave encapsulada codificada em 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 Exemplo: desencapsular uma chave de carga útil fornecida por meio de um caminho de dados**  

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

## Argumentos
<a name="cloudhsm_cli-key-unwrap-aes-gcm-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços contendo atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave para ser usada no desencapsulamento.  
Obrigatório: Sim

***<DATA\$1PATH>***  
Caminho para o arquivo binário que contém os dados da chave encapsulada.  
Obrigatório: sim (a menos que seja fornecido por meio de dados codificados em Base64)

***<DATA>***  
Dados de chaves encapsuladas codificados em Base64.  
Obrigatório: sim (a menos que seja fornecido por meio do caminho de dados)

***<ATTRIBUTES>***  
Lista separada por espaço contendo atributos de chaves na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para a chave encapsulada.  
Obrigatório: não

***<AAD>***  
Valor de dados autenticados adicionais (AAD) do Aes GCM, em hexadecimal.  
Obrigatório: não

***<TAG\$1LENGTH\$1BITS>***  
Comprimento de tag do Aes GCM em bits.  
Obrigatório: Sim

***<KEY\$1TYPE\$1CLASS>***  
Tipo de chave e classe da chave encapsulada [valores possíveis: `aes`, `des3`, `ec-private`, `generic-secret`, `rsa-private`].  
Obrigatório: Sim

***<LABEL>***  
Rótulo da chave desencapsulada.  
Obrigatório: Sim

***<SESSION>***  
Cria uma chave de sessão que existe apenas na sessão atual. A chave não pode ser recuperada após o término da sessão.  
Obrigatório: não

***<IV>***  
Valor inicial usado para encapsular a chave, em hexadecimal.  
Obrigatório: não

***<APPROVAL>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de desempacotamento for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-unwrap-aes-gcm-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Desembrulhe uma chave AES-NO-PAD usando a CLI do CloudHSM
<a name="cloudhsm_cli-key-unwrap-aes-no-pad"></a>

Use o **key unwrap aes-no-pad** comando na CLI do CloudHSM para desempacotar uma chave de carga no cluster usando a chave de empacotamento AES e o AWS CloudHSM mecanismo de desempacotamento. `AES-NO-PAD`

As chaves desembrulhadas podem ser usadas da mesma forma que as chaves geradas pelo AWS CloudHSM. Para indicar que elas não foram geradas localmente, o atributo `local` é definido como `false`.

Para usar o **key unwrap aes-no-pad** comando, você deve ter a chave de encapsulamento AES em seu AWS CloudHSM cluster e seu `unwrap` atributo deve estar definido como. `true`

## Tipo de usuário
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

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

Esses exemplos mostram como usar o comando **key unwrap aes-no-pad** usando uma chave AES com o valor do atributo `unwrap` definido como `true`.

**Example Exemplo: desencapsular uma chave de carga útil dos dados da chave encapsulada codificada em 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 Exemplo: desencapsular uma chave de carga útil fornecida por meio de um caminho de dados**  

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

## Argumentos
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços contendo atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave para ser usada no desencapsulamento.  
Obrigatório: Sim

***<DATA\$1PATH>***  
Caminho para o arquivo binário que contém os dados da chave encapsulada.  
Obrigatório: sim (a menos que seja fornecido por meio de dados codificados em Base64)

***<DATA>***  
Dados de chaves encapsuladas codificados em Base64.  
Obrigatório: sim (a menos que seja fornecido por meio do caminho de dados)

***<ATTRIBUTES>***  
Lista separada por espaço contendo atributos de chaves na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para a chave encapsulada.  
Obrigatório: não

***<KEY\$1TYPE\$1CLASS>***  
Tipo de chave e classe da chave encapsulada [valores possíveis: `aes`, `des3`, `ec-private`, `generic-secret`, `rsa-private`].  
Obrigatório: Sim

***<LABEL>***  
Rótulo da chave desencapsulada.  
Obrigatório: Sim

***<SESSION>***  
Cria uma chave de sessão que existe apenas na sessão atual. A chave não pode ser recuperada após o término da sessão.  
Obrigatório: não

***<APPROVAL>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de desempacotamento for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-unwrap-aes-no-pad-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Desempacote uma chave com o AES- PKCS5 -PAD usando a CLI do CloudHSM
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad"></a>

Use o comando **key unwrap aes-pkcs5-pad** na CloudHSM CLI para desencapsular uma chave de carga útil usando a chave de encapsulamento AES e o mecanismo de desencapsulamento `AES-PKCS5-PAD`.

As chaves desembrulhadas podem ser usadas da mesma forma que as chaves geradas pelo AWS CloudHSM. Para indicar que elas não foram geradas localmente, o atributo `local` é definido como `false`.

Para usar o **key unwrap aes-pkcs5-pad** comando, você deve ter a chave de encapsulamento AES em seu AWS CloudHSM cluster e seu `unwrap` atributo deve estar definido como. `true`

## Tipo de usuário
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

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

Esses exemplos mostram como usar o comando **key unwrap aes-pkcs5-pad** usando uma chave AES com o valor do atributo `unwrap` definido como `true`.

**Example Exemplo: desencapsular uma chave de carga útil dos dados da chave encapsulada codificada em 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 Exemplo: desencapsular uma chave de carga útil fornecida por meio de um caminho de dados**  

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

## Argumentos
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços contendo atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave para ser usada no desencapsulamento.  
Obrigatório: Sim

***<DATA\$1PATH>***  
Caminho para o arquivo binário que contém os dados da chave encapsulada.  
Obrigatório: sim (a menos que seja fornecido por meio de dados codificados em Base64)

***<DATA>***  
Dados de chaves encapsuladas codificados em Base64.  
Obrigatório: sim (a menos que seja fornecido por meio do caminho de dados)

***<ATTRIBUTES>***  
Lista separada por espaço contendo atributos de chaves na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para a chave encapsulada.  
Obrigatório: não

***<KEY\$1TYPE\$1CLASS>***  
Tipo de chave e classe da chave encapsulada [valores possíveis: `aes`, `des3`, `ec-private`, `generic-secret`, `rsa-private`].  
Obrigatório: Sim

***<LABEL>***  
Rótulo da chave desencapsulada.  
Obrigatório: Sim

***<SESSION>***  
Cria uma chave de sessão que existe apenas na sessão atual. A chave não pode ser recuperada após o término da sessão.  
Obrigatório: não

***<APPROVAL>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de desempacotamento for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-unwrap-aes-pkcs5-pad-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Desembrulhe uma chave AES-ZERO-PAD usando a CLI do CloudHSM
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad"></a>

Use o **key unwrap aes-zero-pad** comando na CLI do CloudHSM para desempacotar uma chave de carga no cluster usando a chave de empacotamento AES e o AWS CloudHSM mecanismo de desempacotamento. `AES-ZERO-PAD`

As chaves desembrulhadas podem ser usadas da mesma forma que as chaves geradas pelo AWS CloudHSM. Para indicar que elas não foram geradas localmente, o atributo `local` é definido como `false`.

Para usar o **key unwrap aes-no-pad** comando, você deve ter a chave de encapsulamento AES em seu AWS CloudHSM cluster e seu `unwrap` atributo deve estar definido como. `true`

## Tipo de usuário
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

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

Esses exemplos mostram como usar o comando **key unwrap aes-zero-pad** usando uma chave AES com o valor do atributo `unwrap` definido como `true`.

**Example Exemplo: desencapsular uma chave de carga útil dos dados da chave encapsulada codificada em 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 Exemplo: desencapsular uma chave de carga útil fornecida por meio de um caminho de dados**  

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

## Argumentos
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços contendo atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave para ser usada no desencapsulamento.  
Obrigatório: Sim

***<DATA\$1PATH>***  
Caminho para o arquivo binário que contém os dados da chave encapsulada.  
Obrigatório: sim (a menos que seja fornecido por meio de dados codificados em Base64)

***<DATA>***  
Dados de chaves encapsuladas codificados em Base64.  
Obrigatório: sim (a menos que seja fornecido por meio do caminho de dados)

***<ATTRIBUTES>***  
Lista separada por espaço contendo atributos de chaves na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para a chave encapsulada.  
Obrigatório: não

***<KEY\$1TYPE\$1CLASS>***  
Tipo de chave e classe da chave encapsulada [valores possíveis: `aes`, `des3`, `ec-private`, `generic-secret`, `rsa-private`].  
Obrigatório: Sim

***<LABEL>***  
Rótulo da chave desencapsulada.  
Obrigatório: Sim

***<SESSION>***  
Cria uma chave de sessão que existe apenas na sessão atual. A chave não pode ser recuperada após o término da sessão.  
Obrigatório: não

***<APPROVAL>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de desempacotamento for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-unwrap-aes-zero-pad-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Desembrulhe uma chave CLOUDHSM-AES-GCM usando a CLI do CloudHSM
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm"></a>

Use o **key unwrap cloudhsm-aes-gcm** comando na CLI do CloudHSM para desempacotar uma chave de carga no cluster usando a chave de empacotamento AES e o AWS CloudHSM mecanismo de desempacotamento. `CLOUDHSM-AES-GCM`

As chaves desembrulhadas podem ser usadas da mesma forma que as chaves geradas pelo AWS CloudHSM. Para indicar que elas não foram geradas localmente, o atributo `local` é definido como `false`.

Para usar o **key unwrap cloudhsm-aes-gcm** comando, você deve ter a chave de encapsulamento AES em seu AWS CloudHSM cluster e seu `unwrap` atributo deve estar definido como. `true`

## Tipo de usuário
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

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

Esses exemplos mostram como usar o comando **key unwrap cloudhsm-aes-gcm** usando uma chave AES com o valor do atributo `unwrap` definido como `true`.

**Example Exemplo: desencapsular uma chave de carga útil dos dados da chave encapsulada codificada em 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 Exemplo: desencapsular uma chave de carga útil fornecida por meio de um caminho de dados**  

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

## Argumentos
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços contendo atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave para ser usada no desencapsulamento.  
Obrigatório: Sim

***<DATA\$1PATH>***  
Caminho para o arquivo binário que contém os dados da chave encapsulada.  
Obrigatório: sim (a menos que seja fornecido por meio de dados codificados em Base64)

***<DATA>***  
Dados de chaves encapsuladas codificados em Base64.  
Obrigatório: sim (a menos que seja fornecido por meio do caminho de dados)

***<ATTRIBUTES>***  
Lista separada por espaço contendo atributos de chaves na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para a chave encapsulada.  
Obrigatório: não

***<AAD>***  
Valor de dados autenticados adicionais (AAD) do Aes GCM, em hexadecimal.  
Obrigatório: não

***<TAG\$1LENGTH\$1BITS>***  
Comprimento de tag do Aes GCM em bits.  
Obrigatório: Sim

***<KEY\$1TYPE\$1CLASS>***  
Tipo de chave e classe da chave encapsulada [valores possíveis: `aes`, `des3`, `ec-private`, `generic-secret`, `rsa-private`].  
Obrigatório: Sim

***<LABEL>***  
Rótulo da chave desencapsulada.  
Obrigatório: Sim

***<SESSION>***  
Cria uma chave de sessão que existe apenas na sessão atual. A chave não pode ser recuperada após o término da sessão.  
Obrigatório: não

***<APPROVAL>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de desempacotamento for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-unwrap-cloudhsm-aes-gcm-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Desencapsular uma chave com o RSA-AES usando a CloudHSM CLI
<a name="cloudhsm_cli-key-unwrap-rsa-aes"></a>

Use o comando **key unwrap rsa-aes** na CloudHSM CLI para desencapsular uma chave de carga útil usando uma chave privada RSA e o mecanismo de desencapsulamento `RSA-AES`.

As chaves desembrulhadas podem ser usadas da mesma forma que as chaves geradas pelo AWS CloudHSM. Para indicar que elas não foram geradas localmente, o atributo `local` é definido como `false`.

Para usar o**key unwrap rsa-aes**, você deve ter a chave privada RSA da chave de empacotamento pública RSA em seu AWS CloudHSM cluster e seu `unwrap` atributo deve estar definido como. `true` 

**nota**  
Esse comando está disponível somente com o CloudHSM CLI 5.11\$1.

## Tipo de usuário
<a name="cloudhsm_cli-key-unwrap-rsa-aes-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-unwrap-rsa-aes-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplo
<a name="cloudhsm_cli-key-unwrap-rsa-aes-examples"></a>

Esses exemplos mostram como usar o comando **key unwrap rsa-aes** usando a chave privada RSA com o valor do atributo `unwrap` definido como `true`.

**Example Exemplo: desencapsular uma chave de carga útil dos dados da chave encapsulada codificada em 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 Exemplo: desencapsular uma chave de carga útil fornecida por meio de um caminho de dados**  

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

## Argumentos
<a name="cloudhsm_cli-key-unwrap-rsa-aes-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços contendo atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave para ser usada no desencapsulamento.  
Obrigatório: Sim

***<DATA\$1PATH>***  
Caminho para o arquivo binário que contém os dados da chave encapsulada.  
Obrigatório: sim (a menos que seja fornecido por meio de dados codificados em Base64)

***<DATA>***  
Dados de chaves encapsuladas codificados em Base64.  
Obrigatório: sim (a menos que seja fornecido por meio do caminho de dados)

***<ATTRIBUTES>***  
Lista separada por espaço contendo atributos de chaves na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para a chave encapsulada.  
Obrigatório: não

***<KEY\$1TYPE\$1CLASS>***  
Tipo de chave e classe da chave encapsulada [valores possíveis: `aes`, `des3`, `ec-private`, `generic-secret`, `rsa-private`].  
Obrigatório: Sim

***<HASH\$1FUNCTION>***  
Especifica a função hash.  
Valores válidos:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Obrigatório: Sim

***<MGF>***  
Especifica a função de geração da máscara.   
A função hash da função de geração de máscara deve corresponder à função hash do mecanismo de assinatura.
Valores válidos:  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Obrigatório: Sim

***<LABEL>***  
Rótulo da chave desencapsulada.  
Obrigatório: Sim

***<SESSION>***  
Cria uma chave de sessão que existe apenas na sessão atual. A chave não pode ser recuperada após o término da sessão.  
Obrigatório: não

***<APPROVAL>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de desempacotamento for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-unwrap-rsa-aes-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Desencapsular uma chave com o RSA-OAEP usando a CloudHSM CLI
<a name="cloudhsm_cli-key-unwrap-rsa-oaep"></a>

Use o comando **key unwrap rsa-oaep** na CloudHSM CLI para desencapsular uma chave de carga útil usando a chave privada RSA e o mecanismo de desencapsulamento `RSA-OAEP`.

As chaves desembrulhadas podem ser usadas da mesma forma que as chaves geradas pelo AWS CloudHSM. Para indicar que elas não foram geradas localmente, o atributo `local` é definido como `false`.

Para usar o **key unwrap rsa-oaep** comando, você deve ter a chave privada RSA da chave de empacotamento pública RSA em seu AWS CloudHSM cluster e seu `unwrap` atributo deve estar definido como. `true`

## Tipo de usuário
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplos
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-examples"></a>

Esses exemplos mostram como usar o comando **key unwrap rsa-oaep** usando a chave privada RSA com o valor do atributo `unwrap` definido como `true`.

**Example Exemplo: desencapsular uma chave de carga útil dos dados da chave encapsulada codificada em 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 Exemplo: desencapsular uma chave de carga útil fornecida por meio de um caminho de dados**  

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

## Argumentos
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços contendo atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave para ser usada no desencapsulamento.  
Obrigatório: Sim

***<DATA\$1PATH>***  
Caminho para o arquivo binário que contém os dados da chave encapsulada.  
Obrigatório: sim (a menos que seja fornecido por meio de dados codificados em Base64)

***<DATA>***  
Dados de chaves encapsuladas codificados em Base64.  
Obrigatório: sim (a menos que seja fornecido por meio do caminho de dados)

***<ATTRIBUTES>***  
Lista separada por espaço contendo atributos de chaves na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para a chave encapsulada.  
Obrigatório: não

***<KEY\$1TYPE\$1CLASS>***  
Tipo de chave e classe da chave encapsulada [valores possíveis: `aes`, `des3`, `ec-private`, `generic-secret`, `rsa-private`].  
Obrigatório: Sim

***<HASH\$1FUNCTION>***  
Especifica a função hash.  
Valores válidos:  
+ sha1
+ sha224
+ sha256
+ sha384
+ sha512
Obrigatório: Sim

***<MGF>***  
Especifica a função de geração da máscara.   
A função hash da função de geração de máscara deve corresponder à função hash do mecanismo de assinatura.
Valores válidos:  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Obrigatório: Sim

***<LABEL>***  
Rótulo da chave desencapsulada.  
Obrigatório: Sim

***<SESSION>***  
Cria uma chave de sessão que existe apenas na sessão atual. A chave não pode ser recuperada após o término da sessão.  
Obrigatório: não

***<APPROVAL>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de desempacotamento for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-unwrap-rsa-oaep-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Desencapsular uma chave com o RSA-PKCS usando a CloudHSM CLI
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs"></a>

Use o comando **key unwrap rsa-pkcs** na CloudHSM CLI para desencapsular uma chave de carga útil usando a chave privada RSA e o mecanismo de desencapsulamento `RSA-PKCS`.

As chaves desembrulhadas podem ser usadas da mesma forma que as chaves geradas pelo AWS CloudHSM. Para indicar que elas não foram geradas localmente, o atributo `local` é definido como `false`.

Para usar o **unwrap rsa-pkcs** comando key, você deve ter a chave privada RSA da chave de empacotamento pública RSA em seu AWS CloudHSM cluster e seu `unwrap` atributo deve estar definido como. `true`

## Tipo de usuário
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplos
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-examples"></a>

Esses exemplos mostram como usar o comando **key unwrap rsa-oaep** usando uma chave AES com o valor do atributo `unwrap` definido como `true`.

**Example Exemplo: desencapsular uma chave de carga útil dos dados da chave encapsulada codificada em 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 Exemplo: desencapsular uma chave de carga útil fornecida por meio de um caminho de dados**  

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

## Argumentos
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços contendo atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para selecionar uma chave para ser usada no desencapsulamento.  
Obrigatório: Sim

***<DATA\$1PATH>***  
Caminho para o arquivo binário que contém os dados da chave encapsulada.  
Obrigatório: sim (a menos que seja fornecido por meio de dados codificados em Base64)

***<DATA>***  
Dados de chaves encapsuladas codificados em Base64.  
Obrigatório: sim (a menos que seja fornecido por meio do caminho de dados)

***<ATTRIBUTES>***  
Lista separada por espaço contendo atributos de chaves na forma de `KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` para a chave encapsulada.  
Obrigatório: não

***<KEY\$1TYPE\$1CLASS>***  
Tipo de chave e classe da chave encapsulada [valores possíveis: `aes`, `des3`, `ec-private`, `generic-secret`, `rsa-private`].  
Obrigatório: Sim

***<LABEL>***  
Rótulo da chave desencapsulada.  
Obrigatório: Sim

***<SESSION>***  
Cria uma chave de sessão que existe apenas na sessão atual. A chave não pode ser recuperada após o término da sessão.  
Obrigatório: não

***<APPROVAL>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de desempacotamento for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-unwrap-rsa-pkcs-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# O comando key wrap na CLI do CloudHSM
<a name="cloudhsm_cli-key-wrap"></a>

O comando **key wrap** na CLI do CloudHSM exporta uma cópia criptografada de uma chave privada simétrica ou assimétrica do módulo de segurança de hardware (HSM) para um arquivo. Ao executar o comando **key wrap**, você especifica duas coisas: a chave a ser exportada e o arquivo de saída. A chave a ser exportada é uma chave no HSM que criptografará (encapsulará) a chave que você deseja exportar.

O comando **key wrap** não remove a chave do HSM nem impede que você use a chave em operações criptográficas. É possível exportar a mesma chave várias vezes. Para importar a chave criptografada novamente no HSM, use [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md). Somente o proprietário de uma chave, ou seja, o usuário de criptografia que a criou, pode encapsulá-la. Os usuários com quem essa chave é compartilhada podem usá-la somente em operações criptográficas.

O comando **key wrap** oferece consiste nos seguintes subcomandos:
+ [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)

# Encapsular uma chave com o AES-GCM usando a CloudHSM CLI
<a name="cloudhsm_cli-key-wrap-aes-gcm"></a>

Use o comando **key wrap aes-gcm** na CloudHSM CLI para encapsular uma chave de carga útil usando uma chave AES no módulo de segurança de hardware (HSM) e no mecanismo de encapsulamento `AES-GCM`. O atributo `extractable` da chave de carga útil deve ser definido como `true`.

Somente o proprietário de uma chave, ou seja, o usuário de criptografia que a criou, pode encapsulá-la. Os usuários que compartilham a chave podem usá-la em operações criptográficas.

Para usar o **key wrap aes-gcm** comando, primeiro você deve ter uma chave AES em seu AWS CloudHSM cluster. Você pode gerar uma chave AES para encapsular com o comando [Gerar uma chave AES simétrica com a CloudHSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) e o atributo `wrap` definido como `true`.

## Tipo de usuário
<a name="cloudhsm_cli-key-wrap-aes-gcm-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-wrap-aes-gcm-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplo
<a name="cloudhsm_cli-key-wrap-aes-gcm-examples"></a>

Este exemplo mostra como usar o comando **key wrap aes-gcm** usando uma chave 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"
  }
}
```

## Argumentos
<a name="cloudhsm_cli-key-wrap-aes-gcm-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de carga útil.  
Obrigatório: Sim

***<PATH>***  
Caminho para o arquivo binário em que os dados da chave encapsulada serão salvos.  
Obrigatório: não

***<WRAPPING\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de encapsulamento.   
Obrigatório: Sim

***<AAD>***  
Valor de dados autenticados adicionais (AAD) do AES GCM, em hexadecimal.   
Obrigatório: não

***<TAG\$1LENGTH\$1BITS>***  
Comprimento do rótulo AES GCM em bits.  
Obrigatório: Sim

***<WRAPPING\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de encapsulamento. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de encapsulamento for maior do que 1.

***<PAYLOAD\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de carga útil. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de carga útil for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-wrap-aes-gcm-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Envolva uma chave AES-NO-PAD usando a CLI do CloudHSM
<a name="cloudhsm_cli-key-wrap-aes-no-pad"></a>

Use o comando **key wrap aes-no-pad** na CloudHSM CLI para encapsular uma chave de carga útil usando uma chave AES no módulo de segurança de hardware (HSM) e no mecanismo de encapsulamento `AES-NO-PAD`. O atributo `extractable` da chave de carga útil deve ser definido como `true`.

Somente o proprietário de uma chave, ou seja, o usuário de criptografia que a criou, pode encapsulá-la. Os usuários que compartilham a chave podem usá-la em operações criptográficas.

Para usar o **key wrap aes-no-pad** comando, primeiro você deve ter uma chave AES em seu AWS CloudHSM cluster. Você pode gerar uma chave AES para encapsular usando o comando [Gerar uma chave AES simétrica com a CloudHSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) e o atributo `wrap` definido como `true`.

## Tipo de usuário
<a name="cloudhsm_cli-key-wrap-aes-no-pad-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-wrap-aes-no-pad-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplo
<a name="cloudhsm_cli-key-wrap-aes-no-pad-examples"></a>

Este exemplo mostra como usar o comando **key wrap aes-no-pad** usando uma chave AES com o valor do atributo `wrap` definido como `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"
  }
}
```

## Argumentos
<a name="cloudhsm_cli-key-wrap-aes-no-pad-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de carga útil.  
Obrigatório: Sim

***<PATH>***  
Caminho para o arquivo binário em que os dados da chave encapsulada serão salvos.  
Obrigatório: não

***<WRAPPING\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de encapsulamento.   
Obrigatório: Sim

***<WRAPPING\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de encapsulamento. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de encapsulamento for maior do que 1.

***<PAYLOAD\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de carga útil. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de carga útil for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-wrap-aes-no-pad-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Encapsular uma chave com AES- PKCS5 -PAD usando o CloudHSM CLI
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad"></a>

Use o comando **key wrap aes-pkcs5-pad** na CloudHSM CLI para encapsular uma chave de carga útil usando uma chave AES no módulo de segurança de hardware (HSM) e no mecanismo de encapsulamento `AES-PKCS5-PAD`. O atributo `extractable` da chave de carga útil deve ser definido como `true`.

Somente o proprietário de uma chave, ou seja, o usuário de criptografia que a criou, pode encapsulá-la. Os usuários que compartilham a chave podem usá-la em operações criptográficas.

Para usar o **key wrap aes-pkcs5-pad** comando, primeiro você deve ter uma chave AES em seu AWS CloudHSM cluster. Você pode gerar uma chave AES para encapsular usando o comando [Gerar uma chave AES simétrica com a CloudHSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) e o atributo `wrap` definido como `true`.

## Tipo de usuário
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplo
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-examples"></a>

Este exemplo mostra como usar o comando **key wrap aes-pkcs5-pad** usando uma chave AES com o valor do atributo `wrap` definido como `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="
  }
}
```

## Argumentos
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de carga útil.  
Obrigatório: Sim

***<PATH>***  
Caminho para o arquivo binário em que os dados da chave encapsulada serão salvos.  
Obrigatório: não

***<WRAPPING\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de encapsulamento.   
Obrigatório: Sim

***<WRAPPING\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de encapsulamento. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de encapsulamento for maior do que 1.

***<PAYLOAD\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de carga útil. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de carga útil for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-wrap-aes-pkcs5-pad-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Envolva uma chave AES-ZERO-PAD usando a CLI do CloudHSM
<a name="cloudhsm_cli-key-wrap-aes-zero-pad"></a>

Use o comando **key wrap aes-zero-pad** na CloudHSM CLI para encapsular uma chave de carga útil usando uma chave AES no módulo de segurança de hardware (HSM) e o mecanismo de encapsulamento `AES-ZERO-PAD`. O atributo `extractable` da chave de carga útil deve ser definido como `true`.

Somente o proprietário de uma chave, ou seja, o usuário de criptografia que a criou, pode encapsulá-la. Os usuários que compartilham a chave podem usá-la em operações criptográficas.

Para usar o **key wrap aes-zero-pad** comando, primeiro você deve ter uma chave AES em seu AWS CloudHSM cluster. Você pode gerar uma chave AES para encapsular usando o comando [Gerar uma chave AES simétrica com a CloudHSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) com o atributo `wrap` definido como `true`.

## Tipo de usuário
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplo
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-examples"></a>

Este exemplo mostra como usar o comando **key wrap aes-zero-pad ** usando uma chave AES com o valor do atributo `wrap` definido como `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"
  }
}
```

## Argumentos
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de carga útil.  
Obrigatório: Sim

***<PATH>***  
Caminho para o arquivo binário em que os dados da chave encapsulada serão salvos.  
Obrigatório: não

***<WRAPPING\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de encapsulamento.   
Obrigatório: Sim

***<WRAPPING\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de encapsulamento. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de encapsulamento for maior do que 1.

***<PAYLOAD\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de carga útil. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de carga útil for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-wrap-aes-zero-pad-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Envolva uma chave CLOUDHSM-AES-GCM usando a CLI do CloudHSM
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm"></a>

Use o comando **key wrap cloudhsm-aes-gcm** na CloudHSM CLI para encapsular uma chave de carga útil usando uma chave AES no módulo de segurança de hardware (HSM) e no mecanismo de encapsulamento `CLOUDHSM-AES-GCM`. O atributo `extractable` da chave de carga útil deve ser definido como `true`.

Somente o proprietário de uma chave, ou seja, o usuário de criptografia que a criou, pode encapsulá-la. Os usuários que compartilham a chave podem usá-la em operações criptográficas.

Para usar o **key wrap cloudhsm-aes-gcm** comando, primeiro você deve ter uma chave AES em seu AWS CloudHSM cluster. Você pode gerar uma chave AES para encapsular com o comando [Gerar uma chave AES simétrica com a CloudHSM CLI](cloudhsm_cli-key-generate-symmetric-aes.md) e o atributo `wrap` definido como `true`.

## Tipo de usuário
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplo
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-examples"></a>

Este exemplo mostra como usar o comando **key wrap cloudhsm-aes-gcm** usando uma chave 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"
  }
}
```

## Argumentos
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de carga útil.  
Obrigatório: Sim

***<PATH>***  
Caminho para o arquivo binário em que os dados da chave encapsulada serão salvos.  
Obrigatório: não

***<WRAPPING\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de encapsulamento.   
Obrigatório: Sim

***<AAD>***  
Valor de dados autenticados adicionais (AAD) do AES GCM, em hexadecimal.   
Obrigatório: não

***<TAG\$1LENGTH\$1BITS>***  
Comprimento do rótulo AES GCM em bits.  
Obrigatório: Sim

***<WRAPPING\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de encapsulamento. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de encapsulamento for maior do que 1.

***<PAYLOAD\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de carga útil. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de carga útil for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-wrap-cloudhsm-aes-gcm-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Criar uma chave com o RSA-AES usando a CloudHSM CLI
<a name="cloudhsm_cli-key-wrap-rsa-aes"></a>

Use o comando **key wrap rsa-aes** na CloudHSM CLI para encapsular uma chave de carga útil usando uma chave pública RSA no módulo de segurança de hardware (HSM) e no mecanismo de encapsulamento RSA-AES. O atributo `extractable` da chave de carga útil deve ser definido como `true`.

Somente o proprietário de uma chave, ou seja, o usuário de criptografia que a criou, pode encapsulá-la. Os usuários que compartilham a chave podem usá-la em operações criptográficas.

Para usar o **key wrap rsa-aes** comando, primeiro você deve ter uma chave RSA em seu AWS CloudHSM cluster. Você pode gerar um par de chaves RSA usando o comando [A generate-asymmetric-pair categoria na CLI do CloudHSM](cloudhsm_cli-key-generate-asymmetric-pair.md) e o atributo `wrap` definido como `true`.

## Tipo de usuário
<a name="cloudhsm_cli-key-wrap-rsa-aes-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-wrap-rsa-aes-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplo
<a name="cloudhsm_cli-key-wrap-rsa-aes-examples"></a>

Este exemplo mostra como usar o comando **key wrap rsa-ae** usando uma chave pública RSA com o valor do atributo `wrap` definido como `true`.

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

## Argumentos
<a name="cloudhsm_cli-key-wrap-rsa-aes-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de carga útil.  
Obrigatório: Sim

***<PATH>***  
Caminho para o arquivo binário em que os dados da chave encapsulada serão salvos.  
Obrigatório: não

***<WRAPPING\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de encapsulamento.   
Obrigatório: Sim

***<MGF>***  
Especifica a função de geração da máscara.  
A função hash da função de geração de máscara deve corresponder à função hash do mecanismo de assinatura.
Valores válidos  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Obrigatório: Sim

***<WRAPPING\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de encapsulamento. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de encapsulamento for maior do que 1.

***<PAYLOAD\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de carga útil. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de carga útil for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-wrap-rsa-aes-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Encapsular uma chave com o RSA-OAEP usando a CloudHSM CLI
<a name="cloudhsm_cli-key-wrap-rsa-oaep"></a>

Use o comando **key wrap rsa-oaep** na CloudHSM CLI para encapsular uma chave de carga útil usando uma chave pública RSA no módulo de segurança de hardware (HSM) e no mecanismo de encapsulamento `RSA-OAEP`. O atributo `extractable` da chave de carga útil deve ser definido como `true`.

Somente o proprietário de uma chave, ou seja, o usuário de criptografia que a criou, pode encapsulá-la. Os usuários que compartilham a chave podem usá-la em operações criptográficas.

Para usar o **key wrap rsa-oaep** comando, primeiro você deve ter uma chave RSA em seu AWS CloudHSM cluster. Você pode gerar um par de chaves RSA usando o comando [A generate-asymmetric-pair categoria na CLI do CloudHSM](cloudhsm_cli-key-generate-asymmetric-pair.md) e o atributo `wrap` definido como `true`.

## Tipo de usuário
<a name="cloudhsm_cli-key-unwrap-rsa-aes-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-unwrap-rsa-aes-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplo
<a name="cloudhsm_cli-key-unwrap-rsa-aes-examples"></a>

Este exemplo mostra como usar o comando **key wrap rsa-oaep** usando uma chave pública RSA com o valor do atributo `wrap` definido como `true`.

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

## Argumentos
<a name="cloudhsm_cli-key-unwrap-rsa-aes-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de carga útil.  
Obrigatório: Sim

***<PATH>***  
Caminho para o arquivo binário em que os dados da chave encapsulada serão salvos.  
Obrigatório: não

***<WRAPPING\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de encapsulamento.   
Obrigatório: Sim

***<MGF>***  
Especifica a função de geração da máscara.  
A função hash da função de geração de máscara deve corresponder à função hash do mecanismo de assinatura.
Valores válidos  
+ mgf1-sha1
+ mgf1-sha224
+ mgf1-sha256
+ mgf1-sha384
+ mgf1-sha512
Obrigatório: Sim

***<WRAPPING\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de encapsulamento. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de encapsulamento for maior do que 1.

***<PAYLOAD\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de carga útil. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de carga útil for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-unwrap-rsa-aes-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)

# Criar uma chave com o RSA-PKCS usando a CloudHSM CLI
<a name="cloudhsm_cli-key-wrap-rsa-pkcs"></a>

Use o comando **key wrap rsa-pkcs** na CloudHSM CLI para encapsular uma chave de carga útil usando uma chave pública RSA no módulo de segurança de hardware (HSM) e no mecanismo de encapsulamento `RSA-PKCS`. O atributo `extractable` da chave de carga útil deve ser definido como `true`.

Somente o proprietário de uma chave, ou seja, o usuário de criptografia que a criou, pode encapsulá-la. Os usuários que compartilham a chave podem usá-la em operações criptográficas.

Para usar o **key wrap rsa-pkcs** comando, primeiro você deve ter uma chave RSA em seu AWS CloudHSM cluster. Você pode gerar um par de chaves RSA usando o comando [A generate-asymmetric-pair categoria na CLI do CloudHSM](cloudhsm_cli-key-generate-asymmetric-pair.md) e o atributo `wrap` definido como `true`.

## Tipo de usuário
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-userType"></a>

Os seguintes tipos de usuários podem executar este comando.
+ Usuários de criptomoedas (CUs)

## Requisitos
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-requirements"></a>
+ Para executar esse comando, você deve estar registrado(a) como um CU.

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

## Exemplo
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-examples"></a>

Este exemplo mostra como usar o comando **key wrap rsa-pkcs** usando uma chave pública 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=="
  }
```

## Argumentos
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-arguments"></a>

***<CLUSTER\$1ID>***  
O ID do cluster em que essa operação será executada.  
Obrigatório: se vários clusters tiverem sido [configurados.](cloudhsm_cli-configs-multi-cluster.md)

***<PAYLOAD\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de carga útil.  
Obrigatório: Sim

***<PATH>***  
Caminho para o arquivo binário em que os dados da chave encapsulada serão salvos.  
Obrigatório: não

***<WRAPPING\$1FILTER>***  
Referência de chave (por exemplo, `key-reference=0xabc`) ou lista separada por espaços de atributos de chave na forma de `attr.KEY_ATTRIBUTE_NAME=KEY_ATTRIBUTE_VALUE` selecionar uma chave de encapsulamento.   
Obrigatório: Sim

***<WRAPPING\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de encapsulamento. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de encapsulamento for maior do que 1.

***<PAYLOAD\$1APPROVALR>***  
Especifica o caminho do arquivo para um arquivo de token de quórum designado para aprovar a operação da chave de carga útil. Exigido somente se o valor do quórum do serviço de gerenciamento de chaves da chave de carga útil for maior do que 1.

## Tópicos relacionados
<a name="cloudhsm_cli-key-wrap-rsa-pkcs-seealso"></a>
+ [O comando key wrap na CLI do CloudHSM](cloudhsm_cli-key-wrap.md)
+ [O comando key unwrap na CLI do CloudHSM](cloudhsm_cli-key-unwrap.md)