Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Riferimento per i comandi della AWS CloudHSM Key Management Utility
Lo strumento da riga di comando **key\$1mgmt\$1util** consente di gestire le chiavi nei moduli di sicurezza hardware (HSM) del AWS CloudHSM cluster, incluse la creazione, l'eliminazione e la ricerca delle chiavi e dei relativi attributi. Include vari comandi, ognuno dei quali è descritto in dettaglio in questo argomento.
Per una guida rapida, vedi [Guida introduttiva a AWS CloudHSM key\$1mgmt\$1util](key_mgmt_util-getting-started.md). Per informazioni sull'interpretazione degli attributi chiave, vedi. [AWS CloudHSM riferimento agli attributi chiave per KMU](key-attribute-table.md) Per informazioni sullo strumento a riga di comando cloudhsm\$1mgmt\$1util, che include i comandi di gestione dell'HSM e degli utenti del cluster, vedi [AWS CloudHSM Utilità di gestione (CMU)](cloudhsm_mgmt_util.md).
Prima di eseguire un comando key\$1mgmt\$1util, devi avviare [key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [accedere](key_mgmt_util-log-in.md) a HSM come crypto user (CU).
Per elencare tutti i comandi key\$1mgmt\$1util, digita:
```
Command: help
```
Per ottenere assistenza su un determinato comando key\$1mgmt\$1util, digita:
```
Command: -h
```
Per terminare la sessione key\$1mgmt\$1util, digita:
```
Command: exit
```
I seguenti argomenti descrivono i comandi in key\$1mgmt\$1util.
**Nota**
Alcuni comandi in key\$1mgmt\$1util e cloudhsm\$1mgmt\$1util hanno lo stesso nome. Tuttavia, i comandi hanno in genere una sintassi diversa, un output diverso e funzionalità leggermente diverse.
| Comando | Description |
| --- | --- |
| [aesWrapUnwrap](key_mgmt_util-aesWrapUnwrap.md) | Consente di crittografare e decodificare i contenuti di una chiave in un file. |
| [EliminaChiave](key_mgmt_util-deleteKey.md) | Elimina una chiave da. HSMs |
| [StringaErrore2](key_mgmt_util-Error2String.md) | Consente di recuperare l'errore che corrisponde a un codice di errore esadecimale. |
| [Esci](key_mgmt_util-exit.md) | Esce da key\$1mgmt\$1util. |
| [exportPrivateKey](key_mgmt_util-exportPrivateKey.md) | Consente di esportare su un file su disco una copia di una chiave privata. |
| [exportPubKey](key_mgmt_util-exportPubKey.md) | Consente di esportare da un HSM su un file una copia di una chiave pubblica. |
| [exSymKey](key_mgmt_util-exSymKey.md) | Esporta una copia in testo semplice di una chiave simmetrica da a un file. HSMs |
| [extractMaskedObject](key_mgmt_util-extractMaskedObject.md) | Estrae una chiave da un HSM come un file oggetto nascosto. |
| [TrovaChiave](key_mgmt_util-findKey.md) | Consente di cercare le chiavi in base al valore dell'attributo della chiave. |
| [findSingleKey](key_mgmt_util-findSingleKey.md) | Verifica che esista una chiave su tutti i componenti del cluster. HSMs |
| [Gen DSAKey Pair](key_mgmt_util-genDSAKeyPair.md) | Genera una coppia di key pair DSA ([Digital Signing Algorithm](https://en.wikipedia.org/wiki/Digital_Signature_Algorithm)) nel tuo HSMs. |
| [coppia di geni ECCKey](key_mgmt_util-genECCKeyPair.md) | Genera una coppia di chiavi [Elliptic Curve Cryptography](https://en.wikipedia.org/wiki/Elliptic-curve_cryptography) (ECC) nel tuo. HSMs |
| [coppia di geni RSAKey](key_mgmt_util-genRSAKeyPair.md) | Genera una coppia di chiavi asimmetriche [RSA](https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29) nel tuo. HSMs |
| [genSymKey](key_mgmt_util-genSymKey.md) | Genera una chiave simmetrica nel tuo HSMs |
| [OttieniAttributo](key_mgmt_util-getAttribute.md) | Consente di recuperare i valori degli attributi di una chiave di AWS CloudHSM e li scrive in un file. |
| [getCaviumPrivChiave](key_mgmt_util-getCaviumPrivKey.md) | Crea una versione falsa in formato PEM di una chiave privata e la esporta in un file. |
| [OttieniCertificato](key_mgmt_util-getCert.md) | Consente di recuperare certificati di partizioni HSM e li salva in un file. |
| [getKeyInfo](key_mgmt_util-getKeyInfo.md) | Ottiene l'utente HSM IDs degli utenti che possono utilizzare la chiave. Se la chiave è controllata dal quorum, consente di recuperare il numero di utenti del quorum. |
| [help](key_mgmt_util-help.md) | Visualizza informazioni di aiuto sui comandi disponibili in key\$1mgmt\$1util. |
| [importPrivateKey](key_mgmt_util-importPrivateKey.md) | Importa una chiave privata in un HSM. |
| [importPubKey](key_mgmt_util-importPubKey.md) | Importa una chiave pubblica in un HSM. |
| [imSymKey](key_mgmt_util-imSymKey.md) | Consente di importare nell'HSM una copia in testo normale di una chiave simmetrica da un file. |
| [insertMaskedObject](key_mgmt_util-insertMaskedObject.md) | Inserisce un oggetto nascosto da un file su disco in un HSM contenuto nel cluster correlato al cluster di origine dell'oggetto. I cluster correlati sono qualsiasi cluster [generati da un backup del cluster di origine](create-cluster-from-backup.md). |
| [Convalida il file chiave utilizzando AWS CloudHSM KMU](key_mgmt_util-IsValidKeyHandlefile.md) | Determina se un determinato file contiene o meno una chiave privata reale o una chiave PEM di esempio. |
| [listAttributes](key_mgmt_util-listAttributes.md) | Elenca gli attributi di una AWS CloudHSM chiave e le costanti che li rappresentano. |
| [ElencaUtenti](key_mgmt_util-listUsers.md) | Ottiene gli utenti inclusi in HSMs, il tipo e l'ID utente e altri attributi. |
| [loginHSM e logoutHSM](key_mgmt_util-loginHSM.md) | Accedere e disconnettersi da un cluster. HSMs |
| [ImpostaAttributo](key_mgmt_util-setAttribute.md) | Consente di convertire una chiave di sessione in una chiave persistente. |
| [Firma](key_mgmt_util-sign.md) | Generare una firma per un file utilizzando una chiave privata scelta. |
| [unWrapKey](key_mgmt_util-unwrapKey.md) | Importa una chiave incapsulata (crittografata) da un file in. HSMs |
| [Verifica](key_mgmt_util-verify.md) | Verifica se una determinata chiave è stata utilizzata per firmare un determinato file. |
| [wrapChiave](key_mgmt_util-wrapKey.md) | Consente di esportare una copia crittografata di una chiave dai moduli HSM a un file. |
# Crittografa e decrittografa un AWS CloudHSM file usando KMU
Utilizzate il **aesWrapUnwrap** comando in AWS CloudHSM key\$1mgmt\$1util per crittografare o decrittografare il contenuto di un file su disco. Questo comando è concepito per eseguire e annullare il wrapping delle chiavi di crittografia, ma è possibile utilizzarlo su qualsiasi file che contenga meno di 4 KB (4096 byte) di dati.
**aesWrapUnwrap**utilizza AES Key Wrap con imbottitura PKCS \$15. Utilizza una chiave AES sull'HSM come chiave di wrapping o di annullamento del wrapping. Quindi scrive il risultato su un altro file su disco.
Prima di eseguire un comando key\$1mgmt\$1util, devi [avviare key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [accedere](key_mgmt_util-log-in.md) a HSM come crypto user (CU).
## Sintassi
```
aesWrapUnwrap -h
aesWrapUnwrap -m
-f
-w
[-i ]
[-out ]
```
## Esempi
Questi esempi mostrano come utilizzare **aesWrapUnwrap** per crittografare e decodificare una chiave di crittografia in un file.
**Example : eseguire il wrapping di una chiave di crittografia**
Questo comando utilizza **aesWrapUnwrap** per eseguire il wrapping di una chiave Triple DES simmetrica che è stata [esportata dall'HSM in testo normale](key_mgmt_util-exSymKey.md) nel file `3DES.key`. È possibile utilizzare un comando simile per eseguire il wrapping di qualsiasi chiave salvata in un file.
Il comando utilizza il parametro `-m` con il valore `1` per indicare la modalità di wrapping. Utilizza il parametro `-w` per specificare la chiave AES nell'HSM (handle della chiave `6`) come chiave di wrapping. Scrive la risultante chiave con wrapping nel file `3DES.key.wrapped`.
L'output indica che il comando ha avuto successo e che l'operazione ha utilizzato il valore IV predefinito, che è quello preferito.
```
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 : annullare il wrapping di una chiave di crittografia**
Questo esempio mostra come utilizzare **aesWrapUnwrap** per annullare il wrapping (decodificare) di una chiave con wrapping (crittografata) in un file. È possibile eseguire un'operazione come questa prima di importare una chiave sull'HSM. Ad esempio, se si tenta di utilizzare il [imSymKey](key_mgmt_util-imSymKey.md)comando per importare una chiave crittografata, viene restituito un errore perché la chiave crittografata non ha il formato richiesto per una chiave di testo semplice di quel tipo.
Il comando annulla il wrapping della chiave nel file `3DES.key.wrapped` e scrive il testo normare sul file `3DES.key.unwrapped`. Il comando utilizza il parametro `-m` con il valore `0` per indicare la modalità di annullamento del wrapping. Utilizza il parametro `-w` per specificare la chiave AES nell'HSM (handle della chiave `6`) come chiave di wrapping. Scrive la risultante chiave con wrapping nel file `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
```
## Parameters
**-h**
Visualizza l'aiuto per il comando.
Obbligatorio: sì
**-m**
Specifica la modalità. Per eseguire il wrapping (crittografare) il contenuto del file, digita `1`; per annullare il wrapping (decodificare) il contenuto del file, digita `0`.
Obbligatorio: sì
**-f**
Specifica il file su cui eseguire il wrapping. Inserisci un file che contiene meno di 4 KB (4096 byte) di dati. Questa operazione è stata progettata per eseguire e annullare il wrapping delle chiavi di crittografia.
Obbligatorio: sì
**-w**
Specifica la chiave di wrapping. Immetti l'handle di una chiave AES sull'HSM. Questo parametro è obbligatorio. Per trovare gli handle della chiave, utilizza il comando [findKey](key_mgmt_util-findKey.md).
Per creare una chiave di wrapping, usa [genSymKey](key_mgmt_util-genSymKey.md)per generare una chiave AES (tipo 31).
Obbligatorio: sì
**-i**
Specifica un valore iniziale (IV) alternativo per l'algoritmo. Utilizza il valore predefinito a meno che non si abbia una condizione speciale che richiede un'alternativa.
Default: `0xA6A6A6A6A6A6A6A6`. Il valore predefinito è stabilito nella specifica dell'algoritmo [Wrapping Chiave AES](https://tools.ietf.org/html/rfc3394).
Obbligatorio: no
**-output**
Specifica un nome alternativo per il file di output che contiene la chiave con o senza wrapping. Il valore predefinito è `wrapped_key` (per le operazioni di wrapping) e `unwrapped_key` (per le operazioni di annullamento del wrapping) nella directory locale.
Se il file esiste, il comando **aesWrapUnwrap** lo sovrascrive senza preavviso. Se il comando ha esito negativo, **aesWrapUnwrap** crea un file di output senza contenuto.
Impostazione predefinita: per il wrapping: `wrapped_key`; per l'annullamento del wrapping: `unwrapped_key`.
Obbligatorio: no
## Argomenti correlati
+ [exSymKey](key_mgmt_util-exSymKey.md)
+ [imSymKey](key_mgmt_util-imSymKey.md)
+ [unWrapKey](key_mgmt_util-unwrapKey.md)
+ [wrapKey](key_mgmt_util-wrapKey.md)
# Eliminare una AWS CloudHSM chiave usando KMU
Utilizzate il **deleteKey** comando contenuto in AWS CloudHSM key\$1mgmt\$1util per eliminare una chiave dal modulo di sicurezza hardware (HSM) in un cluster. AWS CloudHSM Puoi eliminare soltanto una chiave alla volta. L'eliminazione di una chiave di una coppia di chiavi non influisce sull'altra chiave della coppia.
Soltanto il proprietario della chiave può eliminarla. Gli utenti che condividono la chiave possono utilizzarla nelle operazioni di crittografia, ma non eliminarla.
Prima di eseguire un comando key\$1mgmt\$1util, devi [avviare key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [accedere](key_mgmt_util-log-in.md) all'HSM come crypto user (CU).
## Sintassi
```
deleteKey -h
deleteKey -k
```
## Esempi
Questi esempi mostrano come utilizzare per eliminare le chiavi dal tuo. **deleteKey** HSMs
**Example : eliminazione di una chiave**
Questo comando elimina la chiave con l'handle `6`. Se il comando ha esito positivo, **deleteKey** restituisce messaggi di operazione riuscita da ciascun HSM del 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 : eliminazione di una chiave (errore)**
Se il comando non riesce perché nessuna chiave dispone dell'handle specificato, **deleteKey** restituisce un messaggio di errore di handle in oggetto non valido.
```
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
```
Se il comando non riesce perché l'utente corrente non è il proprietario della chiave, il comando restituisce un errore di accesso negato.
```
Command: deleteKey -k 262152
Cfm3DeleteKey returned: 0xc6 : HSM Error: Key Access is denied.
```
## Parameters
**-h**
Visualizza il testo di aiuto per il comando.
Obbligatorio: sì
**-k**
Specifica l'handle della chiave da eliminare. Per cercare gli handle di chiave nell'HSM, utilizza [findKey](key_mgmt_util-findKey.md).
Campo obbligatorio: sì
## Argomenti correlati
+ [findKey](key_mgmt_util-findKey.md)
# Descrivi un AWS CloudHSM errore utilizzando KMU
Utilizzate il comando **Error2String** helper in key\$1mgmt\$1util per restituire l'errore che corrisponde a un codice di errore esadecimale AWS CloudHSM key\$1mgmt\$1util. Puoi usare questo comando per la risoluzione dei problemi di comandi e script.
Prima di eseguire un comando key\$1mgmt\$1util, devi [avviare key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [accedere](key_mgmt_util-log-in.md) all'HSM come crypto user (CU).
## Sintassi
```
Error2String -h
Error2String -r
```
## Esempi
Questi esempi mostrano come utilizzare **Error2String** per ottenere la stringa di errore per un codice di errore key\$1mgmt\$1util.
**Example : ottenere una descrizione dell'errore**
Questo comando ottiene la descrizione dell'errore per il codice di errore `0xdb`. La descrizione spiega che un tentativo di accedere a key\$1mgmt\$1util non è riuscito perché il tipo di utente è errato. Solo gli utenti crittografici (CU) possono accedere a key\$1mgmt\$1util.
```
Command: Error2String -r 0xdb
Error Code db maps to HSM Error: Invalid User Type.
```
**Example : trovare il codice di errore**
Questo esempio illustra dove trovare il codice di errore in un errore key\$1mgmt\$1util. Il codice di errore, `0xc6`, viene visualizzato dopo la stringa: `Cfm3 returned: `.
In questo esempio, [getKeyInfo](key_mgmt_util-getKeyInfo.md)indica che l'utente corrente (utente 4) può utilizzare la chiave nelle operazioni crittografiche. Tuttavia, quando l'utente cerca di utilizzare [deleteKey](key_mgmt_util-deleteKey.md) per eliminare la chiave, il comando restituisce il codice di errore `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 l'errore `0xc6` ti viene notificato, puoi utilizzare un comando **Error2String** come questo per individuare l'errore. In questo caso, il comando `deleteKey` ha avuto esito negativo causando un errore di accesso negato in quanto la chiave è condivisa con l'utente corrente, ma è di proprietà di un altro utente. Solo i proprietari delle chiavi dispongono dell'autorizzazione per eliminare una chiave.
```
Command: Error2String -r 0xa8
Error Code c6 maps to HSM Error: Key Access is denied
```
## Parameters
**-h**
Visualizza l'aiuto per il comando.
Obbligatorio: sì
**-r**
Specifica un codice di errore esadecimale. L'indicatore esadecimale `0x` è obbligatorio.
Obbligatorio: sì
# Uscire dalla AWS CloudHSM KMU
Utilizzate il **exit** comando in AWS CloudHSM key\$1mgmt\$1util per uscire da key\$1mgmt\$1util. Una volta completata la disconnessione, verrà di nuovo visualizzata la riga di comando standard.
Prima di eseguire qualsiasi comando key\$1mgmt\$1util, devi [avviare key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start).
## Sintassi
```
exit
```
## Parameters
Questo comando non ha parametri.
## Argomenti correlati
+ [Avvio di key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start)
# Esportazione di una AWS CloudHSM chiave privata tramite KMU
Utilizzate il **exportPrivateKey** comando in AWS CloudHSM key\$1mgmt\$1util per esportare una chiave privata asimmetrica da un modulo di sicurezza hardware (HSM) a un file. L'HSM non consente l'esportazione diretta di chiavi in chiaro. Il comando esegue il wrapping della chiave privata utilizzando una chiave di wrapping AES specificata dall'utente, decodifica i byte soggetti a wrapping e copia la chiave privata in chiaro in un file.
Tuttavia, il comando **exportPrivateKey** non rimuove la chiave da HSM, non ne modifica gli [attributi della chiave](key-attribute-table.md) oppure impedisce di utilizzare la chiave in altre operazioni di crittografia. È possibile esportare la stessa chiave più volte.
È possibile esportare solo le chiavi private che hanno il valore dell'attributo `OBJ_ATTR_EXTRACTABLE` impostato su `1`. È necessario specificare una chiave di wrapping AES con un valore di attributo `1` `OBJ_ATTR_WRAP` e `OBJ_ATTR_DECRYPT`. Per trovare gli attributi della chiave, utilizza il comando [**getAttribute**](key_mgmt_util-getAttribute.md).
Prima di eseguire un comando key\$1mgmt\$1util, devi [avviare key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [accedere](key_mgmt_util-log-in.md) a HSM come crypto user (CU).
## Sintassi
```
exportPrivateKey -h
exportPrivateKey -k
-w
-out
[-m ]
[-wk ]
```
## Esempi
Questo esempio illustra come utilizzare **exportPrivateKey** per esportare una chiave privata da un HSM.
**Example : Esporta una chiave privata**
Questo comando esporta una chiave privata con handle `15` utilizzando una chiave di wrapping con handle `16` per un file PEM chiamato `exportKey.pem`. Se il comando ha esito positivo, **exportPrivateKey** restituisce un messaggio di operazione riuscita.
```
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
```
## Parameters
Questo comando accetta i parametri seguenti.
**`-h`**
Visualizza il testo di aiuto per il comando.
Obbligatorio: sì
**`-k`**
Specifica l'handle della chiave privata da esportare.
Obbligatorio: sì
**`-w`**
Specifica l'handle di una chiave di wrapping. Questo parametro è obbligatorio. Per trovare le handle della chiave, utilizza il comando [**findKey**](key_mgmt_util-findKey.md).
Per determinare se una chiave può essere utilizzata come chiave di wrapping, utilizzare [**getAttribute**](key_mgmt_util-getAttribute.md) per ottenere il valore dell'attributo `OBJ_ATTR_WRAP` (262). Per creare una chiave di wrapping, utilizza [**genSymKey**](key_mgmt_util-genSymKey.md) per creare una chiave AES (tipo 31).
Se si utilizza il parametro `-wk` per specificare una chiave di annullamento del wrapping esterna, la chiave di wrapping `-w` viene utilizzata per eseguire il wrapping della chiave durante l'esportazione, ma non per annullarlo.
Obbligatorio: sì
**`-out`**
Consente di specificare il nome del file in cui verrà scritta la chiave privata esportata.
Obbligatorio: sì
**`-m`**
Specifica il meccanismo di wrapping della chiave privata in fase di esportazione. L'unico valore valido è `4`, che rappresenta il `NIST_AES_WRAP mechanism.`
Default: 4 (`NIST_AES_WRAP`)
Obbligatorio: no
**`-wk`**
Specifica la chiave da utilizzare per eseguire l'annullamento del wrapping della chiave esportata. Inserire il percorso e il nome di un file che contiene una chiave AES non crittografata.
Quando includi questo parametro. **exportPrivateKey** utilizza la chiave nel file `-w` per eseguire il wrapping della chiave esportata e utilizza la chiave specificata dal parametro `-wk` per annullarlo.
Impostazione predefinita: Utilizza il codice di wrapping specificato nel parametro `-w` per eseguire il wrapping e per annullarlo.
Obbligatorio: no
## Argomenti correlati
+ [importPrivateKey](key_mgmt_util-importPrivateKey.md)
+ [wrapKey](key_mgmt_util-wrapKey.md)
+ [unWrapKey](key_mgmt_util-unwrapKey.md)
+ [genSymKey](key_mgmt_util-genSymKey.md)
# Esporta una AWS CloudHSM chiave pubblica usando KMU
Utilizzate il **exportPubKey** comando in AWS CloudHSM key\$1mgmt\$1util per esportare una chiave pubblica in un HSM in un file. È possibile utilizzarlo per esportare le chiavi pubbliche che generi su un HSM. È inoltre possibile utilizzare questo comando per esportare le chiavi pubbliche importate in un HSM, ad esempio quelle importate tramite il comando **[**importPubKey**](key_mgmt_util-importPubKey.md)**.
L'operazione **exportPubKey** copia il materiale della chiave su un file specificato. Tuttavia, non rimuove la chiave dall'HSM, non ne modifica gli [attributi](key-attribute-table.md) e neppure impedisce di utilizzare la chiave in altre operazioni di crittografia. È possibile esportare la stessa chiave più volte.
È possibile esportare solo le chiavi pubbliche che hanno il valore `OBJ_ATTR_EXTRACTABLE` pari a `1`. Per trovare gli attributi della chiave, utilizza il comando **[getAttribute](key_mgmt_util-getAttribute.md)**.
Prima di eseguire un comando `key_mgmt_util`, devi [avviare key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [accedere](key_mgmt_util-log-in.md) a HSM come crypto user (CU).
## Sintassi
```
exportPubKey -h
exportPubKey -k
-out
```
## Esempi
Questo esempio illustra come utilizzare **exportPubKey** per esportare una chiave pubblica da un HSM.
**Example : Esporta una chiave pubblica**
Questo comando esporta una chiave pubblica con handle `10` su un file denominato `public.pem`. Se il comando ha esito positivo, **exportPubKey** restituisce un messaggio di operazione riuscita.
```
Command: exportPubKey -k 10 -out public.pem
PEM formatted public key is written to public.pem
Cfm3ExportPubKey returned: 0x00 : HSM Return: SUCCESS
```
## Parameters
Questo comando accetta i parametri seguenti.
**`-h`**
Visualizza il testo di aiuto per il comando.
Obbligatorio: sì
**`-k`**
Specifica l'handle della chiave pubblica da esportare.
Obbligatorio: sì
**`-out`**
Specifica il nome del file in cui verrà scritta la chiave pubblica esportata.
Campo obbligatorio: sì
## Argomenti correlati
+ [importPubKey](key_mgmt_util-importPubKey.md)
+ [Genera Chiavi](generate-keys.md)
# Esporta una copia in testo semplice di una AWS CloudHSM chiave usando KMU
Utilizzate il **exSymKey** comando dello strumento AWS CloudHSM key\$1mgmt\$1util per esportare una copia in testo semplice di una chiave simmetrica dal modulo di sicurezza hardware (HSM) e salvarla in un file su disco. Per esportare una copia crittografata (su cui è stato eseguito il wrapping) di una chiave, usa [wrapKey](key_mgmt_util-wrapKey.md). Per importare una chiave in testo semplice, come quelle che esporta, usa. `exSymKey` [imSymKey](key_mgmt_util-imSymKey.md)
Durante il processo di esportazione, il comando **exSymKey** utilizza una chiave AES specificata (la *chiave di wrapping*) per effettuare il *wrapping* (crittografia) e quindi *annullare il wrapping* (decodifica) della chiave da esportare. Tuttavia, il risultato dell'operazione di esportazione è una chiave di testo non crittografato (*su cui è stato annullato il wrapping*) su disco.
Soltanto il proprietario della chiave, ovvero l'utente CU che ha creato la chiave, è in grado di esportarla. Gli utenti che condividono la chiave possono utilizzarla nelle operazioni di crittografia, ma non possono esportarla.
L'operazione **exSymKey** copia il materiale della chiave su un file specificato, ma non rimuove la chiave dall'HSM, non ne modifica gli [attributi](key-attribute-table.md), né impedisce l'utilizzo della chiave nelle operazioni di crittografia. È possibile esportare la stessa chiave più volte.
**exSymKey** esporta solo le chiavi simmetriche. Per esportare le chiavi pubbliche, utilizzare [exportPubKey](key_mgmt_util-exportPubKey.md). Per esportare le chiavi private, utilizzare [exportPrivateKey](key_mgmt_util-exportPrivateKey.md).
Prima di eseguire un comando key\$1mgmt\$1util, devi [avviare key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [accedere](key_mgmt_util-log-in.md) a HSM come crypto user (CU).
## Sintassi
```
exSymKey -h
exSymKey -k
-w
-out
[-m 4]
[-wk ]
```
## Esempi
Questi esempi mostrano come utilizzare per **exSymKey** esportare le chiavi simmetriche che possiedi dal tuo. HSMs
**Example : esportazione di una chiave simmetrica 3DES**
Questo comando esporta una chiave simmetrica Triple DES (3DES) (handle chiave `7`). Utilizza una chiave AES esistente (handle chiave `6`) sull'HSM come chiave di wrapping. Quindi scrive il testo non crittografato della chiave 3DES sul file `3DES.key`.
L'output indica che la chiave `7` (la chiave 3DES) è stata sottoposta a wrapping e all'annullamento del wrapping e che è stata scritta sul file `3DES.key`.
Anche se l'output dice che una "Chiave simmetrica wrapped" è stata scritta sul file di output, il file di output contiene una chiave di testo non crittografata (unwrapped).
```
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 : esportazione con una chiave di wrapping solo per la sessione**
Questo esempio illustra come utilizzare una chiave che esiste solo nella sessione come chiave di wrapping. Poiché sulla chiave da esportare è stato eseguito il wrapping che è poi stato immediatamente annullato ed è stata distribuita come testo non crittografato, non è necessario conservare la chiave di wrapping.
Questa serie di comandi esporta dall'HSM una chiave AES con handle di chiave `8`. Utilizza una chiave di sessione AES creata specificatamente per questo scopo.
Il primo comando consente di [genSymKey](key_mgmt_util-genSymKey.md)creare una chiave AES a 256 bit. Utilizza il parametro `-sess` per creare una chiave che esiste solo nella sessione corrente.
L'output indica che l'HSM crea la chiave `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
```
Quindi, l'esempio verifica che la chiave `8`, la chiave da esportare, sia una chiave simmetrica estraibile. Inoltre verifica che la chiave di wrapping, la chiave `262168`, sia una chiave AES che esiste solo nella sessione. È possibile utilizzare il comando [findKey](key_mgmt_util-findKey.md), ma questo esempio esporta gli attributi di entrambe le chiavi su file e utilizza `grep` per trovare i valori di attributo rilevanti nel file.
Questi comandi utilizzano `getAttribute` con un valore `-a` di `512` (tutti) per ottenere tutti gli attributi per le chiavi `8` e `262168`. Per ulteriori informazioni sugli attributi delle chiavi, vedi [AWS CloudHSM riferimento agli attributi chiave per KMU](key-attribute-table.md).
```
getAttribute -o 8 -a 512 -out attributes/attr_8
getAttribute -o 262168 -a 512 -out attributes/attr_262168
```
Questi comandi utilizzano `grep` per verificare gli attributi della chiave da esportare (chiave `8`) e la chiave di wrapping valida solo per la sessione (chiave `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
```
Infine, utilizziamo un comando **exSymKey** per esportare la chiave `8` utilizzando la chiave di sessione (chiave `262168`) come chiave di wrapping.
Quando la sessione scade, la chiave `262168` non è più disponibile.
```
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 : utilizzo di una chiave di wrapping esterna**
Questo esempio illustra come utilizzare una chiave di wrapping esterna per esportare una chiave dall'HSM.
Quando si esegue l'esportazione di una chiave dall'HSM, è necessario specificare una chiave AES nell'HSM che funga da chiave di wrapping. Per impostazione predefinita, la chiave di wrapping viene utilizzata per eseguire e annullare il wrapping della chiave da esportare. Tuttavia, è possibile utilizzare il parametro `-wk` per ordinare a **exSymKey** di utilizzare una chiave esterna in un file su disco per annullare il wrapping. Quando si esegue questa operazione, la chiave specificata dal parametro `-w` effettua il wrapping della chiave di destinazione e la chiave nel file specificata dal parametro `-wk` annulla il wrapping della chiave.
Poiché la chiave di wrapping deve essere una chiave AES, ovvero una chiave simmetrica, la chiave di wrapping nell'HSM e la chiave di unwrapping su disco devono avere lo stesso materiale chiave. Per eseguire questa operazione, è necessario importare la chiave di wrapping sull'HSM o esportare la chiave di wrapping dall'HSM prima dell'operazione di esportazione.
Questo esempio crea una chiave al di fuori dell'HSM e la importa nell'HSM. Utilizza la copia interna della chiave per effettuare il wrapping di una chiave simmetrica esportata e la copia della chiave nel file per annullare il wrapping.
Il primo comando utilizza OpenSSL per generare una chiave AES a 256 bit. Memorizza la chiave sul file `aes256-forImport.key`. Il comando OpenSSL non restituisce alcun output, ma è possibile utilizzare diversi comandi per confermare che l'operazione sia avvenuta con successo. Questo esempio utilizza lo strumento **wc** (conteggio delle parole), che conferma che il file contiene 32 byte di dati.
```
$ openssl rand -out keys/aes256-forImport.key 32
$ wc keys/aes256-forImport.key
0 2 32 keys/aes256-forImport.key
```
Questo comando utilizza il comando [imSymKey](key_mgmt_util-imSymKey.md) per importare la chiave AES dal file `aes256-forImport.key` all'HSM. Quando il comando viene completato, la chiave esiste nell'HSM con handle `262167` e nel file `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
```
Questo comando utilizza la chiave in un'operazione di esportazione. Il comando utilizza **exSymKey** per esportare la chiave `21`, una chiave AES a 192 bit. Per effettuare il wrapping della chiave, utilizza la chiave `262167`, che è la copia importata nell'HSM. Per annullare il wrapping della chiave, utilizza lo stesso materiale chiave nel file `aes256-forImport.key`. Quando il comando viene completato, la chiave `21` viene esportata sul file `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"
```
## Parameters
**-h**
Visualizza l'aiuto per il comando.
Obbligatorio: sì
**-k**
Specifica l'handle della chiave da esportare. Questo parametro è obbligatorio. Specifica l'handle della chiave simmetrica posseduta. Questo parametro è obbligatorio. Per trovare gli handle della chiave, utilizza il comando [findKey](key_mgmt_util-findKey.md).
Per verificare che una chiave possa essere esportata, utilizza il comando [getAttribute](key_mgmt_util-getAttribute.md) per ottenere il valore dell'attributo `OBJ_ATTR_EXTRACTABLE`, che è rappresentato dalla costante `354`. Inoltre, puoi esportare solo le chiavi di tua proprietà. Per trovare il proprietario di una chiave, usa il [getKeyInfo](key_mgmt_util-getKeyInfo.md)comando.
Obbligatorio: sì
**-w**
Specifica l'handle di una chiave di wrapping. Questo parametro è obbligatorio. Per trovare gli handle della chiave, utilizza il comando [findKey](key_mgmt_util-findKey.md).
Una *chiave di wrapping* è una chiave nell'HSM che viene utilizzata per crittografare (eseguire il wrapping) e quindi decodificare (annullare il wrapping) della chiave da esportare. Solo le chiavi AES possono essere utilizzate come chiavi di wrapping.
Puoi usare qualsiasi chiave AES (di qualsiasi dimensione) come chiave di wrapping. Poiché la chiave di wrapping effettua e quindi annulla immediatamente il wrapping della chiave di destinazione, puoi utilizzare una chiave AES valida solo per la sessione come chiave di wrapping. Per determinare se una chiave può essere usata come chiave di wrapping, utilizza [getAttribute](key_mgmt_util-getAttribute.md) per ottenere il valore dell'attributo `OBJ_ATTR_WRAP`, che è rappresentato dalla costante `262`. Per creare una chiave di wrapping, utilizza [genSymKey](key_mgmt_util-genSymKey.md) per creare una chiave AES (tipo 31).
Se utilizzi il parametro `-wk` per specificare una chiave di unwrapping esterna, la chiave di wrapping `-w` viene utilizzata per eseguire il wrapping della chiave durante l'esportazione, ma non per annullarlo.
La chiave 4 rappresenta una chiave interna non supportata. Ti consigliamo di utilizzare una chiave AES che crei e gestisci come chiave di wrapping.
Obbligatorio: sì
**-output**
Specifica il percorso e il nome del file di output. Quando il comando viene completato, questo file contiene la chiave esportata in testo non crittografato. Se il file già esiste, il comando lo sovrascrive senza preavviso.
Obbligatorio: sì
**-m**
Specifica il meccanismo di wrapping. L'unico valore valido è `4`, che rappresenta il meccanismo `NIST_AES_WRAP`.
Obbligatorio: no
Impostazione predefinita: 4
**-wk**
Utilizza la chiave AES nel file specificato per annullare il wrapping della chiave esportata. Inserire il percorso e il nome di un file che contiene una chiave AES non crittografata.
Quando includi questo parametro. `exSymKey` utilizza la chiave nell'HSM specificata dal parametro `-w` per eseguire il wrapping della chiave esportata e utilizza la chiave nel file `-wk` per annullarne il wrapping. I valori di parametro `-w` e `-wk` devono determinare la stessa chiave non crittografata.
Obbligatorio: no
Impostazione predefinita: utilizzo della chiave di wrapping sull'HSM per annullare il wrapping.
## Argomenti correlati
+ [genSymKey](key_mgmt_util-genSymKey.md)
+ [imSymKey](key_mgmt_util-imSymKey.md)
+ [wrapKey](key_mgmt_util-wrapKey.md)
# Estrai una AWS CloudHSM chiave usando KMU
Utilizzate il **extractMaskedObject** comando in AWS CloudHSM key\$1mgmt\$1util per estrarre una chiave da un modulo di sicurezza hardware (HSM) e salvarla in un file come oggetto mascherato. Gli oggetti nascosti sono oggetti *clonati* che possono essere utilizzati solo dopo averli inseriti nuovamente nel cluster originale utilizzando il comando **[insertMaskedObject](key_mgmt_util-insertMaskedObject.md)**. È possibile inserire solo un oggetto mascherato nello stesso cluster da cui è stato generato, o un clone dello stesso cluster. Questo include qualsiasi versione clonata del cluster generata dalla [copia di un backup tra le regioni](copy-backup-to-region.md) e [utilizzando tale backup per creare un nuovo cluster](create-cluster-from-backup.md).
Gli oggetti mascherati sono un modo efficiente per scaricare e sincronizzare le chiavi, incluse cui le chiavi nonestraibili (ovvero chiavi che hanno un valore [`OBJ_ATTR_EXTRACTABLE`](key-attribute-table.md) di `0`). [In questo modo, le chiavi possono essere sincronizzate in modo sicuro tra cluster correlati in diverse regioni senza la necessità di aggiornare il file di configurazione. AWS CloudHSM](configure-tool.md)
**Importante**
Dopo l'inserimento, gli oggetti mascherati vengono decodificati e viene loro affidato un handle diverso dall'handle della chiave originale. Un oggetto mascherato include tutti i metadati associati alla chiave originale, tra cui attributi, proprietà e informazioni di condivisione, nonché le impostazioni del quorum. Se è necessario sincronizzare le chiavi tra i cluster in un'applicazione, utilizzare invece [syncKey](cloudhsm_mgmt_util-syncKey.md) in the cloudhsm\$1mgmt\$1util.
Prima di eseguire qualsiasi comando è necessario [avviare key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [accedere](key_mgmt_util-log-in.md) al modulo HSM. Il comando **extractMaskedObject** può essere utilizzato dal CU che possiede la chiave o qualsiasi CO.
## Sintassi
```
extractMaskedObject -h
extractMaskedObject -o
-out
```
## Esempi
Questo esempio illustra come utilizzare **extractMaskedObject** per estrarre una chiave da un HSM come oggetto mascherato.
**Example : Estrazione di un oggetto mascherato**
Questo comando consente di estrarre un oggetto mascherato da un HSM di una chiave con handle `524295` e salvarlo come un file chiamato `maskedObj`. Se il comando ha esito positivo, **extractMaskedObject** restituisce un messaggio di operazione riuscita.
```
Command: extractMaskedObject -o 524295 -out maskedObj
Object was masked and written to file "maskedObj"
Cfm3ExtractMaskedObject returned: 0x00 : HSM Return: SUCCESS
```
## Parameters
Questo comando accetta i parametri seguenti.
**`-h`**
Visualizza il testo di aiuto per il comando.
Obbligatorio: sì
**`-o`**
Specifica l'handle della chiave da estrarre come oggetto mascherato.
Obbligatorio: sì
**`-out`**
Consente di specificare il nome del file in cui l'oggetto mascherato verrà salvato.
Campo obbligatorio: sì
## Argomenti correlati
+ [insertMaskedObject](key_mgmt_util-insertMaskedObject.md)
+ [syncKey](cloudhsm_mgmt_util-syncKey.md)
+ [Copiare un backup tra regioni](copy-backup-to-region.md)
+ [Creazione di un AWS CloudHSM cluster da un backup precedente](create-cluster-from-backup.md)
# Cerca AWS CloudHSM le chiavi per attributi usando KMU
Utilizzate il **findKey** comando in AWS CloudHSM key\$1mgmt\$1util per cercare le chiavi in base ai valori degli attributi chiave. Quando un chiave soddisfa tutti i criteri impostati, **findKey** restituisce l'handle della chiave. Senza parametri, **findKey** restituisce gli handle della chiave di tutte le chiavi utilizzabili nell'HSM. Per trovare i valori degli attributi di una determinata chiave, utilizzare [getAttribute](key_mgmt_util-getAttribute.md).
Come tutti i comandi key\$1mgmt\$1util, **findKey** è specifico per l'utente. Restituisce solo le chiavi che l'utente corrente può utilizzare nelle operazioni di crittografia. Ciò include le chiavi che l'utente corrente possiede e le chiavi che sono state condivise con l'utente corrente.
Prima di eseguire un comando key\$1mgmt\$1util, devi [avviare](key_mgmt_util-setup.md#key_mgmt_util-start) key\$1mgmt\$1util e [accedere](key_mgmt_util-log-in.md) a HSM come crypto user (CU).
## Sintassi
```
findKey -h
findKey [-c ]
[-t ]
[-l ]
[-id ]
[-sess (0 | 1)]
[-u ]
[-m ]
[-kcv ]
```
## Esempi
Questi esempi mostrano come utilizzare per trovare e identificare le chiavi **findKey** nel tuo. HSMs
**Example : trovare tutte le chiavi**
Questo comando trova tutte le chiavi per l'utente corrente nell'HSM. L'output include le chiavi che l'utente possiede e condivide e tutte le chiavi pubbliche in HSMs.
Per ottenere gli attributi di una chiave con un determinato handle della chiave, utilizzare [getAttribute](key_mgmt_util-getAttribute.md). Per determinare se l'utente corrente possiede o condivide una particolare chiave, usa [getKeyInfo](key_mgmt_util-getKeyInfo.md)o [findAllKeys](cloudhsm_mgmt_util-findAllKeys.md)in 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 : trovare le chiavi per tipo, utente e sessione**
Questo comando trova le chiavi AES persistenti che l'utente corrente e l'utente 3 possono utilizzare (l'utente 3 potrebbe essere in grado di utilizzare altre chiavi che l'utente corrente non può visualizzare).
```
Command: findKey -t 31 -sess 0 -u 3
```
**Example : trovare chiavi per classe ed etichetta**
Questo comando trova tutte le chiavi pubbliche per l'utente corrente con l'etichetta `2018-sept`.
```
Command: findKey -c 2 -l 2018-sept
```
**Example : trovare le chiavi RSA per modulo**
Questo comando trova le chiavi RSA (tipo 0) per l'utente corrente, create utilizzando il modulo nel file `m4.txt`.
```
Command: findKey -t 0 -m m4.txt
```
## Parameters
**-h**
Visualizza l'aiuto per il comando.
Obbligatorio: sì
**-t**
Trova le chiavi del tipo specificato. Inserire la costante che rappresenta la classe della chiave. Ad esempio, per trovare le chiavi 3DES, digitare `-t 21`.
Valori validi:
+ 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)
Obbligatorio: no
**-c**
Trova le chiavi nella classe specificata. Inserire la costante che rappresenta la classe della chiave. Ad esempio, per trovare le chiavi pubbliche, digitare `-c 2`.
Valori validi per ogni tipo di chiave:
+ 2: pubblica. Questa classe contiene le chiavi pubbliche delle coppie di chiavi pubbliche-private.
+ 3: privata. Questa classe contiene le chiavi private delle coppie di chiavi pubbliche-private.
+ 4: segreta. Questa classe contiene tutte le chiavi simmetriche.
Obbligatorio: no
**-l**
Trova le chiavi con l'etichetta specificata. Digitare l'etichetta esatta. Non è possibile utilizzare caratteri jolly o espressioni regolari nel valore `--l`.
Obbligatorio: no
**-id**
Trova la chiavi con l'ID specificato. Digitare la stringa ID esatta. Non è possibile utilizzare caratteri jolly o espressioni regolari nel valore `-id`.
Obbligatorio: no
**-sessione**
Trova le chiavi per stato della sessione. Per trovare le chiavi che sono valide solo nella sessione corrente, digitare `1`. Per trovare le chiavi persistenti, digitare `0`.
Obbligatorio: no
**-u**
Trova le chiavi che gli utenti specificati e l'utente corrente condividono. Digitare un elenco separato da virgole di utenti HSM IDs, ad esempio o. `-u 3` `-u 4,7` Per trovare il numero IDs di utenti su un HSM, usa [ListUsers](key_mgmt_util-listUsers.md).
Quando si specifica un ID utente, **findKey** restituisce le chiavi per quell'utente. Quando si specificano più utenti IDs, **findKey** restituisce le chiavi che tutti gli utenti specificati possono utilizzare.
Poiché **findKey** restituisce solo le chiavi che l'utente corrente può utilizzare, i risultati `-u` sono sempre identici alle chiavi dell'utente corrente o un sottoinsieme di queste. Per ottenere tutte le chiavi possedute o condivise con qualsiasi utente, i funzionari di crittografia (COs) possono utilizzare [findAllKeys](cloudhsm_mgmt_util-findAllKeys.md)in cloudhsm\$1mgmt\$1util.
Obbligatorio: no
**-m**
Trova le chiavi create utilizzando il modulo RSA nel file specificato. Digitare il percorso del file che archivia il modulo.
-m specifica il file binario contenente il modulo RSA da associare (opzionale).
Obbligatorio: no
**-kcv**
Trova le chiavi con il valore di controllo della chiave specificato.
Il *valore di controllo chiave* (KCV) è un hash o checksum a 3 byte di una chiave che viene generato quando l'HSM importa o genera una chiave. Puoi anche calcolare un KCV al di fuori dell'HSM, ad esempio dopo aver esportato una chiave. È quindi possibile confrontare i valori KCV per confermare l'identità e l'integrità della chiave. Per ottenere il KCV di una chiave, usa [getAttribute](key_mgmt_util-getAttribute.md).
AWS CloudHSM utilizza il seguente metodo standard per generare un valore di controllo della chiave:
+ **Chiavi simmetriche**: primi 3 byte del risultato della crittografia a blocchi zero con la chiave.
+ **Coppie di chiavi asimmetriche**: primi 3 byte dell'hash SHA-1 della chiave pubblica.
+ **Chiavi HMAC**: KCV per le chiavi HMAC attualmente non supportato.
Obbligatorio: no
## Output
L'output **findKey** elenca il numero totale di chiavi corrispondenti e i relativi handle della chiave.
```
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
```
## Argomenti correlati
+ [findSingleKey](key_mgmt_util-findSingleKey.md)
+ [getKeyInfo](key_mgmt_util-getKeyInfo.md)
+ [OttieniAttributo](key_mgmt_util-getAttribute.md)
+ [findAllKeys](cloudhsm_mgmt_util-findAllKeys.md)in cloudhsm\$1mgmt\$1util
+ [Riferimento per l'attributo della chiave](key-attribute-table.md)
# Verifica una AWS CloudHSM chiave usando KMU
Utilizzate il **findSingleKey** comando nello strumento AWS CloudHSM key\$1mgmt\$1util per verificare che esista una chiave su tutti i moduli di sicurezza hardware (HSM) del cluster. AWS CloudHSM
Prima di eseguire un comando key\$1mgmt\$1util, devi [avviare key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [accedere](key_mgmt_util-log-in.md) a HSM come crypto user (CU).
## Sintassi
```
findSingleKey -h
findSingleKey -k
```
## Esempio
**Example**
Questo comando verifica che la chiave `252136` esista su tutti e tre i componenti del cluster. HSMs
```
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
```
## Parameters
**-h**
Visualizza l'aiuto per il comando.
Obbligatorio: sì
**-k**
Specifica l'handle di una chiave nel modulo HSM. Questo parametro è obbligatorio.
Per trovare gli handle della chiave, utilizza il comando [findKey](key_mgmt_util-listUsers.md).
Campo obbligatorio: sì
## Argomenti correlati
+ [findKey](key_mgmt_util-listUsers.md)
+ [getKeyInfo](key_mgmt_util-listUsers.md)
+ [getAttribute](key_mgmt_util-findKey.md)
# Genera una coppia di key pair AWS CloudHSM DSA usando KMU
Utilizzate il **genDSAKeyPair** comando nello strumento AWS CloudHSM key\$1mgmt\$1util per generare una coppia di chiavi [DSA (Digital Signing Algorithm](https://en.wikipedia.org/wiki/Digital_Signature_Algorithm)) nei moduli di sicurezza hardware (HSM). Devi specificare la lunghezza del modulo; il comando genera il valore del modulo. Puoi anche assegnare un ID, condividere la chiave con altri utenti HSM, creare chiavi non estraibili e chiavi che scadono al termine della sessione. Quando il comando viene eseguito correttamente, restituisce l'*handle della chiave* che l'HSM assegna alle chiavi pubbliche e private. Puoi utilizzare gli handle per identificare le chiavi per altri comandi.
Prima di eseguire un comando key\$1mgmt\$1util, devi [avviare key\$1mgmt\$1util](key_mgmt_util-setup.md#key_mgmt_util-start) e [accedere](key_mgmt_util-log-in.md) all'HSM come crypto user (CU).
**Suggerimento**
Per trovare gli attributi di una chiave che hai creato, ad esempio tipo, lunghezza, etichetta e ID, usa [getAttribute](key_mgmt_util-getAttribute.md). Per trovare le chiavi per un determinato utente, usa. [getKeyInfo](key_mgmt_util-getKeyInfo.md) Per trovare le chiavi in base ai valori degli attributi, usa [findKey](key_mgmt_util-findKey.md).
## Sintassi
```
genDSAKeyPair -h
genDSAKeyPair -m
-l