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à.
# Utilizzo di Client SDK 5 con cui lavorare AWS CloudHSM
AWS CloudHSM include due versioni principali di Client SDK:
+ Client SDK 5: questo è il nostro Client SDK più recente e quello predefinito. Per informazioni sui benefici e i vantaggi che offre, vedi [Vantaggi di AWS CloudHSM Client SDK 5](client-sdk-5-benefits.md).
+ Client SDK 3: Questo è il nostro vecchio Client SDK. Include un set completo di componenti per la compatibilità delle applicazioni basate su piattaforme e linguaggi e strumenti di gestione.
Per istruzioni sulla migrazione da Client SDK 3 a Client SDK 5, consulta. [Migrazione da AWS CloudHSM Client SDK 3 a Client SDK 5](client-sdk-migration.md)
Questo argomento descrive Client SDK 5. Per verificare quale versione di Client SDK stai utilizzando, vedi
**Topics**
+ [Vantaggi di AWS CloudHSM Client SDK 5](client-sdk-5-benefits.md)
+ [AWS CloudHSM Piattaforme supportate da Client SDK 5](client-supported-platforms.md)
+ [Libreria PKCS \$111 per AWS CloudHSM Client SDK 5](pkcs11-library.md)
+ [AWS CloudHSM Motore dinamico OpenSSL per Client SDK 5](openssl-library.md)
+ [Provider AWS CloudHSM OpenSSL per Client SDK 5](openssl-provider-library.md)
+ [Provider di archiviazione delle chiavi (KSP) per AWS CloudHSM Client SDK 5](ksp-library.md)
+ [Provider JCE per AWS CloudHSM Client SDK 5](java-library.md)
# Vantaggi di AWS CloudHSM Client SDK 5
Rispetto a AWS CloudHSM Client SDK 3, Client SDK 5 è più facile da gestire, offre una configurabilità superiore e una maggiore affidabilità. Il Client SDK 5 offre inoltre alcuni vantaggi chiave aggiuntivi al Client SDK 3.
**Progettato per l'architettura serverless**
Il Client SDK 5 non richiede un client daemon, quindi devi più gestire un servizio in background. Questo aiuta gli utenti in alcuni modi importanti:
+ Semplifica il processo di avvio dell'applicazione. Tutto ciò che devi fare per iniziare a usare CloudHSM è configurare l'SDK prima di eseguire l'applicazione.
+ Non è necessario un processo in esecuzione costante, il che semplifica l'integrazione con componenti serverless come Lambda ed Elastic Container Service (ECS).
**Integrazioni migliori con terze parti e portabilità semplificata**
Il Client SDK 5 segue da vicino le specifiche JCE e offre una portabilità più semplice tra diversi provider JCE e integrazioni migliori con terze parti
**Esperienza utente e configurabilità migliorate**
Il Client SDK 5 migliora la leggibilità dei messaggi di log e fornisce eccezioni e meccanismi di gestione degli errori più chiari, il che semplifica notevolmente l'autodiagnostica per gli utenti. SDK 5 offre anche una varietà di configurazioni, elencate nella [pagina Configurazione dello strumento.](https://docs.aws.amazon.com/cloudhsm/latest/userguide/configure-sdk-5.html)
**Supporto più ampio per la piattaforma**
Il Client SDK 5 offre un maggiore supporto per le moderne piattaforme operative. Ciò include il supporto per le tecnologie ARM e un maggiore supporto per [JCE](https://docs.aws.amazon.com/cloudhsm/latest/userguide/java-library_5.html), [PKCS \$111](https://docs.aws.amazon.com/cloudhsm/latest/userguide/pkcs11-library.html) e [OpenSSL.](https://docs.aws.amazon.com/cloudhsm/latest/userguide/openssl-library.html) [Per ulteriori informazioni, consulta Piattaforme supportate.](client-supported-platforms.md)
**IPv6 supporto per la connessione**
Client SDK 5.14\$1 supporta connessioni a dual-stack utilizzando. HSMs IPv6
**Funzionalità e meccanismi aggiuntivi**
Il Client SDK 5 include funzionalità e meccanismi aggiuntivi che non sono disponibili nel Client SDK 3 e il Client SDK 5 continuerà ad aggiungere altri meccanismi in futuro.
# AWS CloudHSM Piattaforme supportate da Client SDK 5
Il supporto AWS CloudHSM di base è diverso per ogni versione di Client SDK. Il supporto della piattaforma per i componenti di un SDK in genere corrisponde al supporto di base, ma non sempre. Per determinare il supporto della piattaforma per un determinato componente, assicurati innanzitutto che la piattaforma desiderata compaia nella sezione base dell'SDK, quindi controlla eventuali esclusioni o altre informazioni pertinenti nella sezione del componente.
AWS CloudHSM supporta solo sistemi operativi a 64 bit.
Le piattaforme supportate cambiano nel tempo. Le versioni precedenti del CloudHSM Client SDK potrebbero non supportare tutti i sistemi operativi elencati qui. Verifica se il sistema operativo supporta le versioni precedenti del Client SDK di CloudHSM consultando le note di rilascio. Per ulteriori informazioni, vedi [Download per AWS CloudHSM Client SDK](client-history.md).
Per le piattaforme supportate per il precedente Client SDK, vedi [AWS CloudHSM Piattaforme supportate da Client SDK 3](sdk3-support.md)
Client SDK 5 non richiede un client daemon.
**Topics**
+ [Supporto Linux per Client SDK 5](sdk8-linux.md)
+ [Supporto Windows per Client SDK 5](sdk8-windows.md)
+ [Supporto serverless per Client SDK 5](sdk8-serverless.md)
+ [Compatibilità HSM per Client SDK 5](sdk5-hsm-types.md)
# Supporto Linux per AWS CloudHSM Client SDK 5
AWS CloudHSM Client SDK 5 supporta i seguenti sistemi operativi e piattaforme Linux.
| Piattaforme supportate | Architettura: x86\$164 | Architettura ARM |
| --- | --- | --- |
| Amazon Linux 2 | Sì | Sì |
| Amazon Linux 2023 | Sì | Sì |
| Red Hat Enterprise Linux 8 (8.3\$1) | Sì | Sì |
| Red Hat Enterprise Linux 9 (9.2\$1) | Sì | Sì |
| Red Hat Enterprise Linux 10 (10.0\$1) | Sì | Sì |
| Ubuntu 22.04 LTS | Sì | Sì |
| Ubuntu 24.04 LTS | Sì | Sì |
+ SDK 5.16 è stata l'ultima versione a fornire il supporto della piattaforma Ubuntu 20.04 LTS. [Per ulteriori informazioni, consulta il sito Web di Ubuntu.](https://ubuntu.com/blog/ubuntu-20-04-lts-end-of-life-standard-support-is-coming-to-an-end-heres-how-to-prepare)
+ SDK 5.12 è stata l'ultima versione a fornire il supporto per la piattaforma CentOS 7 (7.8\$1). Per ulteriori informazioni, vedi il [sito web CentOS](https://blog.centos.org/2023/04/end-dates-are-coming-for-centos-stream-8-and-centos-linux-7/).
+ SDK 5.12 è stata l'ultima versione a fornire il supporto per la piattaforma Red Hat Enterprise Linux 7 (7.8\$1). [Per ulteriori informazioni, consulta il sito Web di Red Hat.](https://www.redhat.com/en/technologies/linux-platforms/enterprise-linux/rhel-7-end-of-maintenance)
+ SDK 5.4.2 è stata l'ultima versione a fornire il supporto della piattaforma CentOS 8. Per ulteriori informazioni, vedi il [sito web CentOS](https://www.centos.org/centos-linux-eol/).
# Supporto Windows per AWS CloudHSM Client SDK 5
AWS CloudHSM Client SDK 5 supporta le seguenti versioni di Windows Server.
+ Microsoft Windows Server 2016
+ Microsoft Windows Server 2019
+ Microsoft Windows Server 2022
+ Microsoft Windows Server 2025
# Supporto serverless per AWS CloudHSM Client SDK 5
AWS CloudHSM Client SDK 5 supporta i seguenti AWS servizi serverless.
+ AWS Lambda
+ Docker/ECS
# Compatibilità HSM per AWS CloudHSM Client SDK 5
La tabella seguente descrive la compatibilità di AWS CloudHSM Client SDK 5 per. HSMs
| hsm1.medium | hsm2m. medio |
| --- | --- |
| Compatibile con Client SDK versione 5.0.0 e successive. | Compatibile con Client SDK versione 5.9.0 e successive. |
# Libreria PKCS \$111 per AWS CloudHSM Client SDK 5
PKCS \$111 è uno standard per l'esecuzione di operazioni crittografiche sui moduli di sicurezza hardware (). HSMs AWS CloudHSM offre implementazioni della libreria PKCS \$111 conformi alla versione PKCS \$111 2.40.
Per informazioni sul processo di bootstrap, consulta la pagina [Connessione al cluster](cluster-connect.md). Per [Problemi noti della libreria PKCS \$111 per AWS CloudHSMProblemi noti per la libreria PKCS \$111](ki-pkcs11-sdk.md) la risoluzione dei problemi, vedere.
Per informazioni sull'utilizzo di Client SDK 3, consulta la pagina [Utilizzo della versione SDK precedente con cui lavorare AWS CloudHSM](choose-client-sdk.md).
**Topics**
+ [Installa la libreria PKCS \$111](pkcs11-library-install.md)
+ [Effettua l'autenticazione alla libreria PKCS \$111](pkcs11-pin.md)
+ [Tipi di chiave](pkcs11-key-types.md)
+ [Meccanismi](pkcs11-mechanisms.md)
+ [operazioni API](pkcs11-apis.md)
+ [Attributi chiave](pkcs11-attributes.md)
+ [Esempi di codice](pkcs11-samples.md)
+ [Configurazioni avanzate.](pkcs11-library-configs.md)
+ [Archiviazione dei certificati](pkcs11-certificate-storage.md)
# Installa la libreria PKCS \$111 per AWS CloudHSM Client SDK 5
Questo argomento fornisce istruzioni per l'installazione della versione più recente della libreria PKCS \$111 per la serie di versioni AWS CloudHSM Client SDK 5. Per ulteriori informazioni sull'SDK del client o sulla libreria PKCS \$111, consulta la pagina sull'[utilizzo dell'SDK del client](use-hsm.md) e la pagina sulla [libreria PKCS \$111.](pkcs11-library.md)
Con Client SDK 5, non è necessario installare o eseguire un daemon del client.
Per eseguire un singolo cluster HSM con Client SDK 5, è necessario gestire innanzitutto le impostazioni di durabilità delle chiavi del client impostando `disable_key_availability_check` su `True`. Per ulteriori informazioni, consulta la pagina sulla [sincronizzazione delle chiavi](manage-key-sync.md) e la pagina sullo [strumento di configurazione di Client SDK 5](configure-sdk-5.md).
Per ulteriori informazioni sulla libreria PKCS \$111 in Client SDK 5, consulta la pagina sulla [libreria PKCS \$111](pkcs11-library.md).
**Nota**
Per eseguire un singolo cluster HSM con Client SDK 5, è necessario gestire innanzitutto le impostazioni di durabilità delle chiavi del client impostando `disable_key_availability_check` su `True`. Per ulteriori informazioni, consulta la pagina sulla [sincronizzazione delle chiavi](manage-key-sync.md) e la pagina sullo [strumento di configurazione di Client SDK 5](configure-sdk-5.md).
**Come installare e configurare la libreria PKCS \$111**
1. Utilizza i seguenti comandi per scaricare e installare la libreria PKCS \$111.
------
#### [ Amazon Linux 2023 ]
Installa la libreria PKCS \$111 per Amazon Linux 2023 sull'architettura X86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-pkcs11-latest.amzn2023.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.amzn2023.x86_64.rpm
```
Installa la libreria PKCS \$111 per Amazon Linux 2023 sull' ARM64 architettura:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-pkcs11-latest.amzn2023.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.amzn2023.aarch64.rpm
```
------
#### [ Amazon Linux 2 ]
Installa la libreria PKCS \$111 per Amazon Linux 2 sull'architettura X86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-pkcs11-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el7.x86_64.rpm
```
Installa la libreria PKCS \$111 per Amazon Linux 2 sull' ARM64 architettura:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-pkcs11-latest.el7.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el7.aarch64.rpm
```
------
#### [ RHEL 10 (10.0\$1) ]
Installa la libreria PKCS \$111 per RHEL 10 sull'architettura X86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-pkcs11-latest.el10.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el10.x86_64.rpm
```
Installa la libreria PKCS \$111 per RHEL 10 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-pkcs11-latest.el10.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el10.aarch64.rpm
```
------
#### [ RHEL 9 (9.2\$1) ]
Installa la libreria PKCS \$111 per RHEL 9 sull'architettura X86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-pkcs11-latest.el9.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el9.x86_64.rpm
```
Installa la libreria PKCS \$111 per RHEL 9 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-pkcs11-latest.el9.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el9.aarch64.rpm
```
------
#### [ RHEL 8 (8.3\$1) ]
Installa la libreria PKCS \$111 per RHEL 8 sull'architettura X86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-pkcs11-latest.el8.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el8.x86_64.rpm
```
Installa la libreria PKCS \$111 per RHEL 8 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-pkcs11-latest.el8.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-pkcs11-latest.el8.aarch64.rpm
```
------
#### [ Ubuntu 24.04 LTS ]
Installa la libreria PKCS \$111 per Ubuntu 24.04 LTS sull'architettura X86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-pkcs11_latest_u24.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-pkcs11_latest_u24.04_amd64.deb
```
Installa la libreria PKCS \$111 per Ubuntu 24.04 LTS sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-pkcs11_latest_u24.04_arm64.deb
```
```
$ sudo apt install ./cloudhsm-pkcs11_latest_u24.04_arm64.deb
```
------
#### [ Ubuntu 22.04 LTS ]
Installa la libreria PKCS \$111 per Ubuntu 22.04 LTS sull'architettura X86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-pkcs11_latest_u22.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-pkcs11_latest_u22.04_amd64.deb
```
Installa la libreria PKCS \$111 per Ubuntu 22.04 LTS sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-pkcs11_latest_u22.04_arm64.deb
```
```
$ sudo apt install ./cloudhsm-pkcs11_latest_u22.04_arm64.deb
```
------
#### [ Windows Server ]
Installa la libreria PKCS \$111 per Windows Server sull'architettura X86\$164:
1. Scarica la [libreria PKCS \$111 per Client SDK 5](https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Windows/AWSCloudHSMPKCS11-latest.msi).
1. Eseguite il programma di installazione della libreria PKCS \$111 (**AWSCloudHSMPKCS11-latest.msi**) con privilegi amministrativi di Windows.
------
1. Utilizza lo strumento di configurazione per specificare la posizione del certificato emittente. Per istruzioni, consulta [Specifica la posizione del certificato di emissione](cluster-connect.md#specify-cert-location).
1. Per connetterti al cluster, consulta la pagina [Esegui il bootstrap di Client SDK](cluster-connect.md#connect-how-to).
1. Puoi trovare i file della libreria PKCS \$111 nelle seguenti posizioni:
+ File binari, script di configurazione e file di log Linux:
```
/opt/cloudhsm
```
File binari Windows:
```
C:\Program Files\Amazon\CloudHSM
```
Script di configurazione e file di log Windows:
```
C:\ProgramData\Amazon\CloudHSM
```
# Effettua l'autenticazione alla libreria PKCS \$111 per AWS CloudHSM Client SDK 5
Quando utilizzate la libreria PKCS \$111, l'applicazione viene eseguita come un particolare [utente crittografico (CU)](manage-hsm-users.md) nel vostro computer. HSMs AWS CloudHSM L'applicazione è in grado di visualizzare e gestire solo le chiavi di proprietà e condivise dall'utente di crittografia. È possibile utilizzare una CU esistente nel proprio computer HSMs o crearne una nuova per l'applicazione. Per informazioni sulla gestione CUs, consulta [Gestione degli utenti HSM con CloudHSM CLI e [Gestione degli utenti HSM con CloudHSM](manage-hsm-users-cmu.md)](manage-hsm-users-chsm-cli.md) Management Utility (CMU)
Per specificare il CU nella libreria PKCS \$111, utilizza il parametro pin della [funzione C\$1Login](http://docs.oasis-open.org/pkcs11/pkcs11-base/v2.40/os/pkcs11-base-v2.40-os.html#_Toc385057915) di PKCS \$111. Infatti AWS CloudHSM, il parametro pin ha il seguente formato:
```
:
```
Ad esempio, il comando seguente imposta il pin della libreria PKCS \$111 sul CU con il nome utente `CryptoUser` e la password `CUPassword123!`.
```
CryptoUser:CUPassword123!
```
# Tipi di chiave supportati per la libreria PKCS \$111 per AWS CloudHSM Client SDK 5
La libreria PKCS \$111 per AWS CloudHSM Client SDK 5 supporta i seguenti tipi di chiavi.
****
| Tipo di chiavi | Description |
| --- | --- |
| AES | Genera chiavi AES a 128, 192 e 256 bit. |
| Triplo DES (3DES,) DESede | Genera chiavi Triple DES a 192 bit. Vedi la nota [1](#key-types-1) di seguito per una modifica imminente. |
| EC | Genera chiavi con le curve secp224r1 (P-224), secp256r1 (P-256), secp256k1 (Blockchain), secp384r1 (P-384) e secp521r1 (P-521). |
| GENERIC\$1SECRET | Genera segreti generici da 1 a 800 byte. |
| RSA | General chiavi RSA da 2048-bit a 4096-bit, con incrementi di 256 bit. |
[1] In conformità alle linee guida del NIST, ciò non è consentito per i cluster in modalità FIPS dopo il 2023. Per i cluster in modalità non FIPS, è ancora consentito dopo il 2023. Per informazioni dettagliate, vedi [Conformità FIPS 140: meccanismo di deprecazione 2024](compliance-dep-notif.md#compliance-dep-notif-1).
# Meccanismi supportati per la libreria PKCS \$111 per Client SDK 5 AWS CloudHSM
La libreria PKCS \$111 è conforme alla versione 2.40 della specifica PKCS \$111. Per richiamare una funzione di crittografia utilizzando PKCS \$111, chiamare una funzione con un determinato meccanismo. Le seguenti sezioni riassumono le combinazioni di funzioni e meccanismi supportati da AWS CloudHSM Client SDK 5.
La libreria PKCS \$111 supporta i seguenti algoritmi:
+ **Crittografia e decrittografia**: AES-CBC, AES-CTR, AES-ECB, AES-GCM, -CBC, -ECB, RSA-OAEP e RSA-PKCS DES3 DES3
+ **Firma e verifica**: RSA, HMAC e ECDSA; con e senza hashing
+ ** SHA1 SHA256 SHA384Hash/digest** SHA224 —,,, e SHA512
+ **Wrapping della chiave**: AES Key Wrap,[1](#mech1) AES-GCM, RSA-AES e RSA-OAEP
+ **Derivazione delle chiavi**: SP800 -108 Counter KDF ed ECDH con KDF (gli algoritmi KDF supportati sono X9.63 con,,,) SHA1 SHA224 SHA256 SHA384 SHA512
**Topics**
+ [Funzioni di generazione chiavi e coppie di chiavi](#pkcs11-mech-function-genkey)
+ [Funzioni di firma e verifica](#pkcs11-mech-function-signverify)
+ [Funzioni Sign recover e Verify recover](#pkcs11-mech-function-sr-vr)
+ [Funzioni di digest](#pkcs11-mech-function-digest)
+ [Funzioni di crittografia e decrittografia](#pkcs11-mech-function-enc-dec)
+ [Funzioni di derivazione della chiave](#pkcs11-mech-function-derive-key)
+ [Funzioni di wrapping e annullamento del wrapping](#pkcs11-mech-function-wrap-unwrap)
+ [Dimensione massima dei dati per ogni meccanismo](#pkcs11-mech-max)
+ [Annotazioni sui meccanismi](#pkcs11-mech-annotations)
## Funzioni di generazione chiavi e coppie di chiavi
La libreria AWS CloudHSM software per la libreria PKCS \$111 consente di utilizzare i seguenti meccanismi per le funzioni Generate Key e Key Pair.
+ `CKM_RSA_PKCS_KEY_PAIR_GEN`
+ `CKM_RSA_X9_31_KEY_PAIR_GEN`: il funzionamento di questo meccanismo è identico a quello del meccanismo `CKM_RSA_PKCS_KEY_PAIR_GEN`, ma offre maggiori garanzie per la generazione di `p` e `q`.
+ `CKM_EC_KEY_PAIR_GEN`
+ `CKM_GENERIC_SECRET_KEY_GEN`
+ `CKM_AES_KEY_GEN`
+ `CKM_DES3_KEY_GEN`: modifica imminente indicata nella nota a piè di pagina [5](#mech5).
## Funzioni di firma e verifica
La libreria AWS CloudHSM software per la libreria PKCS \$111 consente di utilizzare i seguenti meccanismi per le funzioni Sign and Verify. Con Client SDK 5, l'hashing dei dati viene eseguito localmente nel software. Ciò significa che non ci sono limiti alla dimensione dei dati che l'SDK può sottoporre a hash.
Con gli algoritmi RSA e ECDSA di Client SDK 5, l'hashing viene effettuato in locale, quindi non ci sono limiti di dati. Con HMAC, invece, vi è un limite di dati. Per maggiori informazioni, consulta la nota a piè di pagina [2](#mech2).
**RSA**
+ `CKM_RSA_X_509`
+ `CKM_RSA_PKCS`: solo operazioni a parte singola.
+ `CKM_RSA_PKCS_PSS`: solo operazioni a parte singola.
+ `CKM_SHA1_RSA_PKCS`
+ `CKM_SHA224_RSA_PKCS`
+ `CKM_SHA256_RSA_PKCS`
+ `CKM_SHA384_RSA_PKCS`
+ `CKM_SHA512_RSA_PKCS`
+ `CKM_SHA512_RSA_PKCS`
+ `CKM_SHA1_RSA_PKCS_PSS`
+ `CKM_SHA224_RSA_PKCS_PSS`
+ `CKM_SHA256_RSA_PKCS_PSS`
+ `CKM_SHA384_RSA_PKCS_PSS`
+ `CKM_SHA512_RSA_PKCS_PSS`
**ECDSA**
+ `CKM_ECDSA`: solo operazioni a parte singola.
+ `CKM_ECDSA_SHA1`
+ `CKM_ECDSA_SHA224`
+ `CKM_ECDSA_SHA256`
+ `CKM_ECDSA_SHA384`
+ `CKM_ECDSA_SHA512`
**HMAC**
+ `CKM_SHA_1_HMAC`[2](#mech2)
+ `CKM_SHA224_HMAC`[2](#mech2)
+ `CKM_SHA256_HMAC`[2](#mech2)
+ `CKM_SHA384_HMAC`[2](#mech2)
+ `CKM_SHA512_HMAC`[2](#mech2)
**CMAC**
+ `CKM_AES_CMAC`
## Funzioni Sign recover e Verify recover
Client SDK 5 non supporta le funzioni Sign Recover e Verify Recover.
## Funzioni di digest
La libreria AWS CloudHSM software per la libreria PKCS \$111 consente di utilizzare i seguenti meccanismi per le funzioni Digest. Con Client SDK 5, l'hashing dei dati viene eseguito localmente nel software. Ciò significa che non ci sono limiti alla dimensione dei dati che l'SDK può sottoporre a hash.
+ `CKM_SHA_1`
+ `CKM_SHA224`
+ `CKM_SHA256`
+ `CKM_SHA384`
+ `CKM_SHA512`
## Funzioni di crittografia e decrittografia
La libreria AWS CloudHSM software per la libreria PKCS \$111 consente di utilizzare i seguenti meccanismi per le funzioni Encrypt e Decrypt.
+ `CKM_RSA_X_509`
+ `CKM_RSA_PKCS`: solo operazioni a parte singola. Modifica imminente indicata nella nota a piè di pagina [5](#mech5).
+ `CKM_RSA_PKCS_OAEP`: solo operazioni a parte singola.
+ `CKM_AES_ECB`
+ `CKM_AES_CTR`
+ `CKM_AES_CBC`
+ `CKM_AES_CBC_PAD`
+ `CKM_DES3_CBC`: modifica imminente indicata nella nota a piè di pagina [5](#mech5).
+ `CKM_DES3_ECB`: modifica imminente indicata nella nota a piè di pagina [5](#mech5).
+ `CKM_DES3_CBC_PAD`: modifica imminente indicata nella nota a piè di pagina [5](#mech5).
+ `CKM_AES_GCM` [1](#mech1), [2](#mech2)
+ `CKM_CLOUDHSM_AES_GCM`[3](#mech3)
## Funzioni di derivazione della chiave
La libreria AWS CloudHSM software per la libreria PKCS \$111 supporta i seguenti meccanismi di derivazione delle chiavi:
+ `CKM_SP800_108_COUNTER_KDF`
+ `CKM_ECDH1_DERIVE`- Supporta la derivazione delle chiavi ECDH con i seguenti tipi KDF definiti dal fornitore: [6](#kdf6)
+ `CKD_CLOUDHSM_X963_SHA1_KDF`- X9.63 KDF con SHA1 [7](#kdf7)
+ `CKD_CLOUDHSM_X963_SHA224_KDF`- X9.63 KDF con SHA224 [7](#kdf7)
+ `CKD_CLOUDHSM_X963_SHA256_KDF`- X9.63 KDF con SHA256 [7](#kdf7)
+ `CKD_CLOUDHSM_X963_SHA384_KDF`- X9.63 KDF con SHA384 [7](#kdf7)
+ `CKD_CLOUDHSM_X963_SHA512_KDF`- X9.63 KDF con SHA512 [7](#kdf7)
## Funzioni di wrapping e annullamento del wrapping
La libreria AWS CloudHSM software per la libreria PKCS \$111 consente di utilizzare i seguenti meccanismi per le funzioni Wrap e Unwrap.
Per ulteriori informazioni sul wrapping delle chiavi AES, consulta la pagina sul [wrapping delle chiavi AES](manage-aes-key-wrapping.md).
+ `CKM_RSA_PKCS`: solo operazioni a parte singola. Una modifica imminente è indicata nella nota a piè di pagina [5](#mech5).
+ `CKM_RSA_PKCS_OAEP`[4](#mech4)
+ `CKM_AES_GCM`[1](#mech1), [3](#mech3)
+ `CKM_CLOUDHSM_AES_GCM`[3](#mech3)
+ `CKM_RSA_AES_KEY_WRAP`
+ `CKM_CLOUDHSM_AES_KEY_WRAP_NO_PAD`[3](#mech3)
+ `CKM_CLOUDHSM_AES_KEY_WRAP_PKCS5_PAD`[3](#mech3)
+ `CKM_CLOUDHSM_AES_KEY_WRAP_ZERO_PAD`[3](#mech3)
## Dimensione massima dei dati per ogni meccanismo
La tabella seguente elenca le dimensioni massime dei dati per ciascun meccanismo:
**Dimensione massima del set di dati**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/pkcs11-mechanisms.html)
## Annotazioni sui meccanismi
+ [1] Quando si esegue la crittografia AES-GCM, l'HSM non accetta i dati del vettore di inizializzazione (IV) dall'applicazione. È necessario utilizzare un IV generato dall’HSM. L'IV da 12 byte fornito dall'HSM viene scritto nel riferimento della memoria indicato dall'elemento pIV della struttura di parametri `CK_GCM_PARAMS` fornita dall'utente. Per evitare confusione, l'SDK PKCS \$111 nella versione 1.1.1 e successive assicura che pIV punti a un buffer azzerato quando viene inizializzata la crittografia AES-GCM.
+ [2] Quando si opera sui dati utilizzando uno dei seguenti meccanismi, se il buffer dati supera la dimensione massima dei dati, l’operazione genera un errore. Per questi meccanismi, tutta l'elaborazione dei dati deve avvenire all'interno dell'HSM. Per informazioni sui set di dimensioni massime dei dati per ciascun meccanismo, fare riferimento a[Dimensione massima dei dati per ogni meccanismo](#pkcs11-mech-max).
+ [3] Meccanismo definito dal fornitore. Per utilizzare i meccanismi definiti dal fornitore CloudHSM, le applicazioni PKCS \$111 devono includere `/opt/cloudhsm/include/pkcs11/pkcs11t.h` durante la compilazione.
`CKM_CLOUDHSM_AES_GCM`: questo meccanismo proprietario è un'alternativa programmaticamente più sicura allo standard `CKM_AES_GCM`. Antepone il IV generato dall'HSM al testo cifrato invece di scriverlo nuovamente nella struttura `CK_GCM_PARAMS` fornita durante l'inizializzazione del codice. È possibile utilizzare questo meccanismo con le funzioni `C_Encrypt`, `C_WrapKey`, `C_Decrypt` e `C_UnwrapKey`. Quando si utilizza questo meccanismo, la variabile pIV nella struttura `CK_GCM_PARAMS` deve essere impostata su `NULL`. Quando si utilizza questo meccanismo con `C_Decrypt` e `C_UnwrapKey`, il IV dovrebbe essere anteposto al testo cifrato che viene scartato.
`CKM_CLOUDHSM_AES_KEY_WRAP_PKCS5_PAD`: AES Key Wrap con riempimento PKCS \$15.
`CKM_CLOUDHSM_AES_KEY_WRAP_ZERO_PAD`: AES Key Wrap con riempimento a zeri.
+ [4] I seguenti `CK_MECHANISM_TYPE` e `CK_RSA_PKCS_MGF_TYPE` sono supportati come `CK_RSA_PKCS_OAEP_PARAMS` per `CKM_RSA_PKCS_OAEP`:
+ `CKM_SHA_1` tramite `CKG_MGF1_SHA1`
+ `CKM_SHA224` tramite `CKG_MGF1_SHA224`
+ `CKM_SHA256` tramite `CKG_MGF1_SHA256`
+ `CKM_SHA384` tramite `CKM_MGF1_SHA384`
+ `CKM_SHA512` tramite `CKM_MGF1_SHA512`
+ [5] In conformità alle linee guida del NIST, ciò non è consentito per i cluster in modalità FIPS dopo il 2023. Per i cluster in modalità non FIPS, è ancora consentito dopo il 2023. Per informazioni dettagliate, vedi [Conformità FIPS 140: meccanismo di deprecazione 2024](compliance-dep-notif.md#compliance-dep-notif-1).
+ [6] Tipi definiti dal fornitore. Per utilizzare i tipi definiti dal fornitore di CloudHSM, le applicazioni PKCS \$111 devono includerli durante la compilazione. `cloudhsm_pkcs11_vendor_defs.h` Si trova nelle `/opt/cloudhsm/include/pkcs11/cloudhsm_pkcs11_vendor_defs.h` piattaforme basate su Linux e sulle piattaforme basate su Windows `C:\Program Files\Amazon\CloudHSM\include\pkcs11\cloudhsm_pkcs11_vendor_defs.h`
+ [7] Le principali funzioni di derivazione (KDFs) sono specificate nella [pubblicazione speciale 800-56A Revisione 3 del NIST](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Ar3.pdf).
# Operazioni API supportate per la libreria PKCS \$111 per Client SDK 5 AWS CloudHSM
La libreria PKCS \$111 supporta le seguenti operazioni API PKCS \$111 per AWS CloudHSM Client SDK 5.
+ `C_CloseAllSessions`
+ `C_CloseSession`
+ `C_CreateObject`
+ `C_Decrypt`
+ `C_DecryptFinal`
+ `C_DecryptInit`
+ `C_DecryptUpdate`
+ `C_DeriveKey`
+ `C_DestroyObject`
+ `C_Digest`
+ `C_DigestFinal`
+ `C_DigestInit`
+ `C_DigestUpdate`
+ `C_Encrypt`
+ `C_EncryptFinal`
+ `C_EncryptInit`
+ `C_EncryptUpdate`
+ `C_Finalize`
+ `C_FindObjects`
+ `C_FindObjectsFinal`
+ `C_FindObjectsInit`
+ `C_GenerateKey`
+ `C_GenerateKeyPair`
+ `C_GenerateRandom`
+ `C_GetAttributeValue`
+ `C_GetFunctionList`
+ `C_GetInfo`
+ `C_GetMechanismInfo`
+ `C_GetMechanismList`
+ `C_GetSessionInfo`
+ `C_GetSlotInfo`
+ `C_GetSlotList`
+ `C_GetTokenInfo`
+ `C_Initialize`
+ `C_Login`
+ `C_Logout`
+ `C_OpenSession`
+ `C_Sign`
+ `C_SignFinal`
+ `C_SignInit`
+ `C_SignUpdate`
+ `C_UnWrapKey`
+ `C_Verify`
+ `C_VerifyFinal`
+ `C_VerifyInit`
+ `C_VerifyUpdate`
+ `C_WrapKey`
# Attributi chiave nella libreria PKCS \$111 per Client SDK 5 AWS CloudHSM
Un oggetto AWS CloudHSM chiave può essere una chiave pubblica, privata o segreta. Le azioni consentite su un oggetto chiave sono specificate tramite gli attributi. Gli attributi sono definiti quando l'oggetto chiave viene creato. Quando si utilizza la libreria PKCS \$111 per AWS CloudHSM, assegniamo valori predefiniti come specificato dallo standard PKCS \$111.
AWS CloudHSM non supporta tutti gli attributi elencati nella specifica PKCS \$111. Siamo conformi alla specifica per tutti gli attributi supportati. Questi attributi sono elencati nelle rispettive tabelle.
Le funzioni di crittografia, ad esempio `C_CreateObject`, `C_GenerateKey`, `C_GenerateKeyPair`, `C_UnwrapKey`, e `C_DeriveKey` che creano, modificano o copiano gli oggetti utilizzano un modello di attributo come uno dei loro parametri. Per ulteriori informazioni sul trasferimento di un modello di attributo durante la creazione di un oggetto, consulta la pagina sulla [generazione di chiavi attraverso la libreria PKCS \$111](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/generate) per vedere degli esempi.
I seguenti argomenti forniscono ulteriori informazioni sugli attributi AWS CloudHSM chiave.
**Topics**
+ [Tabelle degli attributi](pkcs11-attributes-interpreting.md)
+ [Modifica degli attributi](modify-attr.md)
+ [Interpretazione dei codici di errore](attr-errors.md)
# Tabelle degli attributi della libreria PKCS \$111 per AWS CloudHSM Client SDK 5
Le tabelle della libreria PKCS \$111 AWS CloudHSM contengono un elenco di attributi che differiscono in base al tipo di chiave. Indica se un determinato attributo è supportato per un particolare tipo di chiave quando si utilizza una funzione crittografica specifica con. AWS CloudHSM
**Legenda:**
+ ✔ indica che CloudHSM supporta l'attributo per il tipo di chiave specifico.
+ ✖ indica che CloudHSM non supporta l'attributo per il tipo di chiave specifico.
+ R indica che il valore dell'attributo è di sola lettura per il tipo di chiave specifico.
+ S indica che l'attributo non può essere letto da `GetAttributeValue` poiché è sensibile.
+ Una cella vuota nella colonna Valore predefinito indica che non vi è alcun valore predefinito specifico assegnato all'attributo.
## GenerateKeyPair
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## GenerateKey
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## CreateObject
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## UnwrapKey
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## DeriveKey
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
## GetAttributeValue
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/pkcs11-attributes-interpreting.html)
**Annotazioni degli attributi**
+ [1] Questo attributo è parzialmente supportato dal firmware e deve essere impostato esplicitamente solo sul valore predefinito.
+ [2] Attributo obbligatorio.
# Modifica degli attributi della libreria PKCS \$111 per AWS CloudHSM Client SDK 5
Alcuni attributi della libreria PKCS \$111 di un AWS CloudHSM oggetto possono essere modificati dopo la creazione dell'oggetto, mentre altri no. Per modificare gli attributi, utilizzate il comando [key set-attribute](cloudhsm_cli-key-set-attribute.md) dalla CLI di CloudHSM. È inoltre possibile derivare un elenco di attributi utilizzando il comando [key list](cloudhsm_cli-key-list.md) dalla CLI di CloudHSM.
L'elenco seguente mostra gli attributi modificabili dopo la creazione dell'oggetto:
+ `CKA_LABEL`
+ `CKA_TOKEN`
**Nota**
La modifica è consentita solo per la modifica di una chiave di sessione in una chiave di token. Utilizzate il comando [key set-attribute](cloudhsm_cli-key-set-attribute.md) della CLI di CloudhSM per modificare il valore dell'attributo.
+ `CKA_ENCRYPT`
+ `CKA_DECRYPT`
+ `CKA_SIGN`
+ `CKA_VERIFY`
+ `CKA_WRAP`
+ `CKA_UNWRAP`
+ `CKA_LABEL`
+ `CKA_SENSITIVE`
+ `CKA_DERIVE`
**Nota**
Questo attributo supporta la derivazione della chiave. Deve essere `False` per tutte le chiavi pubbliche e non può essere impostato su `True`. Per le chiavi segrete ed EC private, può essere impostato su `True` o `False`.
+ `CKA_TRUSTED`
**Nota**
Questo attributo può essere impostato su `True` o su `False` solo da Responsabile della crittografia (CO).
+ `CKA_WRAP_WITH_TRUSTED`
**Nota**
Applica questo attributo a una chiave di dati esportabile per specificare che è possibile eseguire il wrapping della chiave solo con chiavi contrassegnate come `CKA_TRUSTED`. Una volta impostato l'attributo `CKA_WRAP_WITH_TRUSTED` su true, questo diventa di sola lettura e non è possibile modificarlo o rimuoverlo.
# Interpretazione dei codici di errore della libreria PKCS \$111 per Client SDK 5 AWS CloudHSM
Se si specifica nel modello un attributo della libreria PKCS \$111 che non è supportato da una chiave specifica, viene generato un errore. La tabella riportata di seguito contiene i codici di errore generati quando si violano le specifiche:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/attr-errors.html)
# Esempi di codice per la libreria PKCS \$111 per AWS CloudHSM Client SDK 5
Gli esempi di codice riportati GitHub mostrano come eseguire attività di base utilizzando la libreria PKCS \$111 per AWS CloudHSM Client SDK 5.
## Prerequisiti
Prima di eseguire gli esempi, attieniti alla seguente procedura per configurare l'ambiente:
+ Installa e configura la [libreria PKCS \$111](pkcs11-library-install.md) per Client SDK 5.
+ Configura un [crypto user (CU)](manage-hsm-users.md). L'applicazione utilizza questo account HSM per eseguire i codici di esempio sull'HSM.
## Esempi di codice
Esempi di codice per la libreria AWS CloudHSM software per PKCS \$111 sono disponibili su. [GitHub](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples) Questo repository include esempi su come eseguire operazioni comuni utilizzando PKCS \$111, tra cui crittografia, decrittografia, firma e verifica.
+ [Generazione di chiavi (AES, RSA, EC)](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/generate)
+ [Elenco degli attributi chiave](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/attributes/)
+ [Crittografia e decodifica dei dati con AES GCM](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/encrypt/aes_gcm.c)
+ [Crittografia e decrittografia dei dati con AES\$1CTR](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/encrypt/aes_ctr.c)
+ [Crittografia e decrittografia dei dati con 3DES](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/encrypt/des_ecb.c)
+ [Firma e verifica dei dati con RSA](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/sign/rsa_sign.c)
+ [Derivazione delle chiavi utilizzando HMAC KDF](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/derivation/hmac_kdf.c)
+ [Wrapping e annullamento del wrapping delle chiavi mediante riempimento PKCS \$15](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_wrapping.c)
+ [Wrapping e annullamento del wrapping delle chiavi con AES utilizzando senza riempimento](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_no_padding_wrapping.c)
+ [Wrapping e annullamento del wrapping delle chiavi con AES mediante riempimento a zeri](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_zero_padding_wrapping.c)
+ [Wrapping e annullamento del wrapping delle chiavi con AES-GCM](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/wrapping/aes_gcm_wrapping.c)
+ [Wrapping e annullamento del wrapping delle chiavi con RSA](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/rsa_wrapping.c)
# Configurazioni avanzate per la libreria PKCS \$111 per AWS CloudHSM
Il provider AWS CloudHSM PKCS \$111 include la seguente configurazione avanzata, che non fa parte delle configurazioni generali utilizzate dalla maggior parte dei clienti. Queste configurazioni offrono funzionalità aggiuntive.
+ [Connessione a più slot con PKCS \$111](pkcs11-library-configs-multi-slot.md)
+ [Ripetizione del tentativo di configurazione per PKCS \$111](pkcs11-library-configs-retry.md)
# Configurazione a slot multipli con libreria PKCS \$111 per AWS CloudHSM
Un singolo slot nella libreria PKCS \$111 di Client SDK 5 rappresenta una singola connessione a un cluster in AWS CloudHSM. Con Client SDK 5, puoi configurare la tua PKCS11 libreria per consentire a più slot di connettere gli utenti a più cluster CloudHSM da una singola applicazione PKCS \$111.
Utilizza le istruzioni riportate in questo argomento per fare in modo che l'applicazione utilizzi la funzionalità multislot per connettersi a più cluster.
**Topics**
+ [Prerequisiti multi-slot per la libreria PKCS \$111 per AWS CloudHSM](#pkcs11-multi-slot-prereqs)
+ [Configura la libreria PKCS \$111 per la funzionalità multi-slot per AWS CloudHSM](pkcs11-multi-slot-config-run.md)
+ [Aggiungi un cluster con funzionalità multi-slot per AWS CloudHSM](pkcs11-multi-slot-add-cluster.md)
+ [Rimuovi un cluster con funzionalità multi-slot per AWS CloudHSM](pkcs11-multi-slot-remove-cluster.md)
## Prerequisiti multi-slot per la libreria PKCS \$111 per AWS CloudHSM
Prima di configurare più slot per la libreria PKCS \$111 per AWS CloudHSM, completa i seguenti prerequisiti.
+ Due o più AWS CloudHSM cluster a cui desideri connetterti, insieme ai relativi certificati di cluster.
+ Un'istanza EC2 con i gruppi di sicurezza configurata correttamente per connettersi a tutti i cluster riportati sopra. Per ulteriori informazioni su come configurare un cluster e l'istanza del client, consulta la sezione [Guida introduttiva AWS CloudHSM](getting-started.md).
+ Per configurare la funzionalità multislot, è necessario aver già scaricato e installato la libreria PKCS \$111. Se non lo hai ancora fatto, consulta le istruzioni riportate in [Installa la libreria PKCS \$111 per AWS CloudHSM Client SDK 5](pkcs11-library-install.md).
# Configura la libreria PKCS \$111 per la funzionalità multi-slot per AWS CloudHSM
Per configurare la libreria PKCS \$111 per la funzionalità multi-slot per AWS CloudHSM, procedi nel seguente modo:
1. Individua i cluster a cui desideri connetterti utilizzando la funzionalità multislot.
1. Aggiungi tali cluster alla configurazione PKCS \$111 seguendo le istruzioni riportate in [Aggiungi un cluster con funzionalità multi-slot per AWS CloudHSM](pkcs11-multi-slot-add-cluster.md)
1. La prossima volta che l'applicazione PKCS \$111 verrà eseguita, la funzionalità multislot sarà abilitata.
# Aggiungi un cluster con funzionalità multi-slot per AWS CloudHSM
Quando [ci si connette a più slot con PKCS \$111](pkcs11-library-configs-multi-slot.md) for AWS CloudHSM, usa il **configure-pkcs11 add-cluster** comando per aggiungere un cluster alla configurazione.
## Sintassi
```
configure-pkcs11 add-cluster [OPTIONS]
--cluster-id
[--region ]
[--endpoint ]
[--hsm-ca-cert ]
[--client-cert-hsm-tls-file ]
[--client-key-hsm-tls-file ]
[-h, --help]
```
## Esempi
### Aggiungere un cluster utilizzando il parametro `cluster-id`
**Example**
Utilizza il parametro **configure-pkcs11 add-cluster** insieme a `cluster-id` per aggiungere un cluster (con l'ID del `cluster-1234567`) alla tua configurazione.
```
$ sudo /opt/cloudhsm/bin/configure-pkcs11 add-cluster --cluster-id
```
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-pkcs11.exe" add-cluster --cluster-id
```
**Suggerimento**
Se l'utilizzo del parametro **configure-pkcs11 add-cluster** con `cluster-id` non dà come risultato l'aggiunta del cluster, consulta l'esempio seguente per una versione più lunga del comando che richiede anche i parametri `--region` e `--endpoint` per identificare il cluster che si sta aggiungendo. Se, ad esempio, la regione del cluster è diversa da quella configurata come impostazione predefinita per la CLI di AWS, è necessario impiegare il parametro `--region` per utilizzare la regione corretta. Inoltre, hai la possibilità di specificare l'endpoint AWS CloudHSM API da utilizzare per la chiamata, che potrebbe essere necessario per varie configurazioni di rete, ad esempio l'utilizzo di endpoint di interfaccia VPC che non utilizzano il nome host DNS predefinito per. AWS CloudHSM
### Aggiungere un cluster utilizzando i parametri `cluster-id`, `endpoint` e `region`
**Example**
Utilizza **configure-pkcs11 add-cluster** insieme ai parametri `cluster-id`, `endpoint` e `region` per aggiungere un cluster (con l'ID del `cluster-1234567`) alla tua configurazione.
```
$ sudo /opt/cloudhsm/bin/configure-pkcs11 add-cluster --cluster-id --region --endpoint
```
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-pkcs11.exe" add-cluster --cluster-id --region --endpoint
```
Per ulteriori informazioni sui parametri `--cluster-id`, `--region` e `--endpoint`, vedi [AWS CloudHSM Parametri di configurazione di Client SDK 5](configure-tool-params5.md).
## Parameters
**--cluster-id ****
Effettua una chiamata `DescribeClusters` per trovare tutti gli indirizzi IP a interfaccia di rete elastica (ENI) dell’HSM nel cluster associati all'ID del cluster. Il sistema aggiunge gli indirizzi IP ENI ai file di configurazione. AWS CloudHSM
Se utilizzi il `--cluster-id` parametro da un'istanza EC2 all'interno di un VPC che non ha accesso alla rete Internet pubblica, devi creare un endpoint VPC di interfaccia con cui connetterti. AWS CloudHSM Per ulteriori informazioni sugli endpoint VPC, consulta la pagina [AWS CloudHSM ed endpoint VPC](cloudhsm-vpc-endpoint.md).
Obbligatorio: sì
**--endpoint ****
Specificare l'endpoint AWS CloudHSM API utilizzato per effettuare la chiamata. `DescribeClusters` È necessario impostare questa opzione insieme a `--cluster-id`.
Obbligatorio: no
**--hsm-ca-cert ****
Speciifica il percorso del file del certificato CA HSM.
Obbligatorio: no
**--region ****
Specifica la regione del cluster. È necessario impostare questa opzione insieme a `--cluster-id`.
Se non indichi il parametro `--region`, il sistema sceglie la regione tentando di leggere le variabili di ambiente `AWS_DEFAULT_REGION` o `AWS_REGION`. Se queste variabili non sono impostate, il sistema controlla la regione associata al tuo profilo indicata nel tuo file di AWS Config (generalmente `~/.aws/config`) a meno che non sia stato specificato un file diverso nella variabile di ambiente `AWS_CONFIG_FILE`. Se non è stata impostata nessuna delle variabili precedenti, il sistema utilizza la regione `us-east-1` per impostazione predefinita.
Obbligatorio: no
**-- -archivio client-cert-hsm-tls ****
Percorso del certificato client utilizzato per l'autenticazione reciproca TLS Client-HSM.
Utilizza questa opzione solo se hai registrato almeno un trust anchor su HSM con CloudHSM CLI. È necessario impostare questa opzione insieme a `--client-key-hsm-tls-file`.
Obbligatorio: no
**-- -file client-key-hsm-tls ****
Percorso della chiave client utilizzata per l'autenticazione reciproca TLS Client-HSM.
Utilizza questa opzione solo se hai registrato almeno un trust anchor su HSM con CloudHSM CLI. È necessario impostare questa opzione insieme a `--client-cert-hsm-tls-file`.
Obbligatorio: no
# Rimuovi un cluster con funzionalità multi-slot per AWS CloudHSM
Quando [ti connetti a più slot con PKCS \$111](pkcs11-library-configs-multi-slot.md), utilizza il comando **configure-pkcs11 remove-cluster** per rimuovere un cluster dagli slot PKCS \$111 disponibili.
## Sintassi
```
configure-pkcs11 remove-cluster [OPTIONS]
--cluster-id
[-h, --help]
```
## Esempi
### Rimuovere un cluster utilizzando il parametro `cluster-id`
**Example**
Utilizza il parametro **configure-pkcs11 remove-cluster** insieme a `cluster-id` per rimuovere un cluster (con l'ID del `cluster-1234567`) dalla tua configurazione.
```
$ sudo /opt/cloudhsm/bin/configure-pkcs11 remove-cluster --cluster-id
```
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-pkcs11.exe" remove-cluster --cluster-id
```
Per ulteriori informazioni sul parametro `--cluster-id`, vedi [AWS CloudHSM Parametri di configurazione di Client SDK 5](configure-tool-params5.md).
## Parametro
**--cluster-id ****
L'ID del cluster da rimuovere dalla configurazione
Obbligatorio: sì
# Riprova i comandi per la libreria PKCS \$111 per AWS CloudHSM
AWS CloudHSM Client SDK 5.8.0 e versioni successive dispongono di una strategia di riprova automatica integrata che riproverà le operazioni con limitazione HSM dal lato client. Quando un HSM rallenta le operazioni perché è troppo occupato nell'esecuzione di operazioni precedenti e non può accettare altre richieste, il client SDKs tenterà di riprovare le operazioni limitate fino a 3 volte, effettuando un backup esponenziale. Questa strategia automatica può essere impostata su una delle due modalità: **off** e **standard**.
+ **off**: il Client SDK non eseguirà alcun ulteriore tentativo per le operazioni limitate da parte dell'HSM.
+ **standard**: questa è la modalità predefinita per Client SDK 5.8.0 e successive. In questa modalità, il client SDKs riproverà automaticamente le operazioni limitate effettuando un backup esponenziale.
Per ulteriori informazioni, consulta [Limitazione HSM](troubleshoot-hsm-throttling.md).
## Disattiva i comandi per l'esecuzione di ulteriori tentativi
------
#### [ Linux ]
**Come impostare i comandi Nuovo tentativo su **off** per Client SDK 5 su Linux**
+ Per impostare la configurazione in modalità **off**, utilizza i seguenti comandi:
```
$ sudo /opt/cloudhsm/bin/configure-pkcs11 --default-retry-mode off
```
------
#### [ Windows ]
**Per impostare i comandi Nuovo Tentativo su **off** per Client SDK 5 su Windows**
+ Per impostare la configurazione in modalità **off**, utilizza i seguenti comandi:
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-pkcs11.exe" --default-retry-mode off
```
------
# Archiviazione dei certificati con la libreria PKCS \$111
La libreria AWS CloudHSM PKCS \$111 supporta l'archiviazione di certificati a chiave pubblica come «oggetti pubblici» (come definito in PKCS \$111 2.40) su cluster hsm2m.medium. Questa funzionalità consente alle sessioni PKCS \$111 pubbliche e private di creare, recuperare, modificare ed eliminare certificati a chiave pubblica.
Per utilizzare l'archiviazione dei certificati con la libreria PKCS \$111, è necessario abilitarla nella configurazione del client. Una volta abilitato, è possibile gestire gli oggetti dei certificati dalle applicazioni PKCS \$111. Le operazioni che si applicano sia al certificato che agli oggetti chiave, come [C\$1 FindObjects](http://docs.oasis-open.org/pkcs11/pkcs11-base/v2.40/os/pkcs11-base-v2.40-os.html#_Toc323205461), restituiranno risultati sia dall'archiviazione delle chiavi che dei certificati.
**Topics**
+ [Abilita l'archiviazione dei certificati](pkcs11-certificate-storage-configuration.md)
+ [API di archiviazione dei certificati](pkcs11-certificate-storage-api.md)
+ [Attributi del certificato](pkcs11-certificate-storage-attributes.md)
+ [Registri di controllo dell'archiviazione dei certificati](pkcs11-certificate-storage-audit-logs.md)
# Abilitazione dell'archiviazione dei certificati
È possibile abilitare l'archiviazione dei certificati sui cluster hsm2m.medium utilizzando lo strumento di configurazione della libreria PKCS \$111. Questa funzionalità è disponibile nelle versioni SDK 5.13 e successive. Per un elenco delle operazioni che supportano il tipo di oggetto del certificato, consulta. [Operazioni dell'API di archiviazione dei certificati](pkcs11-certificate-storage-api.md)
Per abilitare l'archiviazione dei certificati, segui questi passaggi per il tuo sistema operativo:
------
#### [ Linux ]
+
****Abilita l'archiviazione dei certificati****
Esegui il comando seguente:
```
$ sudo /opt/cloudhsm/bin/configure-pkcs11 --enable-certificate-storage
```
------
#### [ Windows ]
+
****Abilita l'archiviazione dei certificati****
Apri un prompt dei comandi ed esegui il comando seguente:
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-pkcs11.exe" --enable-certificate-storage
```
------
# Operazioni dell'API di archiviazione dei certificati
Le seguenti operazioni PKCS \$111 supportano il tipo di oggetto certificato (`CKO_CERTIFICATE`):
## Operazioni generali relative ai certificati
**`C_CreateObject`**
Crea un nuovo oggetto certificato.
**`C_DestroyObject`**
Elimina un oggetto certificato esistente.
**`C_GetAttributeValue`**
Ottiene il valore di uno o più attributi di un oggetto certificato.
**`C_SetAttributeValue`**
Aggiorna il valore di uno o più attributi di un oggetto certificato.
## Operazioni di ricerca di oggetti certificati
**`C_FindObjectsInit`**
Avvia una ricerca di oggetti di certificato.
**`C_FindObjects`**
Continua la ricerca di oggetti di certificato.
**`C_FindObjectsFinal`**
Termina la ricerca di oggetti di certificato.
# Attributi di archiviazione dei certificati
La tabella seguente elenca gli attributi degli oggetti di certificato supportati e i relativi valori:
| Attributo | Valore predefinito | Description |
| --- | --- | --- |
| `CKA_CLASS` | Richiesto | Deve essere `CKO_CERTIFICATE`. |
| `CKA_TOKEN` | True | Deve essere `True`. |
| `CKA_MODIFIABLE` | True | Deve essere `True`. |
| `CKA_PRIVATE` | False | Deve essere `False`. |
| `CKA_LABEL` | Empty | Limite 127 caratteri. |
| `CKA_COPYABLE` | False | Deve essere `False`. |
| `CKA_DESTROYABLE` | True | Deve essere `True`. |
| `CKA_CERTIFICATE_TYPE` | Richiesto | Deve essere `CKC_X_509`. |
| `CKA_TRUSTED` | False | Deve essere `False`. |
| `CKA_CERTIFICATE_CATEGORY` | `CK_CERTIFICATE_CATEGORY_UNSPECIFIED` | Deve essere `CK_CERTIFICATE_CATEGORY_UNSPECIFIED`. |
| `CKA_CHECK_VALUE` | Derivato da `CKA_VALUE` | Impostato automaticamente in base a`CKA_VALUE`. |
| `CKA_START_DATE` | Empty | La data del certificato «non anteriore». |
| `CKA_END_DATE` | Empty | La data «non successiva» del certificato. |
| `CKA_PUBLIC_KEY_INFO` | Empty | La dimensione massima è di 16 kilobyte. |
| `CKA_SUBJECT` | Richiesto | Oggetto del certificato. |
| `CKA_ID` | Empty | La dimensione massima è di 128 byte. L'unicità non viene imposta. |
| `CKA_ISSUER` | Empty | L'emittente del certificato. |
| `CKA_SERIAL_NUMBER` | Empty | Il numero di serie del certificato. |
| `CKA_VALUE` | Richiesto | La dimensione massima è di 32 kilobyte. |
# Registri di controllo dell'archiviazione dei certificati
AWS CloudHSM scrive log di controllo per le operazioni di storage dei certificati che modificano i dati in un flusso di log di CloudWatch Amazon Events separato all'interno del gruppo di log del cluster. CloudWatch Questo flusso di log prende il nome dal cluster, non da un HSM specifico all'interno del cluster.
Per informazioni sull'accesso ai log di controllo CloudWatch, vedere. [Utilizzo di Amazon CloudWatch Logs e AWS CloudHSM Audit Logs](get-hsm-audit-logs-using-cloudwatch.md)
## Campi di immissione del registro
`object_handle`
L'identificatore univoco dell'oggetto del certificato.
`op_code`
L'operazione eseguita o tentata. Valori possibili:
+ `CreateObject`
+ `DestroyObject`
+ `SetAttributeValues`
`response`
`OK`se l'operazione è riuscita, o uno dei seguenti tipi di errore:
+ `DuplicateAttribute`
+ `InvalidAttributeValue`
+ `ObjectNotFound`
+ `MaxObjectsReached`
+ `InternalFailure`
`attributes`
Gli eventuali attributi modificati.
`timestamp`
L'ora in cui si è verificata l'operazione, in millisecondi dall'epoca Unix.
## Esempi di registro di controllo
### CreateObject esempio
```
{
"object_handle": 463180677312929947,
"op_code": "CreateObject",
"response": "OK",
"attributes": null,
"timestamp": 1725482483671
}
```
### DestroyObject esempio
```
{
"object_handle": 463180677312929947,
"op_code": "DestroyObject",
"response": "OK",
"attributes": null,
"timestamp": 1725482484559
}
```
### SetAttributeValues esempio
```
{
"object_handle": 463180678453346687,
"op_code": "SetAttributeValues",
"response": "OK",
"attributes": [
"Label"
],
"timestamp": 1725482488004
}
```
### Esempio CreateObject fallito
```
{
"object_handle": null,
"op_code": "CreateObject",
"response": "MaxObjectsReached",
"attributes": null,
"timestamp": 1726084937125
}
```
# AWS CloudHSM Motore dinamico OpenSSL per Client SDK 5
L' AWS CloudHSM OpenSSL Dynamic Engine consente di trasferire le operazioni crittografiche sul cluster CloudHSM tramite l'API OpenSSL.
AWS CloudHSM fornisce un motore dinamico OpenSSL, di cui puoi leggere in o. [AWS CloudHSM Offload SSL/TLS su Linux utilizzando Tomcat con JSSE](third-offload-linux-jsse.md) [AWS CloudHSM Offload SSL/TLS su Linux usando NGINX o Apache con OpenSSL](third-offload-linux-openssl.md) Per un esempio di utilizzo AWS CloudHSM con OpenSSL, [consulta questo blog sulla sicurezza di AWS](https://aws.amazon.com/blogs/security/automate-the-deployment-of-an-nginx-web-service-using-amazon-ecs-with-tls-offload-in-cloudhsm/). Per informazioni sul supporto della piattaforma per SDKs, consulta. [AWS CloudHSM Piattaforme supportate da Client SDK 5](client-supported-platforms.md) Per la risoluzione dei problemi, vedere[Problemi noti per OpenSSL Dynamic Engine per AWS CloudHSM](ki-openssl-sdk.md).
Utilizza le seguenti sezioni per installare e configurare il motore AWS CloudHSM dinamico per OpenSSL, utilizzando Client SDK 5.
Per informazioni sull'utilizzo di Client SDK 3, consulta la pagina [Utilizzo della versione SDK precedente con cui lavorare AWS CloudHSM](choose-client-sdk.md).
**Topics**
+ [Installa il motore AWS CloudHSM dinamico OpenSSL per Client SDK 5](openssl5-install.md)
+ [Tipi di chiave supportati per OpenSSL Dynamic Engine AWS CloudHSM for Client SDK 5](openssl-key-types.md)
+ [Meccanismi supportati per OpenSSL Dynamic Engine AWS CloudHSM for Client SDK 5](openssl-mechanisms.md)
+ [Configurazioni avanzate per OpenSSL per AWS CloudHSM](openssl-library-configs.md)
# Installa il motore AWS CloudHSM dinamico OpenSSL per Client SDK 5
Utilizza le seguenti sezioni per installare OpenSSL Dynamic Engine AWS CloudHSM for Client SDK 5.
**Nota**
Per eseguire un singolo cluster HSM con Client SDK 5, è necessario gestire innanzitutto le impostazioni di durabilità delle chiavi del client impostando `disable_key_availability_check` su `True`. Per ulteriori informazioni, consulta la pagina sulla [sincronizzazione delle chiavi](manage-key-sync.md) e la pagina sullo [strumento di configurazione di Client SDK 5](configure-sdk-5.md).
**Come installare e configurare OpenSSL Dynamic Engine**
1. Utilizzare i comandi seguenti per scaricare e installare il motore OpenSSL.
------
#### [ Amazon Linux 2023 ]
Installa il motore dinamico OpenSSL per Amazon Linux 2023 sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-dyn-latest.amzn2023.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.amzn2023.x86_64.rpm
```
Installa OpenSSL Dynamic Engine per Amazon Linux 2023 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-dyn-latest.amzn2023.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.amzn2023.aarch64.rpm
```
------
#### [ Amazon Linux 2 ]
Installa OpenSSL Dynamic Engine per Amazon Linux 2 sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-dyn-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.el7.x86_64.rpm
```
Installa OpenSSL Dynamic Engine per Amazon Linux 2 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-dyn-latest.el7.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.el7.aarch64.rpm
```
------
#### [ RHEL 9 (9.2\$1) ]
Installa OpenSSL Dynamic Engine per RHEL 9 sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-dyn-latest.el9.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.el9.x86_64.rpm
```
Installa OpenSSL Dynamic Engine per RHEL 9 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-dyn-latest.el9.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.el9.aarch64.rpm
```
------
#### [ RHEL 8 (8.3\$1) ]
Installa OpenSSL Dynamic Engine per RHEL 8 sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-dyn-latest.el8.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.el8.x86_64.rpm
```
Installa OpenSSL Dynamic Engine per RHEL 8 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-dyn-latest.el8.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-dyn-latest.el8.aarch64.rpm
```
------
#### [ Ubuntu 24.04 LTS ]
Installa il motore dinamico OpenSSL per Ubuntu 24.04 LTS sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-dyn_latest_u24.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-dyn_latest_u24.04_amd64.deb
```
Installa il motore dinamico OpenSSL per Ubuntu 24.04 LTS sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-dyn_latest_u24.04_arm64.deb
```
```
$ sudo apt install ./cloudhsm-dyn_latest_u24.04_arm64.deb
```
------
#### [ Ubuntu 22.04 LTS ]
Installa il motore dinamico OpenSSL per Ubuntu 22.04 LTS sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-dyn_latest_u22.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-dyn_latest_u22.04_amd64.deb
```
Installa il motore dinamico OpenSSL per Ubuntu 22.04 LTS sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-dyn_latest_u22.04_arm64.deb
```
```
$ sudo apt install ./cloudhsm-dyn_latest_u22.04_arm64.deb
```
------
Hai installato la libreria condivisa per il motore dinamico su `/opt/cloudhsm/lib/libcloudhsm_openssl_engine.so`.
1. Esegui il bootstrap di Client SDK 5. Per ulteriori informazioni sulle operazioni di bootstrap, consulta la pagina [Esegui il bootstrap di Client SDK](cluster-connect.md#connect-how-to).
1. Imposta una variabile di ambiente con le credenziali di un crypto user (CU). Per informazioni sulla creazione, consulta. CUs [Crea un AWS CloudHSM utente con CloudHSM CLI](cloudhsm_cli-user-create.md)
```
$ export CLOUDHSM_PIN=:
```
**Nota**
Client SDK 5 introduce la variabile di ambiente `CLOUDHSM_PIN` per l'archiviazione delle credenziali del CU. In Client SDK 3 le credenziali del CU si archiviano nella variabile di ambiente `n3fips_password`. Client SDK 5 supporta entrambe le variabili di ambiente, ma si consiglia di utilizzare `CLOUDHSM_PIN`.
Quando impostate le variabili d'`CLOUDHSM_PIN`ambiente, dovete evitare qualsiasi carattere speciale che possa essere interpretato dalla vostra shell.
1. Collega l'installazione di OpenSSL Dynamic Engine al cluster. Per ulteriori informazioni, consulta la pagina [Connessione al cluster](cluster-connect.md).
1. Esegui il bootstrap di Client SDK 5. Per ulteriori informazioni, consulta [Esegui il bootstrap di Client SDK](cluster-connect.md#connect-how-to).
## Verifica di OpenSSL Dynamic Engine per Client SDK 5
Usa il comando seguente per verificare l'installazione di OpenSSL Dynamic Engine.
```
$ openssl engine -t cloudhsm
```
Il seguente output verifica la configurazione:
```
(cloudhsm) CloudHSM OpenSSL Engine
[ available ]
```
# Tipi di chiave supportati per OpenSSL Dynamic Engine AWS CloudHSM for Client SDK 5
AWS CloudHSM OpenSSL Dynamic Engine supporta i seguenti tipi di chiavi con Client SDK 5.
****
| Tipo di chiavi | Description |
| --- | --- |
| EC | ECDSA sign/verify per i tipi di chiavi P-256, P-384 e secp256k1. Per generare chiavi EC interoperabili con il motore OpenSSL, consulta la pagina [Esportazione di una chiave asimmetrica con CLI CloudhSM](cloudhsm_cli-key-generate-file.md). |
| RSA | Generazione di chiavi RSA per chiavi a 2048, 3072 e 4096 bit.Firma/verifica RSA. Viene eseguito l'offload della verifica sul software OpenSSL. |
# Meccanismi supportati per OpenSSL Dynamic Engine AWS CloudHSM for Client SDK 5
AWS CloudHSM OpenSSL Dynamic Engine supporta i seguenti meccanismi per le funzioni Sign and Verify con Client SDK 5.
## Funzioni di firma e verifica
Con Client SDK 5, l'hashing dei dati viene eseguito localmente nel software. Ciò significa che non ci sono limiti alla dimensione dei dati che possono essere sottoposti a hashing.
Tipi di firma RSA
+ SHA1withRSA
+ SHA224withRSA
+ SHA256withRSA
+ SHA384withRSA
+ SHA512withRSA
Tipi di firma ECDSA
+ SHA1withECDSA
+ SHA224withECDSA
+ SHA256withECDSA
+ SHA384withECDSA
+ SHA512withECDSA
# Configurazioni avanzate per OpenSSL per AWS CloudHSM
Il provider AWS CloudHSM OpenSSL include la seguente configurazione avanzata, che non fa parte delle configurazioni generali utilizzate dalla maggior parte dei clienti. Queste configurazioni offrono funzionalità aggiuntive.
+ [Comandi Nuovo tentativo per OpenSSL](openssl-library-configs-retry.md)
# Riprova i comandi per OpenSSL per AWS CloudHSM
AWS CloudHSM Client SDK 5.8.0 e versioni successive dispongono di una strategia di riprova automatica integrata che riproverà le operazioni con limitazione HSM dal lato client. Quando un HSM rallenta le operazioni perché è troppo occupato nell'esecuzione di operazioni precedenti e non può accettare altre richieste, il client SDKs tenterà di riprovare le operazioni limitate fino a 3 volte, effettuando un backup esponenziale. Questa strategia automatica può essere impostata su una delle due modalità: **off** e **standard**.
+ **off**: il Client SDK non eseguirà alcun ulteriore tentativo per le operazioni limitate da parte dell'HSM.
+ **standard**: questa è la modalità predefinita per Client SDK 5.8.0 e successive. In questa modalità, il client SDKs riproverà automaticamente le operazioni limitate effettuando un backup esponenziale.
Per ulteriori informazioni, consulta [Limitazione HSM](troubleshoot-hsm-throttling.md).
## Disattiva i comandi per l'esecuzione di ulteriori tentativi
È possibile utilizzare i seguenti comandi per impostare i comandi di ripetizione dei tentativi sulla modalità **off**:
```
$ sudo /opt/cloudhsm/bin/configure-dyn --default-retry-mode off
```
# Provider AWS CloudHSM OpenSSL per Client SDK 5
Il provider AWS CloudHSM OpenSSL consente di trasferire le operazioni crittografiche TLS sul cluster CloudHSM tramite l'API OpenSSL Provider. L'interfaccia Provider è l'approccio consigliato per le nuove implementazioni che utilizzano OpenSSL 3.2 e versioni successive.
Utilizza le seguenti sezioni per installare e configurare il provider AWS CloudHSM OpenSSL, utilizzando Client SDK 5.
**avvertimento**
L'integrazione con OpenSSL CLI non è attualmente supportata da OpenSSL Provider. AWS CloudHSM Vedi le integrazioni supportate. [AWS CloudHSM Offload SSL/TLS su Linux utilizzando NGINX o con OpenSSL Provider HAProxy](third-offload-linux-openssl-provider.md)
## Piattaforme supportate
Il provider OpenSSL richiede OpenSSL 3.2 o versione successiva, disponibile su EL9 \$1, Ubuntu 24.04\$1 e Amazon Linux 2023\$1.
Verifica la compatibilità: `openssl version`
**Topics**
+ [Piattaforme supportate](#openssl-provider-supported-platforms)
+ [Installa il provider AWS CloudHSM OpenSSL per Client SDK 5](openssl-provider-install.md)
+ [Tipi di chiave supportati per OpenSSL Provider AWS CloudHSM for Client SDK 5](openssl-provider-key-types.md)
+ [Meccanismi supportati dal provider OpenSSL](openssl-provider-mechanisms.md)
+ [Configurazione avanzata del provider OpenSSL](openssl-provider-advanced-config.md)
# Installa il provider AWS CloudHSM OpenSSL per Client SDK 5
Utilizza le seguenti sezioni per installare OpenSSL Provider for AWS CloudHSM Client SDK 5.
**Nota**
Per eseguire un singolo cluster HSM con Client SDK 5, è necessario gestire innanzitutto le impostazioni di durabilità delle chiavi del client impostando `disable_key_availability_check` su `True`. Per ulteriori informazioni, consulta la pagina sulla [sincronizzazione delle chiavi](working-client-sync.md#client-sync-sdk8) e la pagina sullo [strumento di configurazione di Client SDK 5](configure-sdk-5.md).
## Requisiti
Il provider OpenSSL **richiede** i tipi di cluster hsm2m.medium e la versione minima di CloudHSM Client SDK 5.17.0 o successiva.
## Installare il provider OpenSSL
**Per installare il provider OpenSSL**
1. Usa i seguenti comandi per scaricare e installare il provider OpenSSL.
------
#### [ Amazon Linux 2023 ]
Installa il provider OpenSSL per Amazon Linux 2023 sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-openssl-provider-latest.amzn2023.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-openssl-provider-latest.amzn2023.x86_64.rpm
```
Installa il provider OpenSSL per Amazon Linux 2023 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-openssl-provider-latest.amzn2023.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-openssl-provider-latest.amzn2023.aarch64.rpm
```
------
#### [ RHEL 9 (9.2\$1) ]
Installa il provider OpenSSL per RHEL 9 sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-openssl-provider-latest.el9.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-openssl-provider-latest.el9.x86_64.rpm
```
Installa il provider OpenSSL per RHEL 9 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-openssl-provider-latest.el9.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-openssl-provider-latest.el9.aarch64.rpm
```
------
#### [ RHEL 10 (10.0\$1) ]
Installa il provider OpenSSL per RHEL 10 sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-openssl-provider-latest.el10.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-openssl-provider-latest.el10.x86_64.rpm
```
Installa il provider OpenSSL per RHEL 10 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-openssl-provider-latest.el10.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-openssl-provider-latest.el10.aarch64.rpm
```
------
#### [ Ubuntu 24.04 ]
Installa il provider OpenSSL per Ubuntu 24.04 sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-openssl-provider_latest_u24.04_amd64.deb
```
```
$ sudo dpkg -i ./cloudhsm-openssl-provider_latest_u24.04_amd64.deb
```
Installa il provider OpenSSL per Ubuntu 24.04 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-openssl-provider_latest_u24.04_arm64.deb
```
```
$ sudo dpkg -i ./cloudhsm-openssl-provider_latest_u24.04_arm64.deb
```
------
È stata installata la libreria condivisa per il provider OpenSSL all'indirizzo. `/opt/cloudhsm/lib/licloudhsm_openssl_provider.so`
1. Esegui il bootstrap di Client SDK 5. Per ulteriori informazioni sulle operazioni di bootstrap, consulta la pagina [Esegui il bootstrap di Client SDK](cluster-connect.md#connect-how-to).
1. Imposta la variabile di `CLOUDHSM_PIN` ambiente con le tue credenziali di utente crittografico (CU):
```
$ export CLOUDHSM_PIN=:
```
1. Connect l'installazione di OpenSSL Provider al cluster. Per ulteriori informazioni, consulta la pagina [Connessione al cluster](cluster-connect.md).
## Verifica dell'installazione
Verifica che il provider OpenSSL sia installato correttamente:
```
$ CLOUDHSM_PIN=: openssl list -providers -provider cloudhsm
```
Dovresti vedere un output simile a:
```
Providers:
cloudhsm
name: AWS CloudHSM OpenSSL Provider
version: 5.17.0
status: active
default
name: OpenSSL Default Provider
version: 3.2.2
status: active
```
# Tipi di chiave supportati per OpenSSL Provider AWS CloudHSM for Client SDK 5
Il provider AWS CloudHSM OpenSSL supporta i seguenti tipi di chiavi con Client SDK 5.
****
| Tipo di chiavi | Description |
| --- | --- |
| RSA | Operazioni di crittografia RSA sign/verify e asimmetrica. Viene eseguito l'offload della verifica sul software OpenSSL. Per generare chiavi RSA interoperabili con il provider OpenSSL, vedere. [Esportazione di una chiave asimmetrica con CLI CloudhSM](cloudhsm_cli-key-generate-file.md) |
| EC | ECDSA sign/verify per le curve P-256, P-384 e P-521. Viene eseguito l'offload della verifica sul software OpenSSL. Per generare chiavi EC interoperabili con il provider OpenSSL, vedere. [Esportazione di una chiave asimmetrica con CLI CloudhSM](cloudhsm_cli-key-generate-file.md) |
# Meccanismi supportati dal provider OpenSSL
L'SDK AWS CloudHSM OpenSSL Provider supporta un set completo di meccanismi crittografici per varie operazioni, tra cui firme digitali, crittografia asimmetrica, crittografia simmetrica, scambio di chiavi e altro ancora.
## Tipi di firma RSA
Il provider OpenSSL supporta le firme digitali RSA con più algoritmi di hash e schemi di padding:
SHA1withRSA
Firme RSA con algoritmo hash SHA-1
+ Imbottitura PKCS \$11 v1.5
+ Imbottitura PSS (Probabilistic Signature Scheme)
SHA224withRSA
Firme RSA con algoritmo hash SHA-224
+ Imbottitura PKCS \$11 v1.5
+ Imbottitura PSS
SHA256withRSA
Firme RSA con algoritmo hash SHA-256
+ Imbottitura PKCS \$11 v1.5
+ Imbottitura PSS
SHA384withRSA
Firme RSA con algoritmo hash SHA-384
+ Imbottitura PKCS \$11 v1.5
+ Imbottitura PSS
SHA512withRSA
Firme RSA con algoritmo hash SHA-512
+ Imbottitura PKCS \$11 v1.5
+ Imbottitura PSS
## Tipi di firma ECDSA
Il provider OpenSSL supporta le firme digitali ECDSA con più algoritmi hash:
SHA1withECDSA
Firme ECDSA con algoritmo hash SHA-1
SHA224withECDSA
Firme ECDSA con algoritmo hash SHA-224
SHA256withECDSA
Firme ECDSA con algoritmo hash SHA-256
SHA384withECDSA
Firme ECDSA con algoritmo hash SHA-384
SHA512withECDSA
Firme ECDSA con algoritmo hash SHA-512
# Configurazione avanzata del provider OpenSSL
L'SDK AWS CloudHSM OpenSSL Provider offre opzioni di configurazione avanzate per personalizzarne il comportamento per diversi casi d'uso e ambienti. Utilizza lo strumento di configurazione per impostare queste opzioni.
+ [Riprova la configurazione per OpenSSL Provider](openssl-provider-configs-retry.md)
# Riprova i comandi per OpenSSL Provider per AWS CloudHSM
AWS CloudHSM Client SDK 5.8.0 e versioni successive dispongono di una strategia di riprova automatica integrata che riproverà le operazioni con limitazione HSM dal lato client. Quando un HSM rallenta le operazioni perché è troppo occupato nell'esecuzione di operazioni precedenti e non può accettare altre richieste, il client SDKs tenterà di riprovare le operazioni limitate fino a 3 volte, effettuando un backup esponenziale. Questa strategia automatica può essere impostata su una delle due modalità: **off** e **standard**.
+ **off**: il Client SDK non eseguirà alcun ulteriore tentativo per le operazioni limitate da parte dell'HSM.
+ **standard**: questa è la modalità predefinita per Client SDK 5.8.0 e successive. In questa modalità, il client SDKs riproverà automaticamente le operazioni limitate effettuando un backup esponenziale.
Per ulteriori informazioni, consulta [Limitazione HSM](troubleshoot-hsm-throttling.md).
## Disattiva i comandi per l'esecuzione di ulteriori tentativi
------
#### [ Linux ]
**Come impostare i comandi Nuovo tentativo su **off** per Client SDK 5 su Linux**
+ Per impostare la configurazione in modalità **off**, utilizza i seguenti comandi:
```
$ sudo /opt/cloudhsm/bin/configure-openssl-provider --default-retry-mode off
```
------
# Provider di archiviazione delle chiavi (KSP) per AWS CloudHSM Client SDK 5
Key Storage Provider (KSP) è un'API crittografica specifica per il sistema operativo Microsoft Windows. Key Storage Provider (KSP) consente agli sviluppatori di utilizzare tecniche crittografiche per proteggere le applicazioni basate su Windows.
Per informazioni sul processo di bootstrap, consulta la pagina [Connessione al cluster](cluster-connect.md).
Per informazioni sull'utilizzo di Client SDK 3, vedi [Utilizzo della versione SDK precedente con cui lavorare AWS CloudHSM](choose-client-sdk.md).
**Topics**
+ [Installa il Key Storage Provider (KSP) per AWS CloudHSM Client SDK 5](ksp-library-install.md)
+ [Autenticazione al Key Storage Provider (KSP) per AWS CloudHSM Client SDK 5](ksp-library-authentication.md)
+ [Tipi di chiavi supportati per Key Storage Provider (KSP) for AWS CloudHSM Client SDK 5](ksp-library--key-types.md)
+ [Operazioni API supportate Key storage provider (KSP) per AWS CloudHSM Client SDK 5](ksp-library-apis.md)
+ [Configurazioni avanzate per KSP per AWS CloudHSM](ksp-library-configs.md)
# Installa il Key Storage Provider (KSP) per AWS CloudHSM Client SDK 5
Utilizza le seguenti sezioni per installare il Key storage provider (KSP) per AWS CloudHSM Client SDK 5.
**Nota**
Per eseguire un singolo cluster HSM con Client SDK 5, è necessario gestire innanzitutto le impostazioni di durabilità delle chiavi del client impostando `disable_key_availability_check` su `True`. Per ulteriori informazioni, consulta la pagina sulla [sincronizzazione delle chiavi](manage-key-sync.md) e la pagina sullo [strumento di configurazione di Client SDK 5](configure-sdk-5.md).
**Per installare e configurare il Key Storage Provider (KSP)**
1. Installa il Key Storage Provider (KSP) per Windows Server sull'architettura x86\$164, apri PowerShell come amministratore ed esegui il seguente comando:
```
PS C:\> wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Windows/AWSCloudHSMKSP-latest.msi -Outfile C:\AWSCloudHSMKSP-latest.msi
```
```
PS C:\> Start-Process msiexec.exe -ArgumentList '/i C:\AWSCloudHSMKSP-latest.msi /quiet /norestart /log C:\client-install.txt' -Wait
```
1. Utilizza lo strumento di configurazione per specificare la posizione del certificato emittente. Per istruzioni, consulta [Specifica la posizione del certificato di emissione](cluster-connect.md#specify-cert-location).
1. Per connetterti al cluster, consulta la pagina [Esegui il bootstrap di Client SDK](cluster-connect.md#connect-how-to).
1. È possibile trovare i file Key Storage Provider (KSP) nelle seguenti posizioni:
+ File binari Windows:
```
C:\Program Files\Amazon\CloudHSM
```
Script di configurazione e file di log Windows:
```
C:\ProgramData\Amazon\CloudHSM
```
# Autenticazione al Key Storage Provider (KSP) per AWS CloudHSM Client SDK 5
Prima di utilizzare il Key storage provider (KSP) per AWS CloudHSM Client SDK 5, è necessario impostare le credenziali di accesso per l'HSM sul sistema. Sono disponibili due opzioni:
+ Windows Credentials Manager (consigliato per una maggiore sicurezza)
+ Variabili di ambiente di sistema (configurazione più semplice)
## Gestione credenziali di Windows
È possibile configurare le credenziali utilizzando l'`set_cloudhsm_credentials`utilità o l'interfaccia di Windows Credentials Manager.
+ **Utilizzo dell'utility `set_cloudhsm_credentials`**:
Il programma di installazione di Windows include l'utilità. `set_cloudhsm_credentials` Puoi utilizzare questa utility per trasferire le credenziali di accesso HSM a Gestione credenziali di Windows. Se si desidera compilare questa utilità dai sorgenti, è possibile utilizzare il codice Python incluso nell'installatore.
1. Accedi a `C:\Program Files\Amazon\CloudHSM\tools\`.
1. Esegui il comando seguente:
```
set_cloudhsm_credentials.exe --username --password
```
+ **Utilizzo dell'interfaccia di gestione delle credenziali**:
1. Apri Credential Manager:
+ Inserisci `credential manager` nella casella di ricerca della barra delle applicazioni
+ **Seleziona Credential Manager**
1. Seleziona **Credenziali di Windows** per gestire le credenziali di Windows.
1. Seleziona **Aggiungi una credenziale generica**
1. Inserisci i seguenti dettagli:
+ **Indirizzo Internet o di rete**:`CLOUDHSM_PIN`.
+ **Nome utente**:**.
+ **Password**:**.
1. Seleziona **OK**
## Variabili di ambiente del sistema
Puoi impostare variabili di ambiente di sistema per identificare il tuo HSM e il tuo [utente crittografico](understanding-users.md#crypto-user-chsm-cli) (CU).
**avvertimento**
L'impostazione delle credenziali tramite le variabili di ambiente di sistema memorizza la password in testo non crittografato sul sistema. Per una maggiore sicurezza, utilizzate invece Windows Credential Manager.
È possibile impostare le variabili di ambiente utilizzando:
+ Tipo [https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/setx](https://docs.microsoft.com/en-us/windows-server/administration/windows-commands/setx).
+ Pannello di controllo **delle proprietà del sistema** di Windows (scheda **Avanzate**).
+ imposta variabili permanenti di ambiente di sistema Metodi [programmatici](https://msdn.microsoft.com/en-us/library/system.environment.setenvironmentvariable(v=vs.110).aspx).
Per impostare la variabile di ambiente di sistema:
**`CLOUDHSM_PIN=:`**
Identifica un [crypto user](understanding-users.md#crypto-user-chsm-cli) (CU) nell'HSM e fornisce tutte le informazioni di login richieste. La tua applicazione viene autenticata ed eseguita come questo CU. L'applicazione dispone delle autorizzazioni di questo CU e può visualizzare e gestire solo le chiavi di proprietà del CU e quelle con questi condivise. Per creare una nuova CU, utilizzate il comando [user create](cloudhsm_cli-user-create.md) nella CLI di CloudHSM. Per trovare quelli esistenti CUs, usa il comando [user list](cloudhsm_cli-user-list.md) nella CLI di CloudHSM.
Esempio:
```
setx /m CLOUDHSM_PIN test_user:password123
```
**Nota**
Quando imposti le variabili di ambiente CLOUDHSM\$1PIN, devi evitare qualsiasi carattere speciale che possa essere interpretato dalla tua shell.
# Tipi di chiavi supportati per Key Storage Provider (KSP) for AWS CloudHSM Client SDK 5
Il AWS CloudHSM Key Storage Provider (KSP) supporta i seguenti tipi di chiavi con Client SDK 5.
****
| Tipo di chiavi | Description |
| --- | --- |
| EC | Genera chiavi con le curve secp256r1 (P-256), secp384r1 (P-384) e secp521r1 (P-521). |
| RSA | Genera chiavi RSA a 2048, 3072 e 4096 bit. |
# Operazioni API supportate Key storage provider (KSP) per AWS CloudHSM Client SDK 5
I parametri del KSP sono definiti da Microsoft KSP. Per ulteriori informazioni, [consulta la documentazione Microsoft](https://learn.microsoft.com/en-us/windows/win32/api/ncrypt/).
Il Key Storage Provider (KSP) supporta le seguenti operazioni dell'API KSP per AWS CloudHSM Client SDK 5.
+ [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)
+ [NCryptOpenKey](ksp-library-apis-open-key.md)
+ [NCryptCreatePersistedKey](ksp-library-apis-create-persisted-key.md)
+ [NCryptGetProperty](ksp-library-apis-get-property.md)
+ [NCryptSetProperty](ksp-library-apis-set-property.md)
+ [NCryptFinalizeKey](ksp-library-apis-finalize-key.md)
+ [NCryptDeleteKey](ksp-library-apis-delete-key.md)
+ [NCryptFreeObject](ksp-library-apis-free-object.md)
+ [NCryptFreeBuffer](ksp-library-apis-free-buffer.md)
+ [NCryptIsAlgSupported](ksp-library-apis-is-alg-supported.md)
+ [NCryptEnumAlgorithms](ksp-library-apis-enum-algorithms.md)
+ [NCryptEnumKeys](ksp-library-apis-enum-keys.md)
+ [NCryptExportKey](ksp-library-apis-export-key.md)
+ [NCryptSignHash](ksp-library-apis-sign-hash.md)
+ [NCryptVerifySignature](ksp-library-apis-verify-signature.md)
# NCryptOpenStorageProvider funzione con Key Storage Provider (KSP)
La `NCryptOpenStorageProvider` funzione carica e inizializza il Key Storage Provider (KSP).
## Parameters
`phProvider`[fuori]
Un puntatore a una `NCRYPT_PROV_HANDLE` variabile che memorizza l'handle del provider.
`pszProviderName`[in]
Un puntatore a una stringa Unicode con terminazione nulla che identifica il provider di archiviazione delle chiavi. AWS CloudHSM Key Storage Provider (KSP) supporta i seguenti valori:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-open-provider.html)
I valori sono stringhe letterali a caratteri larghi, come indicato da L prima del valore letterale.
`dwFlags`[in]
Bandiere che modificano il comportamento della funzione. Nessun flag è definito per questa funzione.
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NTE\$1INVALID\$1PARAMETER | Uno o più parametri non sono validi. |
| NOTE\$1FAIL | L'operazione non è stata completata. |
# NCryptOpenKey con Key Storage Provider (KSP)
La `NCryptOpenKey` funzione apre una chiave esistente nel Key Storage Provider (KSP).
## Parameters
`hProvider`[in]
L'handle KSP che contiene la chiave. Usa [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)per ottenere la maniglia.
`phKey`[fuori]
Un puntatore a una `NCRYPT_KEY_HANDLE` variabile che memorizza la maniglia della chiave.
`pszKeyName`[in]
Un puntatore a una stringa Unicode con terminazione nulla contenente il nome della chiave.
`dwLegacyKeySpec`[in, non utilizzato]
AWS CloudHSM Key Storage Provider (KSP) non utilizza questo parametro.
`dwFlags`[nel]
Bandiere che modificano il comportamento della funzione. Nessun flag è definito per questa funzione.
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NTE\$1INVALID\$1PARAMETER | Uno o più parametri non sono validi. |
| NOTE\$1FAIL | L'operazione non è stata completata. |
| NTE\$1INVALID\$1HANDLE | L'handle in non è valido. `hProvider` |
| NET\$1BAD\$1KEYSET | Il nome chiave fornito non ha restituito un risultato univoco. |
# NCryptCreatePersistedKey con Key Storage Provider (KSP)
La `NCryptCreatePersistedKey` funzione crea una nuova chiave e la memorizza nel Key Storage Provider (KSP). È possibile utilizzare la [`NCryptSetProperty`](ksp-library-apis-set-property.md)funzione per impostarne le proprietà dopo la creazione. È necessario chiamare [`NCryptFinalizeKey`](ksp-library-apis-finalize-key.md)prima di poter utilizzare la chiave.
## Parameters
`hProvider`[in]
L'handle del provider di archiviazione delle chiavi in cui verrà creata la chiave. [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)Usalo per ottenere questa maniglia.
`phKey`[fuori]
L'indirizzo di una `NCRYPT_KEY_HANDLE` variabile che memorizza l'handle della chiave.
`pszAlgId`[in]
Un puntatore a una stringa Unicode con terminazione nulla che specifica l'identificatore dell'algoritmo crittografico per la creazione della chiave.
AWS CloudHSM Key Storage Provider (KSP) supporta i seguenti algoritmi:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-create-persisted-key.html)
`pszKeyName`[in, opzionale]
Un puntatore a una stringa Unicode con terminazione nulla che contiene il nome della chiave. Se questo parametro è NULL, questa funzione creerà una chiave effimera che non è persistente.
`dwLegacyKeySpec`[in, non utilizzato]
AWS CloudHSM Key Storage Provider (KSP) non utilizza questo parametro.
`dwFlags`[nel]
Bandiere per modificare il comportamento della funzione. Utilizzate zero o più dei seguenti valori:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-create-persisted-key.html)
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | La funzione è stata completata con successo. |
| NTE\$1INVALID\$1PARAMETER | Uno o più parametri non sono validi. |
| NOTE\$1FAIL | L'operazione non è stata completata. |
| NET\$1BAD\$1FLAGS | Il `dwFlags` parametro contiene un valore non valido. |
| NOT\$1NOT\$1SUPPORTED | Il `pszAlgId` parametro contiene un valore non supportato. |
| NTE\$1EXISTS | Esiste già una chiave con il nome specificato e l'operazione non è stata utilizzata. ` NCRYPT_OVERWRITE_KEY_FLAG` |
# NCryptGetProperty con Key Storage Provider (KSP)
La `NCryptGetProperty` funzione recupera i valori delle proprietà per un oggetto di archiviazione delle chiavi.
## Parameters
`hObject`[in]
La maniglia dell'oggetto di cui si desidera recuperare la proprietà. È possibile utilizzare:
+ Un provider handle () `NCRYPT_PROV_HANDLE`
+ Una maniglia chiave (`NCRYPT_KEY_HANDLE`)
`pszProperty `[in]
Un puntatore a una stringa Unicode con terminazione nulla contenente il nome della proprietà da recuperare.
Quando si utilizza`NCRYPT_PROV_HANDLE`, AWS CloudHSM Key Storage Provider (KSP) supporta i seguenti identificatori KSP:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-get-property.html)
Quando viene utilizzato`NCRYPT_KEY_HANDLE`, AWS CloudHSM Key Storage Provider (KSP) supporta i seguenti identificatori KSP:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-get-property.html)
I valori sono stringhe letterali a caratteri larghi, come indicato da L prima del valore letterale.
`pbOutput`[fuori]
L'indirizzo di un buffer per memorizzare il valore della proprietà. Specificare la dimensione del buffer utilizzando. `cbOutput`
Per determinare la dimensione del buffer richiesta, impostate questo parametro su NULL. La funzione memorizza la dimensione richiesta (in byte) nella posizione indicata da. `pcbResult`
`cbOutput`[in]
La dimensione del `pbOutput` buffer in byte.
`pcbResult`[fuori]
Un puntatore a una variabile DWORD che memorizza il numero di byte copiati nel buffer. `pbOutput`
Se `pbOutput` è NULL, memorizza la dimensione richiesta (in byte).
`dwFlags`[in]
Bandiere per modificare il comportamento della funzione. Puoi usare zero o:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-get-property.html)
Quando pszProperty è`NCRYPT_SECURITY_DESCR_PROPERTY`, usa uno o una combinazione di:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-get-property.html)
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NTE\$1INVALID\$1PARAMETER | Uno o più parametri non sono validi. |
| NOTE\$1FAIL | L'operazione non è stata completata. |
| NET\$1BAD\$1FLAGS | Il `dwFlags` parametro contiene un valore non valido. |
| NOT\$1NOT\$1SUPPORTED | Il `pszAlgId` parametro contiene un valore che non è supportato. |
| NTE\$1INVALID\$1HANDLE | L'handle in non è valido. `hObject` |
| NET\$1BUFFER\$1TOO\$1SMALL | Il `cbOutput` parametro è troppo piccolo per i valori restituiti. |
# NCryptSetProperty con Key Storage Provider (KSP)
La `NCryptSetProperty` funzione imposta i valori delle proprietà per un oggetto di archiviazione delle chiavi.
## Parameters
`hObject`[in]
La maniglia dell'oggetto di cui si desidera impostare la proprietà. È possibile utilizzare:
+ Un provider handle (`NCRYPT_PROV_HANDLE`)
+ Una maniglia chiave (`NCRYPT_KEY_HANDLE`)
`pszProperty `[in]
Un puntatore a una stringa Unicode con terminazione nulla contenente il nome della proprietà da recuperare.
Quando si utilizza`NCRYPT_PROV_HANDLE`, AWS CloudHSM Key Storage Provider (KSP) supporta i seguenti identificatori KSP:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-set-property.html)
Quando viene utilizzato`NCRYPT_KEY_HANDLE`, AWS CloudHSM Key Storage Provider (KSP) supporta i seguenti identificatori KSP:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-set-property.html)
I valori sono stringhe letterali a caratteri larghi, come indicato da L prima del valore letterale.
`pbInput`[in]
L'indirizzo di un buffer che contiene il nuovo valore della proprietà. `cbInput`contiene la dimensione del buffer.
`cbInput`[in]
La dimensione del `pbInput` buffer in byte.
`dwFlags`[in]
Bandiere che modificano il comportamento della funzione. Nessun flag è definito per questa funzione.
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NTE\$1INVALID\$1PARAMETER | Uno o più parametri non sono validi. |
| NOTE\$1FAIL | L'operazione non è stata completata. |
| NET\$1BAD\$1FLAGS | Il `dwFlags` parametro contiene un valore non valido. |
| NOT\$1NOT\$1SUPPORTED | Il `pszProperty` parametro contiene un valore che non è supportato. |
| NTE\$1INVALID\$1HANDLE | L'handle in non è valido. `hObject` |
| NET\$1BAD\$1DATA | I dati indicati da `pbInput` e non sono validi. `cbInput` |
# NCryptFinalizeKey con Key Storage Provider (KSP)
La `NCryptFinalizeKey` funzione completa una chiave KSP. È necessario chiamare questa funzione prima di poter utilizzare il tasto.
## Parameters
`hKey`[in]
La maniglia della chiave da completare. Ottieni questo handle chiamando la [NCryptCreatePersistedKey](ksp-library-apis-create-persisted-key.md)funzione.
`dwFlags`[in]
Bandiere per modificare il comportamento della funzione. Puoi usare zero o questi valori:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-finalize-key.html)
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NET\$1FAIL | L'operazione non è stata completata. |
| NTE\$1INVALID\$1HANDLE | L'handle in non è valido. `hKey` |
| NOT\$1NOT\$1SUPPORTED | Il `dwFlags` parametro contiene un valore non supportato. |
| NET\$1BAD\$1FLAGS | Il `dwFlags` parametro contiene un valore non valido. |
# NCryptDeleteKey con Key Storage Provider (KSP)
La `NCryptDeleteKey` funzione elimina una chiave KSP dal Key Storage Provider (KSP).
## Parameters
`hKey`[in]
La maniglia della chiave da eliminare.
`dwFlags`[in]
Bandiere per modificare il comportamento della funzione. È possibile utilizzare zero o più dei seguenti valori:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-delete-key.html)
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | La funzione ha avuto successo. |
| NTE\$1INVALID\$1PARAMETER | Uno o più parametri non sono validi. |
| NET\$1BAD\$1FLAGS | Il `dwFlags` parametro contiene un valore non valido. |
| NOTE\$1FAIL | L'operazione non è stata completata. |
| NTE\$1INVALID\$1HANDLE | L'handle in non è valido. `hKey` |
| NTE\$1INTERNAL\$1ERROR | Si è verificato un errore interno durante l'eliminazione della chiave. |
# NCryptFreeObject con Key Storage Provider (KSP)
La `NCryptFreeObject` funzione rilascia il provider o il key handle dal Key Storage Provider (KSP).
## Parameters
`hObject`[in]
La maniglia dell'oggetto da rilasciare. È possibile utilizzare:
+ Un provider handle (`NCRYPT_PROV_HANDLE`)
+ Una maniglia chiave (`NCRYPT_KEY_HANDLE`)
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NTE\$1INVALID\$1HANDLE | L'handle in non è valido. `hObject` |
# NCryptFreeBuffer con Key Storage Provider (KSP)
La `NCryptFreeBuffer` funzione rilascia un blocco di memoria allocato dal Key Storage Provider (KSP).
## Parameters
`pvInput`[in]
L'indirizzo della memoria da rilasciare.
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NET\$1FAIL | L'operazione non è stata completata. |
# NCryptIsAlgSupported con Key Storage Provider (KSP)
NCryptIsAlgSupported la funzione determina se Key Storage Provider (KSP) supporta uno specifico algoritmo crittografico.
## Parameters
`hProvider`[in]
L'handle del provider di archiviazione delle chiavi. [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)Usalo per prendere il manico.
`pszAlgId`[nel]
Un puntatore a una stringa Unicode con terminazione nulla che contiene l'identificatore dell'algoritmo crittografico per creare la chiave. AWS CloudHSM Key Storage Provider (KSP) supporta i seguenti algoritmi:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-is-alg-supported.html)
`dwFlags`[nel]
Bandiere che modificano il comportamento delle funzioni. Può essere zero o il seguente valore:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-is-alg-supported.html)
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NTE\$1INVALID\$1PARAMETER | Uno o più parametri non sono validi. |
| NET\$1BAD\$1FLAGS | Il `dwFlags` parametro contiene un valore non valido. |
| NOT\$1NOT\$1SUPPORTED | Il `pszAlgId` parametro contiene un valore non supportato. |
| NTE\$1INVALID\$1HANDLE | L'handle in non è valido. `hProvider` |
# NCryptEnumAlgorithms con Key Storage Provider (KSP)
La `NCryptEnumAlgorithms` funzione recupera i nomi degli algoritmi supportati dal Key Storage Provider (KSP).
## Parameters
`hProvider`[in]
L'handle del provider di archiviazione delle chiavi per il quale enumerare gli algoritmi. Utilizzate la [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)funzione per ottenere questo handle.
`dwAlgOperations`[in]
Un insieme di valori che specificano quali classi di algoritmi enumerare. È possibile utilizzare zero per enumerare tutti gli algoritmi o combinare uno o più di questi valori:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-enum-algorithms.html)
`pdwAlgCount`[fuori]
L'indirizzo di un DWORD che memorizza il numero di elementi nell'`ppAlgList`array.
`ppAlgList`[fuori]
L'indirizzo di un puntatore a `NCryptAlgorithmName` struttura che memorizza una matrice di nomi di algoritmi registrati. Il `pdwAlgCount` parametro indica il numero di elementi in questa matrice.
`dwFlags`[in]
Bandiere per modificare il comportamento della funzione. Usa zero o il seguente valore:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-enum-algorithms.html)
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NTE\$1INVALID\$1PARAMETER | Uno o più parametri non sono validi. |
| NOTE\$1FAIL | L'operazione non è stata completata. |
| NET\$1BAD\$1FLAGS | Il `dwFlags` parametro contiene un valore non valido. |
| NOT\$1NOT\$1SUPPORTED | Il `dwAlgOperations` parametro contiene un valore non supportato. |
# NCryptEnumKeys con Key Storage Provider (KSP)
NCryptEnumKeys function elenca le chiavi memorizzate nel Key Storage Provider (KSP).
## Parameters
`hProvider`[in]
L'handle del provider di archiviazione delle chiavi. [`NCryptOpenStorageProvider`](ksp-library-apis-open-provider.md)Usalo per ottenere questo handle.
`pszScope`[in, inutilizzato]
Imposta questo parametro su NULL.
`ppKeyName`[fuori]
Un indirizzo puntatore a una `NCryptKeyName` struttura che memorizza il nome della chiave. Per liberare questa memoria dopo l'uso, chiama`NCryptFreeBuffer`.
`ppEnumState`[dentro, fuori]
Un indirizzo puntatore VOID che tiene traccia dell'avanzamento dell'enumerazione. Il provider di archiviazione delle chiavi utilizza queste informazioni internamente per gestire la sequenza di enumerazione. Per iniziare una nuova enumerazione dall'inizio, imposta questo puntatore su NULL.
Per liberare questa memoria dopo aver completato l'enumerazione, passate questo puntatore a. `NCryptFreeBuffer`
`dwFlags`[in]
Bandiere per modificare il comportamento della funzione. Questa funzione non ha flag.
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NTE\$1INVALID\$1PARAMETER | Uno o più parametri non sono validi. |
| NOTE\$1FAIL | L'operazione non è stata completata. |
| NTE\$1INVALID\$1HANDLE | L'handle in non è valido. `hProvider` |
| NOTE\$1NO\$1MORE\$1ITEMS | L'enumerazione ha elencato tutte le chiavi disponibili. |
# NCryptExportKey con Key Storage Provider (KSP)
La `NCryptExportKey` funzione esporta una chiave KSP in una memoria. BLOB Questa funzione supporta solo l'esportazione di chiavi pubbliche.
## Parameters
`hKey`[in]
La maniglia della chiave da esportare.
`hExportKey`[in, inutilizzato]
AWS CloudHSM Key Storage Provider (KSP) non utilizza questo parametro.
`pszBlobType`[nel]
Una stringa Unicode con terminazione nulla che specifica il tipo da esportare. BLOB AWS CloudHSM Key Storage Provider (KSP) supporta i seguenti valori:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-export-key.html)
`pParameterList`[in, non utilizzato]
AWS CloudHSM Key Storage Provider (KSP) non utilizza questo parametro.
`pbOutput`[fuori, opzionale]
Un indirizzo buffer per memorizzare la chiave BLOB. Specificare la dimensione del buffer utilizzando. `cbOutput` Se impostata su NULL, la funzione memorizza la dimensione richiesta (in byte) nel DWORD a cui fa riferimento. `pcbResult`
`cbOutput`[in]
La dimensione del `pbOutput` buffer in byte.
`pcbResult`[fuori]
Un indirizzo variabile DWORD che memorizza il numero di byte copiati nel buffer. `pbOutput` Se `pbOutput` è NULL, la funzione memorizza la dimensione del buffer richiesta in byte.
`dwFlags`[in]
Bandiere che modificano il funzionamento della funzione. È possibile utilizzare zero o quanto segue:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-export-key.html)
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NTE\$1INVALID\$1PARAMETER | Uno o più parametri non sono validi. |
| NOTE\$1FAIL | L'operazione non è stata completata. |
| NTE\$1INVALID\$1HANDLE | L'handle in non è valido. `hProvider` |
| NET\$1BAD\$1FLAGS | Il `dwFlags` parametro contiene un valore non valido. |
| NOTE\$1BAD\$1KEY\$1STATE | Lo stato della chiave non è valido. |
| NOT\$1NOT\$1SUPPORTED | Il `dwFlags` parametro `pszBlobType` or contiene un valore non supportato. |
| STATUS\$1INTERNAL\$1ERROR | Si è verificato un errore interno durante l'operazione. |
# NCryptSignHash con Key Storage Provider (KSP)
La `NCryptSignHash` funzione crea una firma di un valore hash.
## Parameters
`hKey`[in]
L'handle della chiave da usare per firmare l'hash.
`pPaddingInfo`[in, opzionale]
Un puntatore a una struttura contenente informazioni di riempimento. Il tipo di struttura dipende dal valore. `dwFlags` Utilizzate questo parametro solo con chiavi asimmetriche; impostatelo su NULL per altri tipi di chiavi.
`pbHashValue`[in]
Un puntatore a un buffer contenente il valore hash da firmare. Specificate la dimensione del buffer utilizzando. `cbHashValue`
`cbHashValue`[in]
La dimensione, in byte, del `pbHashValue` buffer da firmare.
`pbSignature`[fuori]
L'indirizzo di un buffer per memorizzare la firma. Specificare la dimensione del buffer utilizzando. `cbSignature`
Per determinare la dimensione del buffer richiesta, impostate questo parametro su NULL. La funzione memorizza la dimensione richiesta (in byte) nella posizione indicata da. `pcbResult`
`cbSignature`[in]
La dimensione del `pbSignature` buffer in byte. La funzione ignora questo parametro se `pbSignature` è NULL.
`pcbResult`[fuori]
Un puntatore a una variabile DWORD che memorizza il numero di byte copiati nel buffer. `pbSignature`
Se `pbSignature` è NULL, memorizza la dimensione del buffer richiesta, in byte.
`dwFlags`[in]
Bandiere per modificare il comportamento della funzione. I flag consentiti dipendono dal tipo di chiave. Usa uno di questi valori:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-sign-hash.html)
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NTE\$1INVALID\$1PARAMETER | Uno o più parametri non sono validi. |
| NOTE\$1FAIL | L'operazione non è stata completata. |
| NTE\$1INVALID\$1HANDLE | L'handle in non è valido. `hKey` |
| NET\$1BAD\$1FLAGS | Il `dwFlags` parametro contiene un valore non valido. |
| NET\$1BUFFER\$1TOO\$1SMALL | Il `pcbOutput` parametro è troppo piccolo per i valori restituiti. |
| NET\$1BAD\$1KEY\$1STATE | Lo stato della chiave non è valido. |
| NTE\$1INTERNAL\$1ERROR | Si è verificato un errore interno durante la firma dell'hash. |
# NCryptVerifySignature con Key Storage Provider (KSP)
La `NCryptVerifySignature` funzione conferma se una firma corrisponde a un hash specificato.
## Parameters
`hKey`[in]
L'handle della chiave da usare per decrittografare la firma. È necessario utilizzare la parte della chiave pubblica della coppia di chiavi utilizzata per firmare i dati con [`NCryptSignHash`](ksp-library-apis-sign-hash.md).
`pPaddingInfo`[in, opzionale]
Un puntatore a una struttura contenente informazioni di riempimento. Il tipo di struttura dipende dal valore. `dwFlags` Utilizzate questo parametro solo con chiavi asimmetriche; impostatelo su NULL per altri tipi di chiavi.
`pbHashValue`[in]
Un puntatore a un buffer contenente il valore hash da firmare. Specificate la dimensione del buffer utilizzando. `cbHashValue`
`cbHashValue`[in]
La dimensione del `pbHashValue` buffer in byte.
`pbSignature`[fuori]
L'indirizzo di un buffer contenente l'hash firmato dei dati. Usa [`NCryptSignHash`](ksp-library-apis-sign-hash.md)per creare questa firma. Specificare la dimensione del buffer utilizzando`cbSignature`.
`cbSignature`[in]
La dimensione del `pbSignature` buffer in byte. Usa [`NCryptSignHash`](ksp-library-apis-sign-hash.md)per creare la firma.
`dwFlags`[in]
Bandiere per modificare il comportamento della funzione. I flag consentiti dipendono dal tipo di chiave. Usa uno di questi valori:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/ksp-library-apis-verify-signature.html)
## Valore restituito
La funzione restituisce un codice di stato per indicare l'esito positivo o negativo.
I codici di restituzione comuni includono:
****
| Codice di restituzione | Description |
| --- | --- |
| ERROR\$1SUCCESS | L'operazione è stata completata con successo. |
| NTE\$1INVALID\$1PARAMETER | Uno o più parametri non sono validi. |
| NOTE\$1FAIL | L'operazione non è stata completata. |
| NTE\$1INVALID\$1HANDLE | L'handle in non è valido. `hKey` |
| NET\$1BAD\$1FLAGS | Il `dwFlags` parametro contiene un valore non valido. |
| NOTE\$1BAD\$1SIGNATURE | La firma non è stata verificata. |
| NET\$1BAD\$1KEY\$1STATE | Lo stato della chiave non è valido. |
| NTE\$1INTERNAL\$1ERROR | Si è verificato un errore interno durante la verifica della firma. |
# Configurazioni avanzate per KSP per AWS CloudHSM
Il AWS CloudHSM Key Storage Provider (KSP) include la seguente configurazione avanzata, che non fa parte delle configurazioni generali utilizzate dalla maggior parte dei clienti. Queste configurazioni offrono funzionalità aggiuntive.
+ [SDK3 modalità di compatibilità per KSP](ksp-library-configs-sdk3-compatibility-mode.md)
# SDK3 modalità di compatibilità per Key Storage Provider (KSP) per AWS CloudHSM
Key Storage Provider (KSP) implementa diversi approcci per l'interazione con le chiavi HSM:
+ Client SDK 5: fornisce una comunicazione diretta con le chiavi memorizzate nell'HSM, eliminando la necessità di file di riferimento locali
+ Client SDK 3: mantiene i file locali sul server Windows che fungono da riferimenti alle chiavi archiviate nell'HSM, utilizzando questi file per facilitare le operazioni chiave
Per i clienti che migrano da Client SDK 3 a Client SDK 5, l'attivazione dell'opzione della modalità di SDK3 compatibilità supporta le operazioni che utilizzano i file di riferimento chiave esistenti preservando al contempo l'architettura di archiviazione delle chiavi HSM sottostante.
## Abilita la SDK3 modalità di compatibilità
------
#### [ Windows ]
**Per abilitare la modalità di SDK3 compatibilità per Key Storage Provider (KSP) for Client SDK 5 in Windows**
+ È possibile utilizzare il seguente comando per abilitare la modalità di SDK3 compatibilità:
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-ksp.exe" --enable-sdk3-compatibility-mode
```
------
## Disabilita la modalità di SDK3 compatibilità
------
#### [ Windows ]
**Per disabilitare la modalità di SDK3 compatibilità per Key Storage Provider (KSP) for Client SDK 5 in Windows**
+ È possibile utilizzare il seguente comando per disabilitare la modalità di SDK3 compatibilità:
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-ksp.exe" --disable-sdk3-compatibility-mode
```
------
# Provider JCE per AWS CloudHSM Client SDK 5
Il provider AWS CloudHSM JCE è un'implementazione del provider basata sul framework del provider Java Cryptographic Extension (JCE). JCE consente di eseguire operazioni di crittografia utilizzando Java Development Kit (JDK). In questa guida, il provider AWS CloudHSM JCE viene talvolta definito provider JCE. Utilizza il provider JCE e il JDK per trasferire le operazioni crittografiche sull'HSM. Per la risoluzione dei problemi, vedere. [Problemi noti relativi all'SDK JCE per AWS CloudHSM](ki-jce-sdk.md)
Per informazioni sull'utilizzo di Client SDK 3, vedi [Utilizzo della versione SDK precedente con cui lavorare AWS CloudHSM](choose-client-sdk.md).
**Topics**
+ [Installare il provider JCE per AWS CloudHSM Client SDK 5](java-library-install_5.md)
+ [Tipi di chiavi supportati per il provider JCE per AWS CloudHSM Client SDK 5](java-lib-keys_5.md)
+ [Nozioni di base sulla gestione delle chiavi nel provider JCE per AWS CloudHSM Client SDK 5](java-library-key-basics_5.md)
+ [Meccanismi supportati per il provider JCE per AWS CloudHSM Client SDK 5](java-lib-supported_5.md)
+ [Attributi chiave Java supportati per AWS CloudHSM Client SDK 5](java-lib-attributes_5.md)
+ [Esempi di codice per la libreria AWS CloudHSM software per Java for Client SDK 5](java-samples.md)
+ [AWS CloudHSM Fornitore JCE Javadocs](java-javadocs_5.md)
+ [AWS CloudHSM KeyStore Classe Java per Client SDK 5](alternative-keystore_5.md)
+ [Configurazioni avanzate per AWS CloudHSM JCE for Client SDK 5](java-lib-configs.md)
# Installare il provider JCE per AWS CloudHSM Client SDK 5
Il provider JCE per AWS CloudHSM Client SDK 5 è compatibile con OpenJDK 8, OpenJDK 11, OpenJDK 17, OpenJDK 21 e OpenJDK 25. Puoi scaricarli entrambi dal [sito Web di OpenJDK.](https://openjdk.java.net/)
Utilizza le seguenti sezioni per installare e fornire credenziali al provider.
**Nota**
Per eseguire un singolo cluster HSM con Client SDK 5, è necessario gestire innanzitutto le impostazioni di durabilità delle chiavi del client impostando `disable_key_availability_check` su `True`. Per ulteriori informazioni, consulta la pagina sulla [sincronizzazione delle chiavi](manage-key-sync.md) e la pagina sullo [strumento di configurazione di Client SDK 5](configure-sdk-5.md).
**Topics**
+ [Fase 1: Installare il provider JCE](#install-java-library_5)
+ [Fase 2: Fornire le credenziali al provider JCE](#java-library-credentials_5)
## Fase 1: Installare il provider JCE
1. Utilizza i seguenti comandi per scaricare e installare il provider JCE.
------
#### [ Amazon Linux 2023 ]
Installa il provider JCE per Amazon Linux 2023 sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-jce-latest.amzn2023.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.amzn2023.x86_64.rpm
```
Installa il provider JCE per Amazon Linux 2023 sull' ARM64 architettura:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Amzn2023/cloudhsm-jce-latest.amzn2023.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.amzn2023.aarch64.rpm
```
------
#### [ Amazon Linux 2 ]
Installa il provider JCE per Amazon Linux 2 sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-jce-latest.el7.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el7.x86_64.rpm
```
Installa il provider JCE per Amazon Linux 2 sull' ARM64 architettura:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-jce-latest.el7.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el7.aarch64.rpm
```
------
#### [ RHEL 10 (10.0\$1) ]
Installa il provider JCE per RHEL 10 sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-jce-latest.el10.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el10.x86_64.rpm
```
Installa il provider JCE per RHEL 10 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL10/cloudhsm-jce-latest.el10.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el10.aarch64.rpm
```
------
#### [ RHEL 9 (9.2\$1) ]
Installa il provider JCE per RHEL 9 (9.2\$1) sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-jce-latest.el9.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el9.x86_64.rpm
```
Installa il provider JCE per RHEL 9 (9.2\$1) sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL9/cloudhsm-jce-latest.el9.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el9.aarch64.rpm
```
------
#### [ RHEL 8 (8.3\$1) ]
Installa il provider JCE per RHEL 8 sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-jce-latest.el8.x86_64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el8.x86_64.rpm
```
Installa il provider JCE per RHEL 8 sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-jce-latest.el8.aarch64.rpm
```
```
$ sudo yum install ./cloudhsm-jce-latest.el8.aarch64.rpm
```
------
#### [ Ubuntu 24.04 LTS ]
Installa il provider JCE per Ubuntu 24.04 LTS sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-jce_latest_u24.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-jce_latest_u24.04_amd64.deb
```
Installa il provider JCE per Ubuntu 24.04 LTS sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Noble/cloudhsm-jce_latest_u24.04_arm64.deb
```
```
$ sudo apt install ./cloudhsm-jce_latest_u24.04_arm64.deb
```
------
#### [ Ubuntu 22.04 LTS ]
Installa il provider JCE per Ubuntu 22.04 LTS sull'architettura x86\$164:
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-jce_latest_u22.04_amd64.deb
```
```
$ sudo apt install ./cloudhsm-jce_latest_u22.04_amd64.deb
```
Installa il provider JCE per Ubuntu 22.04 LTS sull'architettura: ARM64
```
$ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Jammy/cloudhsm-jce_latest_u22.04_arm64.deb
```
```
$ sudo apt install ./cloudhsm-jce_latest_u22.04_arm64.deb
```
------
#### [ Windows Server ]
Installa il provider JCE per Windows Server sull'architettura x86\$164, apri PowerShell come amministratore ed esegui il seguente comando:
```
PS C:\> wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Windows/AWSCloudHSMJCE-latest.msi -Outfile C:\AWSCloudHSMJCE-latest.msi
```
```
PS C:\> Start-Process msiexec.exe -ArgumentList '/i C:\AWSCloudHSMJCE-latest.msi /quiet /norestart /log C:\client-install.txt' -Wait
```
------
1. Esegui il bootstrap di Client SDK 5. Per ulteriori informazioni sulle operazioni di bootstrap, consulta la pagina [Esegui il bootstrap di Client SDK](cluster-connect.md#connect-how-to).
1. Individua i seguenti file del provider JCE:
------
#### [ Linux ]
+ `/opt/cloudhsm/java/cloudhsm-.jar`
+ `/opt/cloudhsm/bin/configure-jce`
+ `/opt/cloudhsm/bin/jce-info`
------
#### [ Windows ]
+ `C:\Program Files\Amazon\CloudHSM\java\cloudhsm-.jar>`
+ `C:\Program Files\Amazon\CloudHSM\bin\configure-jce.exe`
+ `C:\Program Files\Amazon\CloudHSM\bin\jce_info.exe`
------
## Fase 2: Fornire le credenziali al provider JCE
Prima che l'applicazione Java possa utilizzare un HSM, quest'ultimo deve prima autenticare l'applicazione. HSMs eseguire l'autenticazione utilizzando un metodo di accesso esplicito o implicito.
**Accesso esplicito** questo metodo consente di fornire le credenziali AWS CloudHSM direttamente nell'applicazione. Utilizza il metodo dal [https://docs.oracle.com/javase/8/docs/api/java/security/AuthProvider.html](https://docs.oracle.com/javase/8/docs/api/java/security/AuthProvider.html), in cui si passa il nome utente CU, la password e l'ID nel modello di pin. Per ulteriori informazioni, vedi codice di esempio di [Accesso a un HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java).
**Accesso implicito ** questo metodo consente di impostare le credenziali AWS CloudHSM in un nuovo file di proprietà, proprietà del sistema, oppure come variabili di ambiente.
+ **Proprietà di sistema** Imposta le credenziali attraverso le proprietà di sistema durante l'esecuzione di un'applicazione. I seguenti esempi mostrano due modi differenti con cui è possibile eseguire questa operazione:
------
#### [ Linux ]
```
$ java -DHSM_USER= -DHSM_PASSWORD=
```
```
System.setProperty("HSM_USER","");
System.setProperty("HSM_PASSWORD","");
```
------
#### [ Windows ]
```
PS C:\> java -DHSM_USER= -DHSM_PASSWORD=
```
```
System.setProperty("HSM_USER","");
System.setProperty("HSM_PASSWORD","");
```
------
+ **Variabili di ambiente** Imposta le credenziali come variabili di ambiente.
**Nota**
Quando impostate le variabili di ambiente, dovete evitare qualsiasi carattere speciale che possa essere interpretato dalla vostra shell.
------
#### [ Linux ]
```
$ export HSM_USER=
$ export HSM_PASSWORD=
```
------
#### [ Windows ]
```
PS C:\> $Env:HSM_USER=""
PS C:\> $Env:HSM_PASSWORD=""
```
------
Le credenziali potrebbero non essere disponibili se l'applicazione non le fornisce o se viene eseguita un'operazione prima che l’HSM autentichi la sessione. In questi casi, la libreria software CloudHSM per Java cerca le credenziali nel seguente ordine:
1. Proprietà di sistema
1. Variabili di ambiente
# Tipi di chiavi supportati per il provider JCE per AWS CloudHSM Client SDK 5
La libreria AWS CloudHSM software per Java consente di generare i seguenti tipi di chiavi.
****
| Tipo di chiavi | Description |
| --- | --- |
| AES | Genera chiavi AES a 128, 192 e 256 bit. |
| Triplo DES (3DES, DESede) | Genera una chiave DES tripla a 192 bit. [*](#java-lib-keys_5-note-1) |
| EC | Genera coppie di chiavi EC - curve NIST secp224r1 (P-224), secp256r1 (P-256), secp256k1 (Blockchain), secp384r1 (P-384), e secp521r1 (P-521). |
| GENERIC\$1SECRET | Genera segreti generici da 1 a 800 byte. |
| HMAC | Supporto hash per SHA1,, SHA224, SHA256. SHA384 SHA512 |
| RSA | General chiavi RSA da 2048-bit a 4096-bit, con incrementi di 256 bit. |
\$1 In conformità con le linee guida del NIST, ciò non è consentito per i cluster in modalità FIPS dopo il 2023. Per i cluster in modalità non FIPS, è ancora consentito dopo il 2023. Per informazioni dettagliate, vedi [Conformità FIPS 140: meccanismo di deprecazione 2024](compliance-dep-notif.md#compliance-dep-notif-1).
# Nozioni di base sulla gestione delle chiavi nel provider JCE per AWS CloudHSM Client SDK 5
Le nozioni di base sulla gestione delle chiavi nel provider JCE implicano l'importazione, l'esportazione, il caricamento tramite handle, oppure l'eliminazione di chiavi. Per ulteriori informazioni su come gestire le chiavi, vedi l'esempio di codice [Gestire le chiavi](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java).
Puoi inoltre trovare ulteriori esempi di codice del provider JCE all'indirizzo[Esempi di codice](java-samples.md).
# Meccanismi supportati per il provider JCE per AWS CloudHSM Client SDK 5
Questo argomento fornisce informazioni sui meccanismi supportati per il provider JCE con AWS CloudHSM Client SDK 5. Per informazioni sulle interfacce e le classi di motori Java Cryptography Architecture (JCA) supportate da AWS CloudHSM, consultate i seguenti argomenti.
**Topics**
+ [Funzioni di generazione chiavi e coppie di chiavi](#java-gen-key-pairs-5)
+ [Funzioni di cifratura](#java-ciphers_5)
+ [Funzioni di firma e verifica](#java-sign-verify_5)
+ [Funzioni set digest](#java-digests_5)
+ [Funzioni di codice di autenticazione dei messaggi basato su hash (HMAC).](#java-mac_5)
+ [Funzioni di codice di autenticazione dei messaggi basato su crittografia (CMAC)](#java-cmac_5)
+ [Funzioni chiave dell'accordo](#java-key-derivation_5)
+ [Converti le chiavi in specifiche chiave utilizzando le principali fabbriche](#java-key-factories)
+ [Annotazioni sui meccanismi](#w2aac25c21c25c15c23)
## Funzioni di generazione chiavi e coppie di chiavi
La libreria AWS CloudHSM software per Java consente di utilizzare le seguenti operazioni per generare funzioni di chiavi e coppie di chiavi.
+ `RSA`
+ `EC`
+ `AES`
+ `DESede (Triple DES)`vedi nota[1](#java-gen-key-pairs-5-note-1)
+ `GenericSecret`
## Funzioni di cifratura
La libreria AWS CloudHSM software per Java supporta le seguenti combinazioni di algoritmi, modalità e padding.
| Algoritmo | Modalità | Padding | Note |
| --- | --- | --- | --- |
| AES | CBC | `AES/CBC/NoPadding` `AES/CBC/PKCS5Padding` | Implementa `Cipher.ENCRYPT_MODE` e `Cipher.DECRYPT_MODE`. Implementa `Cipher.UNWRAP_MODE for AES/CBC NoPadding` |
| AES | ECB | `AES/ECB/PKCS5Padding` `AES/ECB/NoPadding` | Implementa `Cipher.ENCRYPT_MODE` e `Cipher.DECRYPT_MODE`. |
| AES | CTR | `AES/CTR/NoPadding` | Implementa `Cipher.ENCRYPT_MODE` e `Cipher.DECRYPT_MODE`. |
| AES | GCM | `AES/GCM/NoPadding` | Implementa `Cipher.WRAP_MODE`, `Cipher.UNWRAP_MODE`, `Cipher.ENCRYPT_MODE` e `Cipher.DECRYPT_MODE`.Quando si esegue la crittografia AES-GCM, l'HSM ignora il vettore di inizializzazione (IV) nella richiesta e utilizza un IV da lui generato. Al termine dell'operazione, è necessario chiamare `Cipher.getIV()` per ottenere il IV. |
| AESWrap | ECB | `AESWrap/ECB/NoPadding` `AESWrap/ECB/PKCS5Padding` `AESWrap/ECB/ZeroPadding` | Implementa `Cipher.WRAP_MODE` e `Cipher.UNWRAP_MODE`. |
| DESede (Triplo DES) | CBC | `DESede/CBC/PKCS5Padding` `DESede/CBC/NoPadding` | Implementa `Cipher.ENCRYPT_MODE` e `Cipher.DECRYPT_MODE`. Vedi la nota [1](#java-gen-key-pairs-5-note-1) di seguito per una modifica imminente. |
| DESede (DES triplo) | ECB | `DESede/ECB/NoPadding` `DESede/ECB/PKCS5Padding` | Implementa `Cipher.ENCRYPT_MODE` e `Cipher.DECRYPT_MODE`. Vedi la nota [1](#java-gen-key-pairs-5-note-1) di seguito per una modifica imminente. |
| RSA | ECB | `RSA/ECB/PKCS1Padding` **vedi nota [1](#java-gen-key-pairs-5-note-1)** `RSA/ECB/OAEPPadding` `RSA/ECB/OAEPWithSHA-1ANDMGF1Padding` `RSA/ECB/OAEPWithSHA-224ANDMGF1Padding` `RSA/ECB/OAEPWithSHA-256ANDMGF1Padding` `RSA/ECB/OAEPWithSHA-384ANDMGF1Padding` `RSA/ECB/OAEPWithSHA-512ANDMGF1Padding` | Implementa `Cipher.WRAP_MODE`, `Cipher.UNWRAP_MODE`, `Cipher.ENCRYPT_MODE` e `Cipher.DECRYPT_MODE`. |
| RSA | ECB | `RSA/ECB/NoPadding` | Implementa `Cipher.ENCRYPT_MODE` e `Cipher.DECRYPT_MODE`. |
| RSAAESWrap | ECB | `RSAAESWrap/ECB/OAEPPadding` `RSAAESWrap/ECB/OAEPWithSHA-1ANDMGF1Padding` `RSAAESWrap/ECB/OAEPWithSHA-224ANDMGF1Padding` `RSAAESWrap/ECB/OAEPWithSHA-256ANDMGF1Padding` `RSAAESWrap/ECB/OAEPWithSHA-384ANDMGF1Padding` `RSAAESWrap/ECB/OAEPWithSHA-512ANDMGF1Padding` | Implementa `Cipher.WRAP_MODE` e `Cipher.UNWRAP_MODE`. |
## Funzioni di firma e verifica
La libreria AWS CloudHSM software per Java supporta i seguenti tipi di firma e verifica. Con Client SDK 5 e gli algoritmi di firma con hashing, i dati vengono sottoposti a hash localmente nel software prima di essere inviati all'HSM per la firma/verifica. Ciò significa che non ci sono limiti alla dimensione dei dati che possono essere sottoposti a hash dall'SDK.
**Tipi di firma RSA**
+ `NONEwithRSA`
+ `RSASSA-PSS`
+ `SHA1withRSA`
+ `SHA1withRSA/PSS`
+ `SHA1withRSAandMGF1`
+ `SHA224withRSA`
+ `SHA224withRSAandMGF1`
+ `SHA224withRSA/PSS`
+ `SHA256withRSA`
+ `SHA256withRSAandMGF1`
+ `SHA256withRSA/PSS`
+ `SHA384withRSA`
+ `SHA384withRSAandMGF1`
+ `SHA384withRSA/PSS`
+ `SHA512withRSA`
+ `SHA512withRSAandMGF1`
+ `SHA512withRSA/PSS`
**Tipi di firma ECDSA**
+ `NONEwithECDSA`
+ `SHA1withECDSA`
+ `SHA224withECDSA`
+ `SHA256withECDSA`
+ `SHA384withECDSA`
+ `SHA512withECDSA`
## Funzioni set digest
La libreria AWS CloudHSM software per Java supporta i seguenti digest di messaggi. Con Client SDK 5, l'hashing dei dati viene eseguito localmente nel software. Ciò significa che non ci sono limiti alla dimensione dei dati che possono essere sottoposti a hash dall'SDK.
+ `SHA-1`
+ `SHA-224`
+ `SHA-256`
+ `SHA-384`
+ `SHA-512`
## Funzioni di codice di autenticazione dei messaggi basato su hash (HMAC).
La libreria AWS CloudHSM software per Java supporta i seguenti algoritmi HMAC.
+ `HmacSHA1`(Dimensione massima dei dati in byte: 16288)
+ `HmacSHA224`(Dimensione massima dei dati in byte: 16256)
+ `HmacSHA256`(Dimensione massima dei dati in byte: 16288)
+ `HmacSHA384`(Dimensione massima dei dati in byte: 16224)
+ `HmacSHA512`(Dimensione massima dei dati in byte: 16224)
## Funzioni di codice di autenticazione dei messaggi basato su crittografia (CMAC)
CMACs (Codici di autenticazione dei messaggi basati su crittografia) crea codici di autenticazione dei messaggi (MACs) utilizzando un codice a blocchi e una chiave segreta. Differiscono dal fatto che utilizzano un metodo HMACs a chiave simmetrica a blocchi anziché un metodo di hashing. MACs
La libreria AWS CloudHSM software per Java supporta i seguenti algoritmi CMAC.
+ `AESCMAC`
## Funzioni chiave dell'accordo
La libreria AWS CloudHSM software per Java supporta ECDH con Key Derivation Functions (KDF). Sono supportati i seguenti tipi di KDF:
+ `ECDHwithX963SHA1KDF`Supporta l'algoritmo KDF X9.63 SHA1 [2](#kdf2)
+ `ECDHwithX963SHA224KDF`Supporta l'algoritmo KDF X9.63 SHA224 [2](#kdf2)
+ `ECDHwithX963SHA256KDF`Supporta l'algoritmo KDF X9.63 SHA256 [2](#kdf2)
+ `ECDHwithX963SHA384KDF`Supporta l'algoritmo KDF X9.63 SHA384 [2](#kdf2)
+ `ECDHwithX963SHA512KDF`Supporta l'algoritmo KDF X9.63 SHA512 [2](#kdf2)
## Converti le chiavi in specifiche chiave utilizzando le principali fabbriche
È possibile utilizzare le fabbriche di chiavi per convertire le chiavi in specifiche chiave. AWS CloudHSM dispone di due tipi di fabbriche chiave per JCE:
**SecretKeyFactory:** utilizzato per importare o derivare chiavi simmetriche. Utilizzando SecretKeyFactory, è possibile passare una chiave supportata o una chiave supportata KeySpec per importare o derivare chiavi simmetriche. AWS CloudHSM Di seguito sono riportate le specifiche supportate per: KeyFactory
+ Sono supportate le seguenti [KeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/KeySpec.html)classi SecretKeyFactory del `generateSecret` metodo For:
+ **KeyAttributesMap**può essere usato per importare byte chiave con attributi aggiuntivi come chiave CloudHSM. Un esempio può essere trovato [qui](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java).
+ **[SecretKeySpec](https://docs.oracle.com/javase/8/docs/api/javax/crypto/spec/SecretKeySpec.html)**può essere usato per importare una specifica chiave simmetrica come chiave CloudHSM.
+ **AesCmacKdfParameterSpec**può essere usato per derivare chiavi simmetriche utilizzando un'altra chiave AES CloudHSM.
**Nota**
SecretKeyFactory[il `translateKey` metodo accetta qualsiasi chiave che implementa l'interfaccia chiave.](https://docs.oracle.com/javase/8/docs/api/java/security/Key.html)
**KeyFactory:** utilizzato per importare chiavi asimmetriche. Utilizzando KeyFactory, è possibile passare una chiave supportata o supportata KeySpec per importare una chiave asimmetrica. AWS CloudHSM Per ulteriori informazioni, fai riferimento a queste risorse:
+ KeyFactoryIl `generatePublic` metodo di For, sono supportate le seguenti [KeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/KeySpec.html)classi:
+ KeyAttributesMap CloudHSM per RSA ed EC, tra cui: KeyTypes
+ KeyAttributesMap CloudhSM per RSA ed EC public. KeyTypes Un esempio può essere trovato [qui](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java)
+ [X509](https://docs.oracle.com/javase/8/docs/api/java/security/spec/X509EncodedKeySpec.html) sia EncodedKeySpec per RSA che per EC Public Key
+ [RSAPublicKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/RSAPublicKeySpec.html)per RSA Public Key
+ [ECPublicKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/ECPublicKeySpec.html)per EC Public Key
+ KeyFactoryIl `generatePrivate` metodo di For, sono supportate [KeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/KeySpec.html)le seguenti classi:
+ KeyAttributesMap CloudHSM per RSA ed EC, tra cui: KeyTypes
+ KeyAttributesMap CloudhSM per RSA ed EC public. KeyTypes Un esempio può essere trovato [qui](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java)
+ [PKCS8EncodedKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/PKCS8EncodedKeySpec.html)sia per EC che per RSA Private Key
+ [RSAPrivateCrtKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/RSAPrivateCrtKeySpec.html)per RSA Private Key
+ [ECPrivateKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/ECPrivateKeySpec.html)per EC Private Key
KeyFactoryIl `translateKey` metodo di For, accetta qualsiasi chiave che implementa l'[interfaccia chiave](https://docs.oracle.com/javase/8/docs/api/java/security/Key.html).
## Annotazioni sui meccanismi
[1] In conformità con le linee guida del NIST, ciò non è consentito per i cluster in modalità FIPS dopo il 2023. Per i cluster in modalità non FIPS, è ancora consentito dopo il 2023. Per informazioni dettagliate, vedi [Conformità FIPS 140: meccanismo di deprecazione 2024](compliance-dep-notif.md#compliance-dep-notif-1).
[2] Le principali funzioni di derivazione (KDFs) sono specificate nella pubblicazione [speciale 800-56A Revisione 3 del NIST](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Ar3.pdf).
# Attributi chiave Java supportati per AWS CloudHSM Client SDK 5
Questo argomento fornisce informazioni sugli attributi chiave Java supportati per AWS CloudHSM Client SDK 5. In questo argomento viene descritto come utilizzare un'estensione proprietaria per il provider JCE per impostare attributi chiave. Utilizzare questa estensione per impostare gli attributi della chiave supportati e i relativi valori durante le operazioni seguenti:
+ Generazione delle chiavi
+ Importazione delle chiavi
Per esempi di utilizzo degli attributi chiave, vedi [Esempi di codice per la libreria AWS CloudHSM software per Java for Client SDK 5](java-samples.md).
**Topics**
+ [Comprensione degli attributi](#java-understanding-attributes_5)
+ [Attributi supportati](#java-attributes_5)
+ [Impostazione attributi per una chiave](#java-setting-attributes_5)
## Comprensione degli attributi
Gli attributi chiave vengono utilizzati per specificare le operazioni consentite su oggetti chiave, incluse le chiavi pubbliche, private o segrete. Gli attributi e i valori della chiave vengono definiti durante le operazioni di creazione degli oggetti chiave.
Tuttavia, la Java Cryptography Extension (JCE) non specifica come impostare i valori sugli attributi chiave, pertanto la maggior parte delle operazioni erano consentite per impostazione predefinita. Al contrario, lo standard PKCS\$1 11 definisce un set completo di attributi con valori predefiniti più restrittivi. A partire dal provider JCE 3.1, AWS CloudHSM fornisce un'estensione proprietaria che consente di impostare valori più restrittivi per gli attributi di uso comune.
## Attributi supportati
Puoi impostare i valori per gli attributi elencati nella tabella sottostante. Come best practice, imposta i valori solo per gli attributi che desideri rendere restrittivi. Se non si specifica un valore, AWS CloudHSM utilizza il valore predefinito specificato nella tabella seguente. Una cella vuota nella colonna Valore predefinito indica che all'attributo non è stato assegnato alcun valore predefinito specifico.
****
| Attributo | Valore predefinito | Note | | Chiave simmetrica | Chiave pubblica in una coppia di chiavi | Chiave privata in una coppia di chiavi | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| DECRYPT | TRUE | | TRUE | Il valore Vero indica che è possibile utilizzare la chiave per decodificare qualsiasi buffer. Questo attributo è in genere impostato su FALSO per una chiave il cui WRAP è impostato su vero. |
| DERIVE | | | | Consente di utilizzare una chiave per derivare altre chiavi. |
| ENCRYPT | TRUE | TRUE | | Il valore Vero indica che è possibile utilizzare la chiave per crittografare qualsiasi buffer. |
| EXTRACTABLE | TRUE | | TRUE | Il valore Vero indica che è possibile esportare questa chiave dall'HSM. |
| ID | | | | Un valore definito dall'utente utilizzato per identificare la chiave. |
| KEY\$1TYPE | | | | Utilizzato per identificare il tipo di chiave (AES DESede, segreto generico, EC o RSA). |
| LABEL | | | | Una stringa definita dall'utente che consente di identificare comodamente le chiavi sull'HSM. Per seguire le best practice, utilizza un'etichetta univoca per ogni chiave in modo che sia più facile trovarla in seguito. |
| LOCAL | | | | Indica una chiave generata dall'HSM. |
| OBJECT\$1CLASS | | | | Utilizzato per identificare la classe dell'oggetto di una chiave (SecretKey, PublicKey o PrivateKey). |
| PRIVATE | TRUE | TRUE | TRUE | Il valore Vero indica che un utente potrebbe non poter accedere alla chiave finché l'utente non viene autenticato. Per motivi di chiarezza, gli utenti non possono accedere a nessuna chiave AWS CloudHSM finché non vengono autenticati, anche se questo attributo è impostato su FALSE. |
| SIGN | TRUE | | TRUE | Il valore Vero indica che è possibile utilizzare la chiave per firmare un messaggio di digest. In genere viene impostato su FALSO per le chiavi pubbliche e per le chiavi private archiviate. |
| SIZE | | | | Un attributo che definisce la dimensione di una chiave. Per maggiori dettagli sulle dimensioni delle chiavi supportate, vedi [Meccanismi supportati per Client SDK 5](https://docs.aws.amazon.com/cloudhsm/latest/userguide/java-lib-supported_5.html#java-keys_5). |
| TOKEN | FALSE | FALSE | FALSE | Una chiave permanente che viene replicata HSMs in tutto il cluster e inclusa nei backup. TOKEN = FALSO implica una chiave effimera, che viene cancellata automaticamente quando la connessione al HSM viene interrotta o ci si disconnette. |
| UNWRAP | TRUE | | TRUE | Il valore Vero indica che è possibile utilizzare la chiave per annullare il wrapping (importazione) di un'altra chiave. |
| VERIFY | TRUE | TRUE | | Il valore Vero indica che è possibile utilizzare la chiave per verificare una firma. In genere è impostato su FALSO per chiavi private. |
| WRAP | TRUE | TRUE | | Il valore Vero indica che è possibile utilizzare la chiave per eseguire il wrapping di un'altra chiave. In genere viene impostato su FALSO per chiavi private. |
| WRAP\$1WITH\$1TRUSTED | FALSE | | FALSE | Il valore Vero indica che una chiave può essere soggetta a wrapping e ad annullamento del wrapping con chiavi con l'attributo TRUSTED impostato su vero. Una volta che una chiave ha il valore WRAP\$1WITH\$1TRUSTED impostato su vero, tale attributo è di sola lettura e non può essere impostato su falso. Per saperne di più sul wrapping di fiducia, vedi [Utilizzo di chiavi fidate per controllare l'annullamento del wrapping delle chiavi](https://docs.aws.amazon.com/cloudhsm/latest/userguide/cloudhsm_using_trusted_keys_control_key_wrap.html). |
**Nota**
È possibile ottenere un supporto più ampio per gli attributi nella libreria PKCS \$111. Per ulteriori informazioni, vedi [Attributi PKCS \$111 supportati](pkcs11-attributes.md).
## Impostazione attributi per una chiave
`KeyAttributesMap` è un oggetto simile a Java Map che puoi utilizzare per impostare i valori degli attributi per gli oggetti chiave. I metodi per la funzione `KeyAttributesMap` sono simili a quelli utilizzati per la manipolazione della mappa Java.
Per impostare valori personalizzati sugli attributi, sono disponibili due opzioni:
+ Utilizzare i metodi elencati nella tabella seguente
+ Utilizzare i modelli di generatore illustrati più avanti in questo documento
Gli oggetti della mappa attributi supportano i seguenti metodi per impostare gli attributi:
****
| Operation | Valore restituito | Metodo `KeyAttributesMap` |
| --- | --- | --- |
| Ottenere il valore di un attributo chiave per una chiave esistente | Oggetto (contenente il valore) o nulla | **get**(keyAttribute) |
| Inserire il valore di un attributo chiave | Il valore precedente associato all'attributo chiave o nulla se non esiste alcuna mappatura per un attributo chiave | **put**(keyAttribute, value) |
| Compilare i valori per più attributi chiave | N/D | **PutAll** () keyAttributesMap |
| Rimuovere una coppia chiave-valore dalla mappa degli attributi | Il valore precedente associato all'attributo chiave o *nulla* se non esiste alcuna mappatura per un attributo chiave | **remove**(keyAttribute) |
**Nota**
Eventuali attributi non specificati in modo esplicito vengono impostati sui valori predefiniti elencati nella tabella precedente in [Attributi supportati](#java-attributes_5).
### Impostazione di attributi per una coppia di chiavi
Utilizza la classe Java `KeyPairAttributesMap` per gestire gli attributi chiave per una coppia di chiavi. `KeyPairAttributesMap` incapsula due oggetti `KeyAttributesMap`; uno per una chiave pubblica e uno per una chiave privata.
Per impostare singoli attributi per la chiave pubblica e la chiave privata separatamente, puoi utilizzare il metodo `put()` sull'oggetto mappa `KeyAttributes` corrispondente per tale chiave. Utilizza il metodo `getPublic()` per recuperare la mappa degli attributi per la chiave pubblica e utilizza `getPrivate()` per recuperare la mappa degli attributi per la chiave privata. Compila il valore di più attributi chiave insieme per coppie di chiavi pubbliche e private utilizzando la `putAll()` con una mappa degli attributi della coppia di chiavi come relativo argomento.
# Esempi di codice per la libreria AWS CloudHSM software per Java for Client SDK 5
Questo argomento fornisce risorse e informazioni sugli esempi di codice Java per AWS CloudHSM Client SDK 5.
## Prerequisiti
Prima di eseguire gli esempi, devi configurare l'ambiente:
+ Installa e configura il provider [Java Cryptographic Extension (JCE).](java-library-install_5.md#install-java-library_5)
+ Configura un [nome utente e una password HSM](manage-hsm-users.md) validi. Le autorizzazioni per l'utente di crittografia (CU) sono sufficienti per queste attività. L'applicazione utilizza queste credenziali per accedere all'HSM in ciascun esempio.
+ Decidi come fornire le credenziali al [provider JCE.](java-library-install_5.md#java-library-credentials_5)
## Esempi di codice
I seguenti esempi di codice mostrano come utilizzare il [provider JCE AWS CloudHSM](java-library.md) per eseguire attività di base. Altri esempi di codice sono disponibili su. [GitHub](https://github.com/aws-samples/aws-cloudhsm-jce-examples/tree/sdk5)
+ [Esegui l'accesso a un modulo HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java)
+ [Gestisci chiavi](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java)
+ [Genera di chiavi simmetriche](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/SymmetricKeys.java)
+ [Genera chiavi asimmetriche](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AsymmetricKeys.java)
+ [Crittografa e decodifica con AES-GCM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AESGCMEncryptDecryptRunner.java)
+ [Crittografa e decodifica con AES-CTR](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AESCTREncryptDecryptRunner.java)
+ Crittografa [e decrittografa con DESede](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/DESedeECBEncryptDecryptRunner.java) -ECB (vedi nota) [1](#java-samples-code-5-note-1)
+ [Firma e verifica con chiavi RSA](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/RSAOperationsRunner.java)
+ [Firma e verifica con Chiavi EC](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/ECOperationsRunner.java)
+ [Usa attributi chiave supportati](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyAttributesRunner.java)
+ [Utilizzo dell'archivio delle chiavi CloudHSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyStoreExampleRunner.java)
[1] In conformità alle linee guida del NIST, ciò non è consentito per i cluster in modalità FIPS dopo il 2023. Per i cluster in modalità non FIPS, è ancora consentito dopo il 2023. Per informazioni dettagliate, vedi [Conformità FIPS 140: meccanismo di deprecazione 2024](compliance-dep-notif.md#compliance-dep-notif-1).
# AWS CloudHSM Fornitore JCE Javadocs
Utilizza il provider JCE Javadocs per ottenere informazioni sull'utilizzo dei tipi e dei metodi Java definiti nell'SDK JCE di AWS CloudHSM. Per scaricare la versione più recente di Javadoc per AWS CloudHSM, consultate la [AWS CloudHSM ultima versione di Client SDK](latest-releases.md) sezione della pagina Download.
È possibile importare Javadocs in un ambiente di sviluppo integrato (IDE) o visualizzarli in un Web browser.
# AWS CloudHSM KeyStore Classe Java per Client SDK 5
La AWS CloudHSM `KeyStore` classe fornisce un archivio di chiavi per scopi speciali PKCS12 . Questo archivio chiavi può archiviare i certificati insieme ai dati della chiave e correlarli ai dati della chiave memorizzati su AWS CloudHSM. La AWS CloudHSM `KeyStore` classe implementa la `KeyStore` Service Provider Interface (SPI) della Java Cryptography Extension (JCE). [Per ulteriori informazioni sull'utilizzo`KeyStore`, vedete Class. KeyStore](https://devdocs.io/openjdk~8/java/security/keystore)
**Nota**
Poiché i certificati sono informazioni pubbliche e, per massimizzare la capacità di archiviazione delle chiavi crittografiche, non AWS CloudHSM supporta l'archiviazione dei certificati su. HSMs
## Scegli l'archivio di chiavi appropriato per AWS CloudHSM Client SDK 5
Il provider AWS CloudHSM Java Cryptographic Extension (JCE) offre un AWS CloudHSM per scopi speciali. KeyStore La AWS CloudHSM `KeyStore` classe supporta l'offload delle operazioni chiave sull'HSM, l'archiviazione locale dei certificati e le operazioni basate sui certificati.
Caricate il CloudHSM per scopi speciali come segue: KeyStore
```
KeyStore ks = KeyStore.getInstance("CloudHSM")
```
## Inizializza il Client SDK 5 AWS CloudHSM KeyStore
Effettua AWS CloudHSM KeyStore l'accesso nello stesso modo in cui accedi al provider JCE. È possibile utilizzare le variabili di ambiente o il file delle proprietà del sistema ed è necessario effettuare il login prima di iniziare a utilizzare CloudHSM KeyStore. Per un esempio di accesso a un HSM utilizzando JCE, vedi [Accedi a un HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java).
Se lo desideri, puoi specificare una password per crittografare il PKCS12 file locale che contiene i dati dell'archivio delle chiavi. Quando si crea il AWS CloudHSM Keystore, si imposta la password e la si fornisce quando si utilizzano i metodi load, set e get.
Crea un'istanza di un nuovo oggetto CloudHSM come segue KeyStore :
```
ks.load(null, null);
```
Scrivi i dati dell'archivio chiavi in un file utilizzando il metodo `store`. Da quel momento in poi, puoi caricare l'archivio chiavi esistente utilizzando il metodo `load` con il file sorgente e la password come segue:
```
ks.load(inputStream, password);
```
## Usa il nostro Client SDK 5 AWS CloudHSM KeyStore AWS CloudHSM
AWS CloudHSM KeyStore è conforme alle KeyStore specifiche della [classe](https://devdocs.io/openjdk~8/java/security/keystore) JCE e fornisce le seguenti funzioni.
+ `load`
Carica l'archivio chiavi dal flusso di input specificato. Se durante il salvataggio dell'archivio chiavi è stata impostata una password, è necessario fornire questa stessa password affinché il caricamento abbia esito positivo. Impostare entrambi i parametri su nulla per inizializzare un nuovo archivio di chiavi vuoto.
```
KeyStore ks = KeyStore.getInstance("CloudHSM");
ks.load(inputStream, password);
```
+ `aliases`
Restituisce un'enumerazione dei nomi alias di tutte le voci nell'istanza dell'archivio chiavi considerato. I risultati includono oggetti archiviati localmente nel PKCS12 file e oggetti residenti nell'HSM.
**Esempio di codice:**
```
KeyStore ks = KeyStore.getInstance("CloudHSM");
for(Enumeration entry = ks.aliases(); entry.hasMoreElements();) {
String label = entry.nextElement();
System.out.println(label);
}
```
+ `containsalias`
Restituisce vero se l'archivio chiavi ha accesso ad almeno un oggetto con l'alias specificato. L'archivio delle chiavi controlla gli oggetti archiviati localmente nel PKCS12 file e gli oggetti che risiedono sull'HSM.
+ `deleteEntry`
Elimina una voce di certificato dal file locale PKCS12 . L'eliminazione dei dati chiave memorizzati in un HSM non è supportata utilizzando. AWS CloudHSM KeyStore È possibile eliminare le chiavi utilizzando il metodo `destroy` dell'interfaccia [Distruggibile](https://devdocs.io/openjdk~8/javax/security/auth/destroyable#destroy--).
```
((Destroyable) key).destroy();
```
+ `getCertificate`
Restituisce il certificato associato a un alias, se disponibile. Se l'alias non esiste o fa riferimento a un oggetto che non è un certificato, la funzione restituisce NULLA.
```
KeyStore ks = KeyStore.getInstance("CloudHSM");
Certificate cert = ks.getCertificate(alias);
```
+ `getCertificateAlias`
Restituisce il nome (alias) della prima voce dell'archivio chiavi i cui dati corrispondono al certificato specificato.
```
KeyStore ks = KeyStore.getInstance("CloudHSM");
String alias = ks.getCertificateAlias(cert);
```
+ `getCertificateChain`
Restituisce la catena di certificati associata all'alias specificato. Se l'alias non esiste o fa riferimento a un oggetto che non è un certificato, la funzione restituisce NULLA.
+ `getCreationDate`
Restituisce la data di creazione della voce identificata dall'alias specificato. Se una data di creazione non è disponibile, la funzione restituisce la data in cui il certificato è diventato valido.
+ `getKey`
GetKey viene passato all'HSM e restituisce un oggetto chiave corrispondente all'etichetta specificata. Poiché interroga `getKey` direttamente l'HSM, può essere utilizzato per qualsiasi chiave sull'HSM indipendentemente dal fatto che sia stata generata da. KeyStore
```
Key key = ks.getKey(keyLabel, null);
```
+ `isCertificateEntry`
Controlla se la voce con l'alias specificato rappresenta una voce di certificato.
+ `isKeyEntry`
Controlla se la voce con l'alias specificato rappresenta una voce chiave. L'azione cerca l'alias sia nel PKCS12 file che nell'HSM.
+ `setCertificateEntry`
Assegna il certificato dato all'alias specificato. Se l'alias specificato è già in uso per identificare una chiave o un certificato, viene generata una `KeyStoreException`. È possibile utilizzare il codice JCE per ottenere l'oggetto chiave e quindi utilizzare il KeyStore `SetKeyEntry` metodo per associare il certificato alla chiave.
+ `setKeyEntry` con chiave `byte[]`
**Questa API non è attualmente supportata con Client SDK 5.**
+ `setKeyEntry` con oggetto `Key`
Assegna la chiave considerata all'alias specificato e la memorizza all'interno dell'HSM. Se la chiave non esiste già all'interno dell'HSM, verrà importata nell'HSM come chiave di sessione estraibile.
Se l'oggetto `Key` è di tipo `PrivateKey`, deve essere accompagnato da una catena di certificati corrispondente.
Se l'alias esiste già, la chiamata `SetKeyEntry` genera un `KeyStoreException` e impedisce la sovrascrittura della chiave. Se la chiave deve essere sovrascritta, utilizza KMU o JCE a tale scopo.
+ `engineSize`
Restituisce il numero di voci nell'archivio chiavi.
+ `store`
Memorizza l'archivio delle chiavi nel flusso di output specificato come PKCS12 file e lo protegge con la password specificata. Inoltre, persiste tutte le chiavi caricate (che sono impostate usando le chiamate `setKey`).
# Configurazioni avanzate per AWS CloudHSM JCE for Client SDK 5
Il provider AWS CloudHSM JCE include le seguenti configurazioni avanzate, che non fanno parte delle configurazioni generali utilizzate dalla maggior parte dei clienti.
+ [Connessione a più cluster](java-lib-configs-multi.md)
+ [Estrazione delle chiavi tramite JCE](java-lib-configs-getencoded.md)
+ [Riprova la configurazione per JCE](java-lib-configs-retry.md)
# Connessione a più AWS CloudHSM cluster con il provider JCE
Questa configurazione consente a una singola istanza client di comunicare con più AWS CloudHSM cluster. Rispetto al fatto che una singola istanza comunica solo con un singolo cluster, questa può essere una funzionalità che in alcuni casi consente di risparmiare sui costi. La `CloudHsmProvider` classe è l'implementazione AWS CloudHSM della [classe Provider di Java Security](https://docs.oracle.com/javase/8/docs/api/java/security/Provider.html). Ogni istanza di questa classe rappresenta una connessione all'intero AWS CloudHSM cluster. Si crea un'istanza di questa classe e la si aggiunge all'elenco del provider di sicurezza Java in modo da poter interagire con essa utilizzando classi JCE standard.
L'esempio seguente crea un'istanza di questa classe e la aggiunge all'elenco del provider di sicurezza Java:
```
if (Security.getProvider(CloudHsmProvider.PROVIDER_NAME) == null) {
Security.addProvider(new CloudHsmProvider());
}
```
`CloudHsmProvider` può essere configurato in due modi:
1. Configura con file (configurazione predefinita)
1. Configura usando il codice
I seguenti argomenti descrivono queste configurazioni e come connettersi a più cluster.
**Topics**
+ [Configura la AWS CloudHSM `CloudHsmProvider` classe con un file (configurazione predefinita)](java-lib-configs-default.md)
+ [Configura la AWS CloudHSM `CloudHsmProvider` classe usando il codice](java-lib-configs-using-code.md)
+ [Connect a più AWS CloudHSM cluster](java-lib-connecting-to-multiclusters.md)
# Configura la AWS CloudHSM `CloudHsmProvider` classe con un file (configurazione predefinita)
Il modo predefinito per configurare la AWS CloudHSM `CloudHsmProvider` classe è con un file.
Quando si crea un'istanza `CloudHsmProvider` utilizzando il costruttore predefinito, per impostazione predefinita cercherà il file di configurazione nel percorso `/opt/cloudhsm/etc/cloudhsm-jce.cfg` in Linux. Questo file di configurazione può essere configurato utilizzando `configure-jce`.
Un oggetto creato utilizzando il costruttore predefinito utilizzerà il nome del provider CloudHSM predefinito `CloudHSM`. Il nome del provider è utile per interagire con JCE e fargli sapere quale provider utilizzare per varie operazioni. Di seguito è riportato un esempio di utilizzo del nome del provider CloudHSM per il funzionamento della crittografia:
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "CloudHSM");
```
# Configura la AWS CloudHSM `CloudHsmProvider` classe usando il codice
A partire dalla versione 5.8.0 di Client SDK, puoi anche configurare la AWS CloudHSM `CloudHsmProvider` classe utilizzando il codice Java. Il modo per farlo è usare un oggetto di classe `CloudHsmProviderConfig`. È possibile creare l'oggetto utilizzando `CloudHsmProviderConfigBuilder`.
`CloudHsmProvider` ha un altro costruttore che accetta l'oggetto `CloudHsmProviderConfig`, come mostra l'esempio seguente.
**Example**
```
CloudHsmProviderConfig config = CloudHsmProviderConfig.builder()
.withCluster(
CloudHsmCluster.builder()
.withHsmCAFilePath(hsmCAFilePath)
.withClusterUniqueIdentifier("CloudHsmCluster1")
.withServer(CloudHsmServer.builder().withHostIP(hostName).build())
.build())
.build();
CloudHsmProvider provider = new CloudHsmProvider(config);
```
In questo esempio, il nome del provider JCE è. `CloudHsmCluster1` Questo è il nome che l'applicazione può quindi utilizzare per interagire con JCE:
**Example**
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "CloudHsmCluster1");
```
In alternativa, le applicazioni possono anche utilizzare l'oggetto provider creato sopra per far sapere a JCE di utilizzare quel provider per l'operazione:
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", provider);
```
Se con il metodo `withClusterUniqueIdentifier` non viene specificato un identificatore univoco, viene creato automaticamente un nome casuale. Per ottenere questo identificatore casuale, le applicazioni possono chiamare `provider.getName()` per ottenere l'identificatore.
# Connect a più AWS CloudHSM cluster
Ciascuno `CloudHsmProvider` rappresenta una connessione al tuo AWS CloudHSM Cluster. Se si desidera comunicare con un altro cluster dalla stessa applicazione, è possibile creare un altro oggetto `CloudHsmProvider` con configurazioni per l'altro cluster e interagire con quest'altro cluster utilizzando l'oggetto provider o utilizzando il nome del provider, come illustrato nell'esempio seguente.
**Example**
```
CloudHsmProviderConfig config = CloudHsmProviderConfig.builder()
.withCluster(
CloudHsmCluster.builder()
.withHsmCAFilePath(hsmCAFilePath)
.withClusterUniqueIdentifier("CloudHsmCluster1")
.withServer(CloudHsmServer.builder().withHostIP(hostName).build())
.build())
.build();
CloudHsmProvider provider1 = new CloudHsmProvider(config);
if (Security.getProvider(provider1.getName()) == null) {
Security.addProvider(provider1);
}
CloudHsmProviderConfig config2 = CloudHsmProviderConfig.builder()
.withCluster(
CloudHsmCluster.builder()
.withHsmCAFilePath(hsmCAFilePath2)
.withClusterUniqueIdentifier("CloudHsmCluster2")
.withServer(CloudHsmServer.builder().withHostIP(hostName2).build())
.build())
.build();
CloudHsmProvider provider2 = new CloudHsmProvider(config2);
if (Security.getProvider(provider2.getName()) == null) {
Security.addProvider(provider2);
}
```
Dopo aver configurato entrambi i provider (entrambi i cluster) sopra, è possibile interagire con essi utilizzando l'oggetto provider o utilizzando il nome del provider.
Ampliando questo esempio che mostra come parlare con`cluster1`, è possibile utilizzare il seguente esempio per un'AES/GCM/NoPaddingoperazione:
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", provider1);
```
E nella stessa applicazione per eseguire la generazione di chiavi "AES" sul secondo cluster utilizzando il nome del provider, è possibile utilizzare anche il seguente esempio:
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", provider2.getName());
```
# Estrazione delle chiavi con JCE per AWS CloudHSM
La Java Cryptography Extension (JCE) utilizza un'architettura che consente di collegare diverse implementazioni di crittografia. AWS CloudHSM fornisce uno di questi provider JCE che trasferisce le operazioni crittografiche all'HSM. Affinché la maggior parte degli altri provider JCE lavori con le chiavi archiviate in AWS CloudHSM, devono estrarre i byte chiave HSMs dal testo in chiaro nella memoria della macchina per utilizzarli. HSMs in genere consentono l'estrazione delle chiavi solo come oggetti avvolti, non come testo in chiaro. Tuttavia, per supportare i casi d'uso di integrazione tra provider, AWS CloudHSM consente un'opzione di configurazione opt-in per consentire l'estrazione dei byte delle chiavi in chiaro.
**Importante**
JCE trasferisce le operazioni AWS CloudHSM ogni volta che viene specificato il provider AWS CloudHSM o AWS CloudHSM viene utilizzato un oggetto chiave. Non è necessario estrarre le chiavi in chiaro se si prevede che l'operazione avvenga all'interno dell'HSM. L'estrazione delle chiavi in testo non crittografato è necessaria solo quando l'applicazione non può utilizzare meccanismi sicuri come eseguire e annullare il wrapping di una chiave a causa delle restrizioni imposte da una libreria di terze parti o da un provider JCE.
Per impostazione predefinita, il provider AWS CloudHSM JCE consente l'estrazione di **chiavi pubbliche** per funzionare con provider JCE esterni. I seguenti metodi sono sempre consentiti:
| Classe | Metodo | Formato (getEncoded) |
| --- | --- | --- |
| EcPublicKey | getEncoded() | X.509 |
| | getW() | N/D |
| RSAPublicChiave | getEncoded() | X.509 |
| | getPublicExponent() | N/D |
| CloudHsmRsaPrivateCrtKey | getPublicExponent() | N/D |
Per impostazione predefinita, il provider AWS CloudHSM JCE non consente l'estrazione di byte di chiave in chiaro per le chiavi **private** o **segrete**. Se il tuo caso d'uso lo richiede, puoi abilitare l'estrazione dei byte di chiave in chiaro per le chiavi **private** o **segrete** alle seguenti condizioni:
1. L'attributo `EXTRACTABLE` per le chiavi private e segrete è impostato su **true**.
+ Per impostazione predefinita, l'attributo `EXTRACTABLE` per le chiavi private e segrete è impostato su **true**. Le chiavi `EXTRACTABLE` sono chiavi che possono essere esportate dall'HSM. Per ulteriori informazioni, vedi Attributi Java supportati per [Client SDK 5](java-lib-attributes_5.md).
1. L'attributo `WRAP_WITH_TRUSTED` per le chiavi private e segrete è impostato su **falso**.
+ `getEncoded`, `getPrivateExponent` e `getS` non possono essere utilizzate con chiavi private che non possono essere esportate in chiaro. `WRAP_WITH_TRUSTED` non consente l'esportazione delle chiavi private dall'HSM in chiaro. Per maggiori informazioni, vedi [Using trusted keys to control key unwraps](manage-keys-using-trusted-keys.md).
# Consenti al provider JCE di estrarre chiavi private segrete da AWS CloudHSM
Utilizza i seguenti passaggi per consentire al provider AWS CloudHSM JCE di estrarre i segreti della tua chiave privata.
**Importante**
Questa modifica alla configurazione consente l'estrazione di tutti i byte chiave `EXTRACTABLE` in chiaro dal cluster HSM. Per una maggiore sicurezza, è consigliabile prendere in considerazione l'utilizzo di [metodi di wrapping di chiavi](java-lib-supported_5.md) per estrarre la chiave dall'HSM in modo sicuro. Ciò impedisce l'estrazione involontaria dei byte della chiave dall'HSM.
1. Utilizza i seguenti comandi per consentire l'estrazione delle chiavi **private** o **segrete** in JCE:
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/configure-jce --enable-clear-key-extraction-in-software
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-jce.exe" --enable-clear-key-extraction-in-software
```
------
1. Una volta abilitata l'estrazione delle chiavi in chiaro, vengono abilitati i seguenti metodi per estrarre le chiavi private in memoria.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/cloudhsm/latest/userguide/get-encoded-take-out-private-keys.html)
Se desideri ripristinare il comportamento predefinito e non consentire a JCE di esportare le chiavi in chiaro, esegui il seguente comando:
------
#### [ Linux ]
```
$ /opt/cloudhsm/bin/configure-jce --disable-clear-key-extraction-in-software
```
------
#### [ Windows ]
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-jce.exe" --disable-clear-key-extraction-in-software
```
------
# Riprova i comandi per JCE per AWS CloudHSM
AWS CloudHSM Client SDK 5.8.0 e versioni successive dispongono di una strategia di riprova automatica integrata che riproverà le operazioni con limitazione HSM dal lato client. Quando un HSM rallenta le operazioni perché è troppo occupato nell'esecuzione di operazioni precedenti e non può accettare altre richieste, il client SDKs tenterà di riprovare le operazioni limitate fino a 3 volte, effettuando un backup esponenziale. Questa strategia automatica può essere impostata su una delle due modalità: **off** e **standard**.
+ **off**: il Client SDK non eseguirà alcun ulteriore tentativo per le operazioni limitate da parte dell'HSM.
+ **standard**: questa è la modalità predefinita per Client SDK 5.8.0 e successive. In questa modalità, il client SDKs riproverà automaticamente le operazioni limitate effettuando un backup esponenziale.
Per ulteriori informazioni, consulta [Limitazione HSM](troubleshoot-hsm-throttling.md).
## Disattiva i comandi per l'esecuzione di ulteriori tentativi
------
#### [ Linux ]
**Come impostare i comandi Nuovo tentativo su **off** per Client SDK 5 su Linux**
+ Per impostare la configurazione in modalità **off**, utilizza i seguenti comandi:
```
$ sudo /opt/cloudhsm/bin/configure-jce --default-retry-mode off
```
------
#### [ Windows ]
**Per impostare i comandi Nuovo Tentativo su **off** per Client SDK 5 su Windows**
+ Per impostare la configurazione in modalità **off**, utilizza i seguenti comandi:
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-jce.exe" --default-retry-mode off
```
------