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à.
# 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).