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á.
# Referência para comandos do AWS CloudHSM Key Management Utility
A ferramenta de linha de comando **key\$1mgmt\$1util** ajuda você a gerenciar chaves nos módulos de segurança de hardware (HSM) em seu AWS CloudHSM cluster, incluindo criar, excluir e localizar chaves e seus atributos. Ela inclui vários comandos, cada um descrito em detalhes neste tópico.
Para começar rapidamente, consulte [Começando com AWS CloudHSM key\$1mgmt\$1util](key_mgmt_util-getting-started.md). Para obter ajuda sobre a interpretação dos principais atributos, consulte [AWS CloudHSM referência de atributo-chave para KMU](key-attribute-table.md). Para obter informações sobre a ferramenta de linha de comando cloudhsm\$1mgmt\$1util, que inclui comandos para gerenciar o HSM e os usuários em seu cluster, consulte [AWS CloudHSM Utilitário de gerenciamento (CMU)](cloudhsm_mgmt_util.md).
Antes de executar um comando key\$1mgmt\$1util, você deve [iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [fazer login](key_mgmt_util-log-in.md) no HSM como um usuário de criptografia (CU).
Para listar todos os comandos key\$1mgmt\$1util, digite:
```
Command: help
```
Para obter ajuda para um comando específico da cloudhsm\$1mgmt\$1util, digite:
```
Command: -h
```
Para encerrar sua sessão key\$1mgmt\$1util, digite:
```
Command: exit
```
Os seguintes tópicos descrevem comandos na key\$1mgmt\$1util.
**nota**
Alguns comandos no key\$1mgmt\$1util e cloudhsm\$1mgmt\$1util têm os mesmos nomes. No entanto, os comandos normalmente têm sintaxe diferente, saída diferente e funcionalidade ligeiramente diferente.
| Command | Description |
| --- | --- |
| [aesWrapUnwrap](key_mgmt_util-aesWrapUnwrap.md) | Criptografa e descriptografa o conteúdo de uma chave em um arquivo. |
| [deleteKey](key_mgmt_util-deleteKey.md) | Exclui uma chave do HSMs. |
| [Error2String](key_mgmt_util-Error2String.md) | Obtém o erro que corresponde a um código de erro hexadecimal da cloudhsm\$1mgmt\$1util. |
| [exit](key_mgmt_util-exit.md) | Encerra a sessão da key\$1mgmt\$1util. |
| [exportPrivateKey](key_mgmt_util-exportPrivateKey.md) | Exporta uma cópia de uma chave privada de um HSM para um arquivo no disco. |
| [exportPubKey](key_mgmt_util-exportPubKey.md) | Exporta uma cópia de uma chave pública de um HSM para um arquivo. |
| [exSymKey](key_mgmt_util-exSymKey.md) | Exporta uma cópia em texto simples de uma chave simétrica do HSMs para um arquivo. |
| [extractMaskedObject](key_mgmt_util-extractMaskedObject.md) | Extrai uma chave de um HSM como um arquivo de objeto mascarado. |
| [findKey](key_mgmt_util-findKey.md) | Procure chaves por valor de atributo de chave. |
| [findSingleKey](key_mgmt_util-findSingleKey.md) | Verifica se existe uma chave em tudo HSMs no cluster. |
| [2 gênios DSAKey Pair](key_mgmt_util-genDSAKeyPair.md) | Gera um par de chaves do [Algoritmo de Assinatura Digital](https://en.wikipedia.org/wiki/Digital_Signature_Algorithm) (DSA) em seu HSMs. |
| [2 gênios ECCKey Pair](key_mgmt_util-genECCKeyPair.md) | Gera um par de chaves de [criptografia de curva elíptica](https://en.wikipedia.org/wiki/Elliptic-curve_cryptography) (ECC) em seu. HSMs |
| [2 gênios RSAKey Pair](key_mgmt_util-genRSAKeyPair.md) | Gera um par de chaves assimétricas [RSA](https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29) em seu. HSMs |
| [genSymKey](key_mgmt_util-genSymKey.md) | Gera uma chave simétrica em seu HSMs |
| [getAttribute](key_mgmt_util-getAttribute.md) | Obtém os valores dos atributos para uma chave do AWS CloudHSM e os grava em um arquivo. |
| [getCaviumPrivChave](key_mgmt_util-getCaviumPrivKey.md) | Cria uma versão em formato PEM falsa de uma chave privada e a exporta para um arquivo. |
| [getCert](key_mgmt_util-getCert.md) | Recupera certificados de partições do HSM e os salva em um arquivo. |
| [getKeyInfo](key_mgmt_util-getKeyInfo.md) | Obtém o usuário do HSM IDs dos usuários que podem usar a chave. Se a chave for controlada por quorum, ele obtém o número de usuários no quorum. |
| [help](key_mgmt_util-help.md) | Exibe informações de ajuda sobre os comandos disponíveis na cloudhsm\$1mgmt\$1util. |
| [importPrivateKey](key_mgmt_util-importPrivateKey.md) | Importa uma chave privada para um HSM. |
| [importPubKey](key_mgmt_util-importPubKey.md) | Importa uma chave pública para um HSM. |
| [imSymKey](key_mgmt_util-imSymKey.md) | Importa uma cópia em texto simples de uma chave simétrica de um arquivo para o HSM. |
| [insertMaskedObject](key_mgmt_util-insertMaskedObject.md) | Insere um objeto mascarado de um arquivo no disco em um HSM contido pelo cluster relacionado ao cluster de origem do objeto. Clusters relacionados são quaisquer clusters [gerados a partir de um backup do cluster de origem](create-cluster-from-backup.md). |
| [Valide o arquivo de chave usando AWS CloudHSM o KMU](key_mgmt_util-IsValidKeyHandlefile.md) | Determina se um determinado arquivo contém ou não uma chave privada real ou uma chave PEM de exemplo. |
| [listAttributes](key_mgmt_util-listAttributes.md) | Lista os atributos de uma AWS CloudHSM chave e as constantes que os representam. |
| [listUsers](key_mgmt_util-listUsers.md) | Obtém os usuários no HSMs, seu tipo e ID de usuário e outros atributos. |
| [loginHSM e logoutHSM](key_mgmt_util-loginHSM.md) | Faça login e saia do HSMs em um cluster. |
| [setAttribute](key_mgmt_util-setAttribute.md) | Converte uma chave de sessão em uma chave persistente. |
| [sign](key_mgmt_util-sign.md) | Gere uma assinatura para um arquivo usando uma chave privada escolhida. |
| [unWrapKey](key_mgmt_util-unwrapKey.md) | Importa uma chave encapsulada (criptografada) de um arquivo para HSMs o. |
| [verify](key_mgmt_util-verify.md) | Verifica se uma determinada chave foi usada para assinar um determinado arquivo. |
| [wrapKey](key_mgmt_util-wrapKey.md) | Exporta uma cópia criptografada de uma chave do HSM para um arquivo. |
# Criptografe e descriptografe qualquer arquivo usando o KMU AWS CloudHSM
Use o **aesWrapUnwrap** comando em AWS CloudHSM key\$1mgmt\$1util para criptografar ou descriptografar o conteúdo de um arquivo no disco. Este comando foi projetado para encapsular e desencapsular chaves de criptografia, mas você pode usá-lo em qualquer arquivo que contenha menos de 4 KB (4096 bytes) de dados.
O **aesWrapUnwrap** usa o Agrupamento de chaves AES com preenchimento PKCS \$15. Ele usa uma chave AES no HSM como a chave de encapsulamento ou desencapsulamento. Em seguida, ele grava o resultado em outro arquivo no disco.
Antes de executar um comando key\$1mgmt\$1util, você deve [iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [fazer login](key_mgmt_util-log-in.md) no HSM como um usuário de criptografia (CU).
## Sintaxe
```
aesWrapUnwrap -h
aesWrapUnwrap -m
-f
-w
[-i ]
[-out ]
```
## Exemplos
Esses exemplos mostram como usar **aesWrapUnwrap** para criptografar e descriptografar uma chave de criptografia em um arquivo.
**Example : encapsular uma chave de criptografia**
Esse comando usa **aesWrapUnwrap** para encapsular uma chave simétrica Triple DES que foi [exportada do HSM em texto simples](key_mgmt_util-exSymKey.md) para o arquivo `3DES.key`. Você pode usar um comando semelhante para remover qualquer chave salva em um arquivo.
O comando usa o parâmetro `-m` com um valor de `1` para indicar o modo de enrolamento. Ele usa o parâmetro `-w` para especificar uma chave AES no HSM (identificador de chave `6`) como a chave de encapsulamento. Ele grava a chave encapsulada resultante no arquivo `3DES.key.wrapped`.
A saída mostra que o comando foi bem-sucedido e que a operação usou o IV padrão, o que é preferido.
```
Command: aesWrapUnwrap -f 3DES.key -w 6 -m 1 -out 3DES.key.wrapped
Warning: IV (-i) is missing.
0xA6A6A6A6A6A6A6A6 is considered as default IV
result data:
49 49 E2 D0 11 C1 97 22
17 43 BD E3 4E F4 12 75
8D C1 34 CF 26 10 3A 8D
6D 0A 7B D5 D3 E8 4D C2
79 09 08 61 94 68 51 B7
result written to file 3DES.key.wrapped
Cfm3WrapHostKey returned: 0x00 : HSM Return: SUCCESS
```
**Example : desencapsular uma chave de criptografia**
Este exemplo mostra como usar **aesWrapUnwrap** para desempacotar (desencapsular) uma chave encapsulada (criptografada) em um arquivo. Você pode querer fazer uma operação como essa antes de importar uma chave para o HSM. Por exemplo, se você tentar usar o [imSymKey](key_mgmt_util-imSymKey.md)comando para importar uma chave criptografada, ele retornará um erro porque a chave criptografada não tem o formato necessário para uma chave de texto simples desse tipo.
O comando desencapsula a chave no arquivo `3DES.key.wrapped` e grava o texto simples no arquivo `3DES.key.unwrapped`. O comando usa o parâmetro `-m` com um valor de `0` para indicar o modo de desencapsulamento. Ele usa o parâmetro `-w` para especificar uma chave AES no HSM (identificador de chave `6`) como a chave de encapsulamento. Ele grava a chave encapsulada resultante no arquivo `3DES.key.unwrapped`.
```
Command: aesWrapUnwrap -m 0 -f 3DES.key.wrapped -w 6 -out 3DES.key.unwrapped
Warning: IV (-i) is missing.
0xA6A6A6A6A6A6A6A6 is considered as default IV
result data:
14 90 D7 AD D6 E4 F5 FA
A1 95 6F 24 89 79 F3 EE
37 21 E6 54 1F 3B 8D 62
result written to file 3DES.key.unwrapped
Cfm3UnWrapHostKey returned: 0x00 : HSM Return: SUCCESS
```
## Parâmetros
**-h**
Exibe a ajuda referente ao comando.
Obrigatório: Sim
**-m**
Especifica o modo. Para encapsular (criptografar) o conteúdo do arquivo, digite `1`; para desencapsular (descriptografar) o conteúdo do arquivo, digite `0`.
Obrigatório: Sim
**-f**
Especifica o arquivo a ser encapsulado. Insira um arquivo que contenha menos de 4 KB (4096 bytes) de dados. Essa operação foi projetada para encapsular e desencapsular chaves de criptografia.
Obrigatório: Sim
**-w**
Especifica a chave de encapsulamento. Insira o identificador de uma chave AES no HSM. Esse parâmetro é obrigatório. Para encontrar os identificadores de chave, use o comando [findKey](key_mgmt_util-findKey.md).
Para criar uma chave de empacotamento, use [genSymKey](key_mgmt_util-genSymKey.md)para gerar uma chave AES (tipo 31).
Obrigatório: Sim
**-i**
Especifica um valor inicial alternativo (IV) para o algoritmo. Use o valor padrão, a menos que você tenha uma condição especial que exija uma alternativa.
Padrão: `0xA6A6A6A6A6A6A6A6`. O valor padrão é definido na especificação do algoritmo [AES Key Wrap](https://tools.ietf.org/html/rfc3394).
Obrigatório: não
**-out**
Especifica um nome alternativo para o arquivo de saída que contém a chave encapsulada ou desencapsulada. O padrão é `wrapped_key` (para operações de encapsulamento) e `unwrapped_key` (para operações de desencapsulamento) no diretório local.
Se o arquivo existir, o **aesWrapUnwrap** o substituirá sem aviso prévio. Se o comando falhar, **aesWrapUnwrap** criará um arquivo de saída sem conteúdo.
Padrão: Para encapsulamento: `wrapped_key`. Para desencapsulamento: `unwrapped_key`.
Obrigatório: não
## Tópicos relacionados
+ [exSymKey](key_mgmt_util-exSymKey.md)
+ [imSymKey](key_mgmt_util-imSymKey.md)
+ [unWrapKey](key_mgmt_util-unwrapKey.md)
+ [wrapKey](key_mgmt_util-wrapKey.md)
# Excluir uma AWS CloudHSM chave usando KMU
Use o **deleteKey** comando no AWS CloudHSM key\$1mgmt\$1util para excluir uma chave do módulo de segurança de hardware (HSM) em 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 proprietário da chave pode excluí-la. Os usuários que compartilham a chave podem usá-la em operações criptográficas, mas não podem excluí-la.
Antes de executar um comando key\$1mgmt\$1util, você deve [iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [fazer login](key_mgmt_util-log-in.md) no HSM como um usuário de criptografia (CU).
## Sintaxe
```
deleteKey -h
deleteKey -k
```
## Exemplos
Esses exemplos mostram como usar **deleteKey** para excluir chaves do seu HSMs.
**Example : excluir uma chave**
Esse comando exclui a chave com identificador de chave `6`. Quando o comando é bem-sucedido, **deleteKey** retorna mensagens de sucesso de cada HSM do cluster.
```
Command: deleteKey -k 6
Cfm3DeleteKey returned: 0x00 : HSM Return: SUCCESS
Cluster Error Status
Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
Node id 2 and err state 0x00000000 : HSM Return: SUCCESS
```
**Example : excluir uma chave (falha)**
Quando o comando falha porque nenhuma chave possui o identificador de chave especificado, **deleteKey** retorna uma mensagem de erro de identificador de objeto inválido.
```
Command: deleteKey -k 252126
Cfm3FindKey returned: 0xa8 : HSM Error: Invalid object handle is passed to this operation
Cluster Error Status
Node id 1 and err state 0x000000a8 : HSM Error: Invalid object handle is passed to this operation
Node id 2 and err state 0x000000a8 : HSM Error: Invalid object handle is passed to this operation
```
Quando o comando falhar porque o usuário atual não é o proprietário da chave, o comando retorna um erro de acesso negado.
```
Command: deleteKey -k 262152
Cfm3DeleteKey returned: 0xc6 : HSM Error: Key Access is denied.
```
## Parâmetros
**-h**
Exibe a ajuda da linha de comando para o comando.
Obrigatório: Sim
**-k**
Especifica o identificador de chave da chave a ser excluída. Para encontrar os identificadores das chaves no HSM, use [findKey](key_mgmt_util-findKey.md).
Obrigatório: Sim
## Tópicos relacionados
+ [findKey](key_mgmt_util-findKey.md)
# Descreva um AWS CloudHSM erro ao usar o KMU
Use o comando **Error2String** auxiliar no AWS CloudHSM key\$1mgmt\$1util para retornar o erro que corresponde a um código de erro hexadecimal key\$1mgmt\$1util. Você pode usar esse comando ao solucionar problemas com comandos e scripts.
Antes de executar um comando key\$1mgmt\$1util, você deve [iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [fazer login](key_mgmt_util-log-in.md) no HSM como um usuário de criptografia (CU).
## Sintaxe
```
Error2String -h
Error2String -r
```
## Exemplos
Estes exemplos mostram como usar **Error2String** para obter a string de erro para um código de erro da key\$1mgmt\$1util.
**Example : Obter uma descrição do erro**
Esse comando obtém a descrição do erro para o código de erro `0xdb`. A descrição explica que uma tentativa de fazer login na key\$1mgmt\$1util falhou porque o usuário possui o tipo de usuário errado. Somente usuários de criptografia (CU) podem fazer login na key\$1mgmt\$1util.
```
Command: Error2String -r 0xdb
Error Code db maps to HSM Error: Invalid User Type.
```
**Example : Encontrar o código de erro**
Este exemplo mostra onde encontrar o código de erro em um erro da key\$1mgmt\$1util. O código de erro, `0xc6`, aparece após a string: `Cfm3 returned: `.
Neste exemplo, [getKeyInfo](key_mgmt_util-getKeyInfo.md)indica que o usuário atual (usuário 4) pode usar a chave em operações criptográficas. No entanto, quando o usuário tenta usar [deleteKey](key_mgmt_util-deleteKey.md) para excluir a chave, o comando retorna o código de erro `0xc6`.
```
Command: deleteKey -k 262162
Cfm3DeleteKey returned: <0xc6> : HSM Error: Key Access is denied
Cluster Error Status
Command: getKeyInfo -k 262162
Cfm3GetKey returned: 0x00 : HSM Return: SUCCESS
Owned by user 3
also, shared to following 1 user(s):
4
```
Se o erro `0xc6` for reportado, você poderá usar um comando **Error2String** como esse para procurar o erro. Nesse caso, o comando `deleteKey` falhou com um erro de acesso negado porque a chave é compartilhada com o usuário atual, mas possuída por um usuário diferente. Somente os proprietários de chaves têm permissão para excluir uma chave.
```
Command: Error2String -r 0xa8
Error Code c6 maps to HSM Error: Key Access is denied
```
## Parâmetros
**-h**
Exibe a ajuda referente ao comando.
Obrigatório: Sim
**-r**
Especifica um código de erro hexadecimal. É necessário o indicador de hexadecimal `0x`.
Obrigatório: Sim
# Saia da AWS CloudHSM KMU
Use o **exit** comando no key\$1mgmt\$1util para sair do AWS CloudHSM key\$1mgmt\$1util. Após a saída bem-sucedida, você retornará à sua linha de comando padrão.
Antes de executar qualquer comando key\$1mgmt\$1util, você deve [iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start).
## Sintaxe
```
exit
```
## Parâmetros
Não há parâmetros para esse comando.
## Tópicos relacionados
+ [Iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start)
# Exportar uma AWS CloudHSM chave privada usando KMU
Use o **exportPrivateKey** comando no AWS CloudHSM key\$1mgmt\$1util para exportar uma chave privada assimétrica de um módulo de segurança de hardware (HSM) para um arquivo. O HSM não permite a exportação direta de chaves em texto não criptografado. O comando agrupa a chave privada usando uma chave de agrupamento AES que você especifica, descriptografa os bytes agrupados e copia a chave privada de texto não criptografado em um arquivo.
O comando **exportPrivateKey** não remove a chave do HSM nem altera os [atributos de chave](key-attribute-table.md) ou impede que você use a chave em outras operações criptográficas. É possível exportar a mesma chave várias vezes.
Você só pode exportar chaves privadas que têm o atributo `OBJ_ATTR_EXTRACTABLE` com o valor `1`. Você deve especificar uma chave de agrupamento AES que tenha atributos de valor `1` `OBJ_ATTR_WRAP` e `OBJ_ATTR_DECRYPT`. Para encontrar os atributos de uma chave, use o comando [**getAttribute**](key_mgmt_util-getAttribute.md).
Antes de executar um comando key\$1mgmt\$1util, você deve [iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [fazer login](key_mgmt_util-log-in.md) no HSM como um usuário de criptografia (CU).
## Sintaxe
```
exportPrivateKey -h
exportPrivateKey -k
-w
-out
[-m ]
[-wk ]
```
## Exemplos
Este exemplo mostra como usar **exportPrivateKey** para exportar uma chave privada de um HSM.
**Example : Export a Private Key**
Esse comando exporta uma chave privada com o identificador `15` usando uma chave de encapsulamento com o identificador `16` para um arquivo PEM chamado `exportKey.pem`. Quando o comando é bem-sucedido, **exportPrivateKey** retorna uma mensagem de êxito.
```
Command: exportPrivateKey -k 15 -w 16 -out exportKey.pem
Cfm3WrapKey returned: 0x00 : HSM Return: SUCCESS
Cfm3UnWrapHostKey returned: 0x00 : HSM Return: SUCCESS
PEM formatted private key is written to exportKey.pem
```
## Parâmetros
Esse comando usa os seguintes parâmetros.
**`-h`**
Exibe a ajuda da linha de comando para o comando.
Obrigatório: Sim
**`-k`**
Especifica o identificador de chave da chave privada a ser exportada.
Obrigatório: Sim
**`-w`**
Especifica o identificador de chave da chave de encapsulamento. Esse parâmetro é obrigatório. Para encontrar os identificadores de chave, use o comando [**findKey**](key_mgmt_util-findKey.md).
Para determinar se uma chave pode ser usada como uma chave de encapsulamento, use [**getAttribute**](key_mgmt_util-getAttribute.md) para obter o valor do atributo `OBJ_ATTR_WRAP` (262). Para criar uma chave de encapsulamento, use [**genSymKey**](key_mgmt_util-genSymKey.md) a fim de criar uma chave AES (digite 31).
Se você usar o parâmetro `-wk` para especificar uma chave de desencapsulamento externa, a chave de encapsulamento `-w` será usada para encapsular, mas não para desencapsular, a chave durante a exportação.
Obrigatório: Sim
**`-out`**
Especifica o nome do arquivo no qual a chave privada exportada será gravada.
Obrigatório: Sim
**`-m`**
Especifica o mecanismo de encapsulamento com o qual encapsular a chave privada que está sendo exportada. O único valor válido é `4`, que representa `NIST_AES_WRAP mechanism.`
Padrão: 4 (`NIST_AES_WRAP`)
Obrigatório: não
**`-wk`**
Especifica a chave a ser usada para desencapsular a chave que está sendo exportada. Insira o caminho e o nome de um arquivo que contém uma chave AES de texto simples.
Durante a inclusão desse parâmetro. **exportPrivateKey** usa a chave no arquivo `-w` para encapsular a chave que está sendo exportada e usa a chave especificada no parâmetro `-wk` para desencapsulá-la.
Padrão: use a chave de encapsulamento especificada no parâmetro `-w` para encapsular e desencapsular.
Obrigatório: não
## Tópicos relacionados
+ [importPrivateKey](key_mgmt_util-importPrivateKey.md)
+ [wrapKey](key_mgmt_util-wrapKey.md)
+ [unWrapKey](key_mgmt_util-unwrapKey.md)
+ [genSymKey](key_mgmt_util-genSymKey.md)
# Exportar uma AWS CloudHSM chave pública usando KMU
Use o **exportPubKey** comando no AWS CloudHSM key\$1mgmt\$1util para exportar uma chave pública em um HSM para um arquivo. Você pode usá-lo para exportar chaves públicas que você gera em um HSM. Você também pode usar esse comando para exportar chaves públicas que foram importadas para um HSM, como as importadas com o comando **[**importPubKey**](key_mgmt_util-importPubKey.md)**.
A operação **exportPubKey** copia o material de chave emum arquivo especificado por você. Mas ele não remove a chave do HSM nem altera os [atributos de chave](key-attribute-table.md) ou impede que você use a chave em outras operações criptográficas. É possível exportar a mesma chave várias vezes.
Você só pode exportar chaves públicas que têm um valor `OBJ_ATTR_EXTRACTABLE` de `1`. Para encontrar os atributos de uma chave, use o comando **[getAttribute](key_mgmt_util-getAttribute.md)**.
Para executar um comando da `key_mgmt_util`, você deve [iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [fazer login](key_mgmt_util-log-in.md) no HSM como um usuário de criptografia (CU).
## Sintaxe
```
exportPubKey -h
exportPubKey -k
-out
```
## Exemplos
Este exemplo mostra como usar **exportPubKey** para exportar uma chave pública de um HSM.
**Example : Export a Public Key**
Esse comando exporta uma chave pública com identificador `10` para um arquivo chamado `public.pem`. Quando o comando é bem-sucedido, **exportPubKey** retorna uma mensagem de êxito.
```
Command: exportPubKey -k 10 -out public.pem
PEM formatted public key is written to public.pem
Cfm3ExportPubKey returned: 0x00 : HSM Return: SUCCESS
```
## Parâmetros
Esse comando usa os seguintes parâmetros.
**`-h`**
Exibe a ajuda da linha de comando para o comando.
Obrigatório: Sim
**`-k`**
Especifica o identificador de chave da chave pública a ser exportada.
Obrigatório: Sim
**`-out`**
Especifica o nome do arquivo no qual a chave pública exportada será gravada.
Obrigatório: Sim
## Tópicos relacionados
+ [importPubKey](key_mgmt_util-importPubKey.md)
+ [Gerar chaves](generate-keys.md)
# Exportar uma cópia em texto simples de uma AWS CloudHSM chave usando KMU
Use o **exSymKey** comando na ferramenta AWS CloudHSM key\$1mgmt\$1util para exportar uma cópia em texto simples de uma chave simétrica do módulo de segurança de hardware (HSM) e salvá-la em um arquivo no disco. Para exportar uma cópia criptografada (encapsulada) de uma chave, use [wrapKey](key_mgmt_util-wrapKey.md). Para importar uma chave de texto simples, como as que `exSymKey` exportam, use. [imSymKey](key_mgmt_util-imSymKey.md)
Durante o processo de exportação, **exSymKey** usa uma chave AES que você especifica (a *chave de encapsulamento*) para *encapsular* (criptografar) e depois *desencapsular* (descriptografar) a chave a ser exportada. No entanto, o resultado da operação de exportação é uma chave em texto simples (*desencapsulada*) no disco.
Somente o proprietário de uma chave, ou seja, o usuário CU que a criou, pode exportá-la. Os usuários que compartilham a chave podem usá-la em operações de criptografia, mas não podem exportá-la.
A operação **exSymKey** copia o material da chave para um arquivo que você especifica, mas não remove a chave do HSM, altera seus [atributos de chave](key-attribute-table.md) ou impede que você a use em operações criptográficas. É possível exportar a mesma chave várias vezes.
**exSymKey** exporta apenas chaves simétricas. Para exportar chaves públicas, use [exportPubKey](key_mgmt_util-exportPubKey.md). Para exportar chaves privadas, use [exportPrivateKey](key_mgmt_util-exportPrivateKey.md).
Antes de executar um comando key\$1mgmt\$1util, você deve [iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [fazer login](key_mgmt_util-log-in.md) no HSM como um usuário de criptografia (CU).
## Sintaxe
```
exSymKey -h
exSymKey -k
-w
-out
[-m 4]
[-wk ]
```
## Exemplos
Esses exemplos mostram como usar para **exSymKey** exportar chaves simétricas que você possui do seu HSMs.
**Example : Exportar uma chave simétrica 3DES**
Esse comando exporta uma chave simétrica Triple DES (3DES) (identificador de chave `7`). Ele usa uma chave AES existente (identificador de chave `6`) no HSM como chave de encapsulamento. Em seguida, ele grava o texto simples da chave 3DES no arquivo `3DES.key`.
A saída mostra que a chave `7` (a tecla 3DES) foi encapsulada e desencapsulada com êxito e, em seguida, gravada no arquivo `3DES.key`.
Embora a saída diga que uma "Chave simétrica encapsulada" foi gravada no arquivo de saída, este último contém uma chave em texto simples (desencapsulada).
```
Command: exSymKey -k 7 -w 6 -out 3DES.key
Cfm3WrapKey returned: 0x00 : HSM Return: SUCCESS
Cfm3UnWrapHostKey returned: 0x00 : HSM Return: SUCCESS
Wrapped Symmetric Key written to file "3DES.key"
```
**Example : Exportar com a chave de encapsulamento somente para sessão**
Este exemplo mostra como usar uma chave que existe apenas na sessão como a chave de encapsulamento. Como a chave a ser exportada é encapsulada, imediatamente desencapsulada e fornecida como texto simples, não há necessidade de reter a chave de encapsulamento.
Esta série de comandos exporta uma chave AES com o identificador de chave `8` do HSM. Ela usa uma chave de sessão AES criada especialmente para esse propósito.
O primeiro comando é usado [genSymKey](key_mgmt_util-genSymKey.md)para criar uma chave AES de 256 bits. Ele usa o parâmetro `-sess` para criar uma chave que existe apenas na sessão atual.
A saída mostra que o HSM cria a chave `262168`.
```
Command: genSymKey -t 31 -s 32 -l AES-wrapping-key -sess
Cfm3GenerateSymmetricKey returned: 0x00 : HSM Return: SUCCESS
Symmetric Key Created. Key Handle: 262168
Cluster Error Status
Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
```
Em seguida, o exemplo verifica se a chave `8`, a chave a ser exportada, é uma chave simétrica extraível. Ele também verifica se a chave de encapsulamento, `262168`, é uma chave AES que existe apenas na sessão. Você pode usar o comando [findKey](key_mgmt_util-findKey.md), mas esse exemplo exporta os atributos de ambas as chaves para arquivos e, em seguida, usa `grep` para encontrar valores de atributos relevantes no arquivo.
Esses comandos usam `getAttribute` com um valor `-a` de `512` (tudo) para obter todos os atributos para as chaves `8` e `262168`. Para obter informações sobre os atributos de chaves, consulte [AWS CloudHSM referência de atributo-chave para KMU](key-attribute-table.md).
```
getAttribute -o 8 -a 512 -out attributes/attr_8
getAttribute -o 262168 -a 512 -out attributes/attr_262168
```
Esses comandos usam `grep` para verificar os atributos da chave a ser exportada (chave `8`) e da chave de encapsulamento somente da sessão (chave `262168`).
```
// Verify that the key to be exported is a symmetric key.
$ grep -A 1 "OBJ_ATTR_CLASS" attributes/attr_8
OBJ_ATTR_CLASS
0x04
// Verify that the key to be exported is extractable.
$ grep -A 1 "OBJ_ATTR_KEY_TYPE" attributes/attr_8
OBJ_ATTR_EXTRACTABLE
0x00000001
// Verify that the wrapping key is an AES key
$ grep -A 1 "OBJ_ATTR_KEY_TYPE" attributes/attr_262168
OBJ_ATTR_KEY_TYPE
0x1f
// Verify that the wrapping key is a session key
$ grep -A 1 "OBJ_ATTR_TOKEN" attributes/attr_262168
OBJ_ATTR_TOKEN
0x00
// Verify that the wrapping key can be used for wrapping
$ grep -A 1 "OBJ_ATTR_WRAP" attributes/attr_262168
OBJ_ATTR_WRAP
0x00000001
```
Por último, usamos um comando **exSymKey** para exportar a chave `8` usando a chave de sessão (chave `262168`) como a chave de encapsulamento.
Quando a sessão terminar, a chave `262168` não existirá mais.
```
Command: exSymKey -k 8 -w 262168 -out aes256_H8.key
Cfm3WrapKey returned: 0x00 : HSM Return: SUCCESS
Cfm3UnWrapHostKey returned: 0x00 : HSM Return: SUCCESS
Wrapped Symmetric Key written to file "aes256_H8.key"
```
**Example : Usar uma chave de desencapsulamento externa**
Este exemplo mostra como usar uma chave de desencapsulamento externa para exportar uma chave do HSM.
Ao exportar uma chave do HSM, você especifica uma chave AES no HSM para ser a chave de encapsulamento. Por padrão, essa chave de encapsulamento é usada para encapsular e desencapsular a chave a ser exportada. No entanto, você pode usar o parâmetro `-wk` para instruir **exSymKey** a usar uma chave externa em um arquivo no disco para desencapsulamento. Ao fazer isso, a chave especificada pelo parâmetro `-w` encapsula a chave de destino e a chave no arquivo especificado pelo parâmetro `-wk` desencapsula a chave.
Como a chave de encapsulamento deve ser uma chave AES, que é simétrica, a chave de encapsulamento no HSM e a chave no disco devem ter o mesmo material de chave. Para fazer isso, você deve importar a chave de encapsulamento para o HSM ou exportá-la do HSM antes da operação de exportação.
Esse exemplo cria uma chave fora do HSM e a importa para o HSM. Ele usa a cópia interna da chave para encapsular uma chave simétrica que está sendo exportada e usa a cópia dessa chave no arquivo para desencapsulá-la.
O primeiro comando usa o OpenSSL para gerar uma chave AES de 256 bits. Ele salva a chave no arquivo `aes256-forImport.key`. O comando OpenSSL não retorna saída, mas você pode usar vários comandos para confirmar seu sucesso. Este exemplo usa a ferramenta **wc** (contagem de palavras), que confirma que o arquivo tem 32 bytes de dados.
```
$ openssl rand -out keys/aes256-forImport.key 32
$ wc keys/aes256-forImport.key
0 2 32 keys/aes256-forImport.key
```
Esse comando usa o comando [imSymKey](key_mgmt_util-imSymKey.md) para importar a chave AES do arquivo `aes256-forImport.key` para o HSM. Quando o comando é concluído, a chave existe no HSM com o identificador de chave `262167` e no arquivo `aes256-forImport.key`.
```
Command: imSymKey -f keys/aes256-forImport.key -t 31 -l aes256-imported -w 6
Cfm3WrapHostKey returned: 0x00 : HSM Return: SUCCESS
Cfm3CreateUnwrapTemplate returned: 0x00 : HSM Return: SUCCESS
Cfm3UnWrapKey returned: 0x00 : HSM Return: SUCCESS
Symmetric Key Unwrapped. Key Handle: 262167
Cluster Error Status
Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
Node id 0 and err state 0x00000000 : HSM Return: SUCCESS
```
Esse comando usa a chave em uma operação de exportação. O comando usa **exSymKey** para exportar a chave `21`, uma chave AES de 192 bits. Para encapsular a chave, ele usa a chave `262167`, que é a cópia que foi importada para o HSM. Para desempacotar a chave, ela usa o mesmo material de chave no arquivo `aes256-forImport.key`. Quando o comando for concluído, a chave `21` será exportada para o arquivo `aes192_h21.key`.
```
Command: exSymKey -k 21 -w 262167 -out aes192_H21.key -wk aes256-forImport.key
Cfm3WrapKey returned: 0x00 : HSM Return: SUCCESS
Wrapped Symmetric Key written to file "aes192_H21.key"
```
## Parâmetros
**-h**
Exibe a ajuda referente ao comando.
Obrigatório: Sim
**-k**
Especifica o identificador de chave da chave a ser exportada. Esse parâmetro é obrigatório. Insira o identificador de chave de uma chave simétrica que você possui. Esse parâmetro é obrigatório. Para encontrar os identificadores de chave, use o comando [findKey](key_mgmt_util-findKey.md).
Para verificar se uma chave pode ser exportada, use o comando [getAttribute](key_mgmt_util-getAttribute.md) para obter o valor do atributo `OBJ_ATTR_EXTRACTABLE`, que é representado pela constante `354`. Além disso, você pode exportar apenas as chaves que você possui. Para encontrar o proprietário de uma chave, use o [getKeyInfo](key_mgmt_util-getKeyInfo.md)comando.
Obrigatório: Sim
**-w**
Especifica o identificador de chave da chave de encapsulamento. Esse parâmetro é obrigatório. Para encontrar os identificadores de chave, use o comando [findKey](key_mgmt_util-findKey.md).
Uma *chave de encapsulamento* é uma chave no HSM que é usada para criptografar (encapsular) e depois descriptografar (desencapsular) a chave a ser exportada. Somente as chaves AES podem ser usadas como chaves de encapsulamento.
Você pode usar qualquer chave do AES (de qualquer tamanho) como uma chave de encapsulamento. Como a chave de encapsulamento encapsula e depois desencapsula imediatamente a chave de destino, você pode usar como chave AES somente de sessão como uma chave de encapsulamento. Para determinar se uma chave pode ser usada como uma chave de encapsulamento, use [getAttribute](key_mgmt_util-getAttribute.md) para obter o valor do atributo `OBJ_ATTR_WRAP`, que é representado pela constante `262`. Para criar uma chave de encapsulamento, use [genSymKey](key_mgmt_util-genSymKey.md) a fim de criar uma chave AES (digite 31).
Se você usar o parâmetro `-wk` para especificar uma chave de desencapsulamento externa, a chave de encapsulamento `-w` será usada para encapsular, mas não para desencapsular, a chave durante a exportação.
A chave 4 representa uma chave interna sem suporte. Recomendamos usar uma chave AES criada e gerenciada por você como a chave de encapsulamento.
Obrigatório: Sim
**-out**
Especifica o caminho e o nome do arquivo de saída. Quando o comando é bem-sucedido, esse arquivo contém a chave exportada em texto simples. Se o arquivo já existir, o comando o sobrescreverá sem aviso prévio.
Obrigatório: Sim
**-m**
Especifica o mecanismo de encapsulamento. O único valor válido é `4`, que representa o mecanismo `NIST_AES_WRAP`.
Obrigatório: não
Padrão: 4
**-wk**
Use a chave AES no arquivo especificado para desencapsular a chave que está sendo exportada. Insira o caminho e o nome de um arquivo que contém uma chave AES de texto simples.
Durante a inclusão desse parâmetro. `exSymKey` usa a chave no arquivo no HSM especificada pelo parâmetro `-w` para encapsular a chave que está sendo exportada e usa a chave no arquivo `-wk` para desencapsulá-la. Os valores dos parâmetros `-w` e `-wk` devem ser resolvidos para a mesma chave de texto simples.
Obrigatório: não
Padrão: use a chave de encapsulamento no HSM para desencapsular.
## Tópicos relacionados
+ [genSymKey](key_mgmt_util-genSymKey.md)
+ [imSymKey](key_mgmt_util-imSymKey.md)
+ [wrapKey](key_mgmt_util-wrapKey.md)
# Extraia uma AWS CloudHSM chave usando KMU
Use o **extractMaskedObject** comando no AWS CloudHSM key\$1mgmt\$1util para extrair uma chave de um módulo de segurança de hardware (HSM) e salvá-la em um arquivo como um objeto mascarado. Objetos mascarados são objetos *clonados* que só podem ser usados após serem inseridos novamente no cluster original usando o comando **[insertMaskedObject](key_mgmt_util-insertMaskedObject.md)**. Você só pode inserir um objeto mascarado no mesmo cluster do qual ele foi gerado ou em um clone desse cluster. Isso inclui quaisquer versões clonadas do cluster geradas ao [copiar um backup entre regiões](copy-backup-to-region.md) e [usar esse backup para criar um novo cluster](create-cluster-from-backup.md).
Objetos mascarados são uma maneira eficiente de descarregar e sincronizar chaves, incluindo chaves nonextractable (isto é, chaves que têm um [`OBJ_ATTR_EXTRACTABLE`](key-attribute-table.md) valor de `0`). [Dessa forma, as chaves podem ser sincronizadas com segurança entre clusters relacionados em diferentes regiões sem a necessidade de atualizar o AWS CloudHSM arquivo de configuração.](configure-tool.md)
**Importante**
Na inserção, os objetos mascarados são descriptografados e recebem um identificador de chave diferente do identificador de chave da chave original. Um objeto mascarado inclui todos os metadados associados à chave original, inclusive atributos, informações de propriedade e compartilhamento e configurações de quórum. Se você precisa sincronizar as chaves em clusters em um aplicativo, use [syncKey](cloudhsm_mgmt_util-syncKey.md) cloudhsm\$1mgmt\$1util instead.
Antes de executar um comando key\$1mgmt\$1util, você deve [iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [fazer login](key_mgmt_util-log-in.md) no HSM. O comando **extractMaskedObject** pode ser usado pelo CU que possui a chave ou qualquer CO.
## Sintaxe
```
extractMaskedObject -h
extractMaskedObject -o
-out
```
## Exemplos
Este exemplo mostra como usar **extractMaskedObject** para extrair uma chave de um HSM como um objeto mascarado.
**Example : Extract a Masked Object**
Esse comando extrai um objeto mascarado de um HSM a partir de uma chave com identificador `524295` e a salva como um arquivo chamado `maskedObj`. Quando o comando é bem-sucedido, **extractMaskedObject** retorna uma mensagem de êxito.
```
Command: extractMaskedObject -o 524295 -out maskedObj
Object was masked and written to file "maskedObj"
Cfm3ExtractMaskedObject returned: 0x00 : HSM Return: SUCCESS
```
## Parâmetros
Esse comando usa os seguintes parâmetros.
**`-h`**
Exibe a ajuda da linha de comando para o comando.
Obrigatório: Sim
**`-o`**
Especifica o identificador da chave a ser extraída como um objeto mascarado.
Obrigatório: Sim
**`-out`**
Especifica o nome do arquivo no qual o objeto mascarado será salvo.
Obrigatório: Sim
## Tópicos relacionados
+ [insertMaskedObject](key_mgmt_util-insertMaskedObject.md)
+ [syncKey](cloudhsm_mgmt_util-syncKey.md)
+ [Copiar um backup entre regiões](copy-backup-to-region.md)
+ [Criando um AWS CloudHSM cluster a partir de um backup anterior](create-cluster-from-backup.md)
# Pesquise AWS CloudHSM chaves por atributos usando KMU
Use o **findKey** comando no AWS CloudHSM key\$1mgmt\$1util para pesquisar chaves pelos valores dos atributos da chave. Quando uma chave corresponder a todos os critérios que você definir, **findKey** retornará o identificador de chave. Sem parâmetros, **findKey** retorna os identificadores de chave de todas as chaves que você pode usar no HSM. Para encontrar os valores de atributo de uma determinada chave, use [getAttribute](key_mgmt_util-getAttribute.md).
Como todos os comandos de key\$1mgmt\$1util, **findKey** é específico do usuário. Ele retorna apenas as chaves que o usuário atual pode usar em operações criptográficas. Isso inclui chaves que o usuário atual possui e as chaves que foram compartilhadas com ele.
Antes de executar um comando key\$1mgmt\$1util, você deve [iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [fazer login](key_mgmt_util-log-in.md) no HSM como um usuário de criptografia (CU).
## Sintaxe
```
findKey -h
findKey [-c ]
[-t ]
[-l ]
[-id ]
[-sess (0 | 1)]
[-u ]
[-m ]
[-kcv ]
```
## Exemplos
Esses exemplos mostram como usar **findKey** para encontrar e identificar chaves em seu HSMs.
**Example : Encontrar todas as chaves**
Esse comando encontra todas as chaves para o usuário atual no HSM. A saída inclui chaves que o usuário possui e compartilha, e todas as chaves públicas no HSMs.
Para obter os atributos de uma chave com um identificador de chave específico, use [getAttribute](key_mgmt_util-getAttribute.md). Para determinar se o usuário atual possui ou compartilha uma chave específica, use [getKeyInfo](key_mgmt_util-getKeyInfo.md)ou [findAllKeys](cloudhsm_mgmt_util-findAllKeys.md)em cloudhsm\$1mgmt\$1util.
```
Command: findKey
Total number of keys present 13
number of keys matched from start index 0::12
6, 7, 524296, 9, 262154, 262155, 262156, 262157, 262158, 262159, 262160, 262161, 262162
Cluster Error Status
Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
Node id 0 and err state 0x00000000 : HSM Return: SUCCESS
Cfm3FindKey returned: 0x00 : HSM Return: SUCCESS
```
**Example : Encontrar chaves por tipo, usuário e sessão**
Este comando encontra chaves AES persistentes que o usuário atual e o usuário 3 podem usar. (O usuário 3 pode usar outras chaves que o usuário atual não pode ver.)
```
Command: findKey -t 31 -sess 0 -u 3
```
**Example : Encontrar chaves por classe e rótulo**
Este comando encontra todas as chaves públicas para o usuário atual com o rótulo `2018-sept`.
```
Command: findKey -c 2 -l 2018-sept
```
**Example : Encontrar chaves RSA por módulo**
Este comando encontra as chaves RSA (tipo 0) para o usuário atual que foram criadas usando o módulo no arquivo `m4.txt`.
```
Command: findKey -t 0 -m m4.txt
```
## Parâmetros
**-h**
Exibe a ajuda referente ao comando.
Obrigatório: Sim
**-t**
Encontra chaves do tipo especificado. Insira a constante que representa a classe de chave. Por exemplo, para encontrar chaves 3DES, digite `-t 21`.
Valores válidos:
+ 0: [RSA](https://en.wikipedia.org/wiki/RSA_(cryptosystem))
+ 1: [DSA](https://en.wikipedia.org/wiki/Digital_Signature_Algorithm)
+ 3: [EC](https://en.wikipedia.org/wiki/Elliptic-curve_cryptography)
+ 16: [GENERIC\$1SECRET](http://docs.oasis-open.org/pkcs11/pkcs11-curr/v2.40/cos01/pkcs11-curr-v2.40-cos01.html#_Toc408226962)
+ 18: [RC4](https://en.wikipedia.org/wiki/RC4)
+ 21: [Triple DES (3DES)](https://en.wikipedia.org/wiki/Triple_DES)
+ 31: [AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)
Obrigatório: não
**-c**
Localiza chaves na classe especificada. Insira a constante que representa a classe de chave. Por exemplo, para encontrar chaves públicas, digite `-c 2`.
Valores válidos para cada tipo de chave:
+ 2: Pública. Essa classe contém as chaves públicas dos pares de chaves públicas-privadas.
+ 3: Privada. Essa classe contém as chaves privadas dos pares de chaves públicas-privadas.
+ 4: Secreta. Essa classe contém todas as chaves simétricas.
Obrigatório: não
**-l**
Encontra chaves com o rótulo especificado. Digite o rótulo exato. Você não pode usar caracteres curinga ou expressões regulares no valor `--l`.
Obrigatório: não
**-id**
Encontra a chave com o ID especificado. Digite a string de ID exata. Você não pode usar caracteres curinga ou expressões regulares no valor `-id`.
Obrigatório: não
**-sess**
Localiza chaves por status da sessão. Para encontrar as chaves válidas apenas na sessão atual, digite `1`. Para localizar chaves persistentes, digite `0`.
Obrigatório: não
**-u**
Encontra as chaves dos usuários especificados e o compartilhamento de usuários atual. Digite uma lista separada por vírgulas de usuários do HSM IDs, como ou. `-u 3` `-u 4,7` Para encontrar o número IDs de usuários em um HSM, use [ListUsers](key_mgmt_util-listUsers.md).
Quando você especifica um ID de usuário, **findKey** retorna as chaves para esse usuário. Quando você especifica vários usuários IDs, **findKey** retorna as chaves que todos os usuários especificados podem usar.
Como **findKey** simplesmente retorna as chaves que o usuário atual pode usar, os resultados de `-u` são sempre idênticos às, ou um subconjunto das, chaves do usuário atual. Para obter todas as chaves pertencentes a ou compartilhadas com qualquer usuário, os agentes criptográficos (COs) podem usar [findAllKeys](cloudhsm_mgmt_util-findAllKeys.md)em cloudhsm\$1mgmt\$1util.
Obrigatório: não
**-m**
Localiza as chaves que foram criadas usando o módulo RSA no arquivo especificado. Digite o caminho para o arquivo que armazena o módulo.
-m especifica o arquivo binário que contém o módulo RSA a ser correspondido (opcional).
Obrigatório: não
**-kcv**
Encontra chaves com o valor de verificação de chave especificado.
O *key check value* (KCV – valor de verificação de chave) é um hash de 3 bytes ou soma de verificação de uma chave gerada quando o HSM importa ou gera uma chave. Você também pode calcular um KCV fora do HSM, como depois de exportar uma chave. Em seguida, é possível comparar os valores do KCV para confirmar a identidade e a integridade da chave. Para obter o KCV de uma chave, use [getAttribute](key_mgmt_util-getAttribute.md).
AWS CloudHSM usa o seguinte método padrão para gerar um valor de verificação de chave:
+ **Chaves simétricas**: primeiros 3 bytes do resultado da criptografia de um bloco zero com a chave.
+ **Pares de chaves assimétricas**: primeiros 3 bytes do hash SHA-1 da chave pública.
+ **Chaves HMAC**: o KCV para chaves HMAC não é suportado no momento.
Obrigatório: não
## Output
A saída **findKey** mostra o número total de chaves correspondentes e seus identificadores de chave.
```
Command: findKey
Total number of keys present 10
number of keys matched from start index 0::9
6, 7, 8, 9, 10, 11, 262156, 262157, 262158, 262159
Cluster Error Status
Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
Node id 2 and err state 0x00000000 : HSM Return: SUCCESS
Cfm3FindKey returned: 0x00 : HSM Return: SUCCESS
```
## Tópicos relacionados
+ [findSingleKey](key_mgmt_util-findSingleKey.md)
+ [getKeyInfo](key_mgmt_util-getKeyInfo.md)
+ [getAttribute](key_mgmt_util-getAttribute.md)
+ [findAllKeys](cloudhsm_mgmt_util-findAllKeys.md)em cloudhsm\$1mgmt\$1util
+ [Referência de atributos de chave](key-attribute-table.md)
# Verifique uma AWS CloudHSM chave usando KMU
Use o **findSingleKey** comando na ferramenta AWS CloudHSM key\$1mgmt\$1util para verificar se existe uma chave em todos os módulos de segurança de hardware (HSM) no cluster. AWS CloudHSM
Antes de executar um comando key\$1mgmt\$1util, você deve [iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [fazer login](key_mgmt_util-log-in.md) no HSM como um usuário de criptografia (CU).
## Sintaxe
```
findSingleKey -h
findSingleKey -k
```
## Exemplo
**Example**
Esse comando verifica se a chave `252136` existe em todos os três HSMs no cluster.
```
Command: findSingleKey -k 252136
Cfm3FindKey returned: 0x00 : HSM Return: SUCCESS
Cluster Error Status
Node id 2 and err state 0x00000000 : HSM Return: SUCCESS
Node id 1 and err state 0x00000000 : HSM Return: SUCCESS
Node id 0 and err state 0x00000000 : HSM Return: SUCCESS
```
## Parâmetros
**-h**
Exibe a ajuda referente ao comando.
Obrigatório: Sim
**-k**
Especifica o identificador da chave no HSM. Esse parâmetro é obrigatório.
Para encontrar os identificadores de chave, use o comando [findKey](key_mgmt_util-listUsers.md).
Obrigatório: Sim
## Tópicos relacionados
+ [findKey](key_mgmt_util-listUsers.md)
+ [getKeyInfo](key_mgmt_util-listUsers.md)
+ [getAttribute](key_mgmt_util-findKey.md)
# Gere um par de chaves AWS CloudHSM DSA usando KMU
Use o **genDSAKeyPair** comando na ferramenta AWS CloudHSM key\$1mgmt\$1util para gerar um par de chaves do Algoritmo de [Assinatura Digital (DSA](https://en.wikipedia.org/wiki/Digital_Signature_Algorithm)) em seus módulos de segurança de hardware (HSM). Você deve especificar o comprimento do módulo; o comando gera o valor do módulo. Você também pode atribuir um ID, compartilhar a chave com outros usuários do HSM e criar chaves não extraíveis que expiram quando a sessão termina. Quando o comando é bem-sucedido, ele retorna os *identificadores de chave* que o HSM atribui às chaves públicas e privadas. Você pode usar os identificadores de chave para identificar as chaves para outros comandos.
Antes de executar um comando key\$1mgmt\$1util, você deve [iniciar key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [fazer login](key_mgmt_util-log-in.md) no HSM como um usuário de criptografia (CU).
**dica**
Para encontrar os atributos de uma chave criada por você, como tipo, comprimento, rótulo e ID, use [getAttribute](key_mgmt_util-getAttribute.md). Para encontrar as chaves de um usuário específico, use [getKeyInfo](key_mgmt_util-getKeyInfo.md). Para encontrar chaves com base em seus valores de atributos, use [FindKey](key_mgmt_util-findKey.md).
## Sintaxe
```
genDSAKeyPair -h
genDSAKeyPair -m
-l