Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Proveedor de JCE para AWS CloudHSM Client SDK 5
El proveedor AWS CloudHSM JCE es una implementación de proveedor creada a partir del marco de proveedores de Java Cryptographic Extension (JCE). El JCE le permite llevar a cabo operaciones criptográficas usando el kit de desarrollo de Java (JDK). En esta guía, el proveedor de AWS CloudHSM JCE a veces se denomina proveedor de JCE. Utilice el proveedor de JCE y el JDK para transferir las operaciones criptográficas de descarga al HSM. Para obtener información sobre la solución de problemas, consulte [Problemas conocidos del SDK de JCE para AWS CloudHSM](ki-jce-sdk.md).
Para obtener información acerca del uso del SDK 3 de cliente, consulte [Uso de la versión anterior del SDK para trabajar con AWS CloudHSM](choose-client-sdk.md).
**Topics**
+ [Instale el proveedor JCE para AWS CloudHSM Client SDK 5](java-library-install_5.md)
+ [Tipos de claves compatibles con el proveedor de JCE para AWS CloudHSM Client SDK 5](java-lib-keys_5.md)
+ [Conceptos básicos de administración clave en el proveedor de JCE para AWS CloudHSM Client SDK 5](java-library-key-basics_5.md)
+ [Mecanismos compatibles con el proveedor de JCE para AWS CloudHSM Client SDK 5](java-lib-supported_5.md)
+ [Atributos clave de Java compatibles con AWS CloudHSM Client SDK 5](java-lib-attributes_5.md)
+ [Ejemplos de código de la biblioteca de AWS CloudHSM software para Java for Client SDK 5](java-samples.md)
+ [AWS CloudHSM Proveedor de ICE Javadocs](java-javadocs_5.md)
+ [AWS CloudHSM KeyStore Clase Java para Client SDK 5](alternative-keystore_5.md)
+ [Configuraciones avanzadas para AWS CloudHSM JCE for Client SDK 5](java-lib-configs.md)
# Instale el proveedor JCE para AWS CloudHSM Client SDK 5
El proveedor de JCE para AWS CloudHSM Client SDK 5 es compatible con OpenJDK 8, OpenJDK 11, OpenJDK 17, OpenJDK 21 y OpenJDK 25. Puede descargar ambos desde el [sitio web de OpenJDK](https://openjdk.java.net/).
Use las siguientes secciones para instalar y proporcionar credenciales al proveedor.
**nota**
Para ejecutar un único clúster de HSM con SDK 5 de cliente, primero debe administrar la configuración de durabilidad de la clave del cliente configurando `disable_key_availability_check` en `True`. Para obtener más información, consulte [Sincronización de claves](manage-key-sync.md) y [Herramienta de configuración de SDK 5 de cliente](configure-sdk-5.md).
**Topics**
+ [Paso 1: Instalar el proveedor de JCE](#install-java-library_5)
+ [Paso 2: Proporcionar las credenciales al proveedor de JCE](#java-library-credentials_5)
## Paso 1: Instalar el proveedor de JCE
1. Utilice el siguiente comando para descargar e instalar el proveedor de JCE.
------
#### [ Amazon Linux 2023 ]
Instale el proveedor de JCE para Amazon Linux 2023 en arquitectura 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
```
Instale el proveedor JCE para Amazon Linux 2023 en la ARM64 arquitectura:
```
$ 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 ]
Instale el proveedor de JCE para Amazon Linux 2 en arquitectura 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
```
Instale el proveedor JCE para Amazon Linux 2 en la ARM64 arquitectura:
```
$ 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) ]
Instale el proveedor JCE para RHEL 10 en una arquitectura 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
```
Instale el proveedor JCE para RHEL 10 en la arquitectura: 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) ]
Instale el proveedor de JCE para RHEL 9 (9.2\$1) en arquitectura 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
```
Instale el proveedor JCE para RHEL 9 (9.2\$1) en la arquitectura: 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) ]
Instale el proveedor de JCE para RHEL 8 en arquitectura 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
```
Instale el proveedor JCE para RHEL 8 en la arquitectura: 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 ]
Instale el proveedor JCE para Ubuntu 24.04 LTS en una arquitectura 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
```
Instale el proveedor JCE para Ubuntu 24.04 LTS en la arquitectura: 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 ]
Instale el proveedor de JCE para Ubuntu 22.04 LTS en arquitectura 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
```
Instale el proveedor JCE para Ubuntu 22.04 LTS en la arquitectura: 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 ]
Instale el proveedor JCE para Windows Server en una arquitectura x86\$164, ábralo PowerShell como administrador y ejecute el siguiente 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. Iniciar SDK 5 de cliente. Para obtener más información sobre las acciones de arranque, consulte [Proceso de arranque del SDK de cliente](cluster-connect.md#connect-how-to).
1. Localice los siguientes archivos de proveedor de 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`
------
## Paso 2: Proporcionar las credenciales al proveedor de JCE
Antes de que la aplicación Java pueda utilizar un HSM, el HSM debe autenticar primero la aplicación. HSMs autentifíquese mediante un método de inicio de sesión explícito o implícito.
**Inicio de sesión explícito**: este método le permite proporcionar las credenciales de AWS CloudHSM directamente en la aplicación. Utiliza el método [https://docs.oracle.com/javase/8/docs/api/java/security/AuthProvider.html](https://docs.oracle.com/javase/8/docs/api/java/security/AuthProvider.html), en el que se pasa el nombre de usuario y la contraseña del CU en el patrón pin. Para obtener más información, consulte el ejemplo de código [Inicio de sesión en un HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java).
**Inicio de sesión implícito**: este método le permite definir las credenciales de AWS CloudHSM en un nuevo archivo de propiedades, en las propiedades del sistema o como variables de entorno.
+ **Propiedades del sistema**: defina las credenciales mediante las propiedades del sistema al ejecutar la aplicación. En los siguientes ejemplos, se muestran dos maneras diferentes de hacerlo:
------
#### [ 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","");
```
------
+ **Variables de entorno**: defina las credenciales como variables de entorno.
**nota**
Al configurar las variables de entorno, debe evitar cualquier carácter especial que pueda interpretar el intérprete de comandos.
------
#### [ Linux ]
```
$ export HSM_USER=
$ export HSM_PASSWORD=
```
------
#### [ Windows ]
```
PS C:\> $Env:HSM_USER=""
PS C:\> $Env:HSM_PASSWORD=""
```
------
Es posible que las credenciales no estén disponibles si la aplicación no las proporciona o si se intenta realizar una operación antes de que el HSM autentique la sesión. En esos casos, la biblioteca de software de CloudHSM para Java busca las credenciales en el orden que se indica a continuación:
1. Propiedades del sistema
1. Variables de entorno
# Tipos de claves compatibles con el proveedor de JCE para AWS CloudHSM Client SDK 5
La biblioteca de AWS CloudHSM software para Java permite generar los siguientes tipos de claves.
****
| Tipo de clave | Description (Descripción) |
| --- | --- |
| AES | Genere claves AES de 128, 192 y 256 bits. |
| Triple DES (3DES, DESede) | Genere una clave DES triple de 192 bits. [*](#java-lib-keys_5-note-1) |
| EC | Genere pares de claves EC: curvas NIST secp224r1 (P-224), secp256r1 (P-256), secp256k1 (Blockchain), secp384r1 (P-384) y secp521r1 (P-521). |
| GENERIC\$1SECRET | Genere secretos genéricos de 1 a 800 bytes. |
| HMAC | Soporte de hash para SHA1,, SHA224 SHA256, SHA384. SHA512 |
| RSA | Genere claves RSA de 2048 a 4096 bits, en incrementos de 256 bits |
\$1 De acuerdo con las directrices de NIST, esto no está permitido para clústeres en modo FIPS a partir de 2023. En el caso de los clústeres en modo no FIPS, seguirá siendo posible después de 2023. Para obtener más información, consulte [Cumplimiento de la normativa FIPS 140: anulación de mecanismo 2024](compliance-dep-notif.md#compliance-dep-notif-1).
# Conceptos básicos de administración clave en el proveedor de JCE para AWS CloudHSM Client SDK 5
Los aspectos básicos de la administración de claves en el proveedor de JCE están relacionados con la importación o la exportación de claves, la carga de claves por identificador o la eliminación de claves. Para obtener más información acerca de la administración de claves, consulte el ejemplo de código de [administración de claves](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java).
También puede encontrar más ejemplos de código de proveedor de JCE en [Ejemplos de código](java-samples.md).
# Mecanismos compatibles con el proveedor de JCE para AWS CloudHSM Client SDK 5
En este tema se proporciona información sobre los mecanismos compatibles con el proveedor de JCE con el SDK de AWS CloudHSM cliente 5. Para obtener información sobre las interfaces y las clases de motores de la arquitectura criptográfica de Java (JCA) compatibles AWS CloudHSM, consulte los temas siguientes.
**Topics**
+ [Generación de funciones de claves y pares de claves](#java-gen-key-pairs-5)
+ [Funciones de cifrado](#java-ciphers_5)
+ [Firma y comprobación de las funciones](#java-sign-verify_5)
+ [Funciones Digest](#java-digests_5)
+ [Funciones de código de autenticación de mensajes basado en hash (HMAC).](#java-mac_5)
+ [Funciones de código de autenticación de mensajes basados en cifrado (CMAC)](#java-cmac_5)
+ [Funciones de acuerdo de claves](#java-key-derivation_5)
+ [Conversión de las claves en especificaciones clave con generadores de claves](#java-key-factories)
+ [Notas del mecanismo](#w2aac25c21c25c15c23)
## Generación de funciones de claves y pares de claves
La biblioteca de AWS CloudHSM software para Java le permite utilizar las siguientes operaciones para generar funciones de claves y de pares de claves.
+ `RSA`
+ `EC`
+ `AES`
+ `DESede (Triple DES)`consulte la nota [1](#java-gen-key-pairs-5-note-1)
+ `GenericSecret`
## Funciones de cifrado
La biblioteca de AWS CloudHSM software para Java admite las siguientes combinaciones de algoritmo, modo y relleno.
| Algoritmo | Mode | Rellenado | Notas |
| --- | --- | --- | --- |
| AES | CBC | `AES/CBC/NoPadding` `AES/CBC/PKCS5Padding` | Implementa `Cipher.ENCRYPT_MODE` y `Cipher.DECRYPT_MODE`. Implementa `Cipher.UNWRAP_MODE for AES/CBC NoPadding` |
| AES | ECB | `AES/ECB/PKCS5Padding` `AES/ECB/NoPadding` | Implementa `Cipher.ENCRYPT_MODE` y `Cipher.DECRYPT_MODE`. |
| AES | CTR | `AES/CTR/NoPadding` | Implementa `Cipher.ENCRYPT_MODE` y `Cipher.DECRYPT_MODE`. |
| AES | GCM | `AES/GCM/NoPadding` | Implementa `Cipher.WRAP_MODE`, `Cipher.UNWRAP_MODE`, `Cipher.ENCRYPT_MODE` y `Cipher.DECRYPT_MODE`.Al realizar el cifrado AES-GCM, el HSM no tiene en cuenta el vector de inicialización (IV) de la solicitud y utiliza un IV que él mismo genera. Una vez que se ha completado la operación, deberá llamar a `Cipher.getIV()` para obtener el IV. |
| AESWrap | ECB | `AESWrap/ECB/NoPadding` `AESWrap/ECB/PKCS5Padding` `AESWrap/ECB/ZeroPadding` | Implementa `Cipher.WRAP_MODE` y `Cipher.UNWRAP_MODE`. |
| DESede (Triple DES) | CBC | `DESede/CBC/PKCS5Padding` `DESede/CBC/NoPadding` | Implementa `Cipher.ENCRYPT_MODE` y `Cipher.DECRYPT_MODE`. Consulte la nota [1](#java-gen-key-pairs-5-note-1) que aparece a continuación para ver los próximos cambios. |
| DESede (Triple DES) | ECB | `DESede/ECB/NoPadding` `DESede/ECB/PKCS5Padding` | Implementa `Cipher.ENCRYPT_MODE` y `Cipher.DECRYPT_MODE`. Consulte la nota [1](#java-gen-key-pairs-5-note-1) que aparece a continuación para ver los próximos cambios. |
| RSA | ECB | `RSA/ECB/PKCS1Padding`**consulte la 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` y `Cipher.DECRYPT_MODE`. |
| RSA | ECB | `RSA/ECB/NoPadding` | Implementa `Cipher.ENCRYPT_MODE` y `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` y `Cipher.UNWRAP_MODE`. |
## Firma y comprobación de las funciones
La biblioteca de AWS CloudHSM software para Java admite los siguientes tipos de firma y verificación. Con el SDK 5 de cliente y los algoritmos de firma con hash, los datos se codifican localmente en el software antes de enviarlos al HSM para su firma o comprobación. Esto significa que no hay límite en cuanto al tamaño de los datos que el SDK puede codificar.
**Tipos de 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`
**Tipos de firma ECDSA**
+ `NONEwithECDSA`
+ `SHA1withECDSA`
+ `SHA224withECDSA`
+ `SHA256withECDSA`
+ `SHA384withECDSA`
+ `SHA512withECDSA`
## Funciones Digest
La biblioteca de AWS CloudHSM software para Java admite los siguientes resúmenes de mensajes. Con SDK 5 de cliente, los datos se codifican localmente en el software. Esto significa que no hay límite en cuanto al tamaño de los datos que el SDK puede codificar.
+ `SHA-1`
+ `SHA-224`
+ `SHA-256`
+ `SHA-384`
+ `SHA-512`
## Funciones de código de autenticación de mensajes basado en hash (HMAC).
La biblioteca AWS CloudHSM de software para Java admite los siguientes algoritmos HMAC.
+ `HmacSHA1` (Tamaño máximo de datos en bytes: 16288)
+ `HmacSHA224` (Tamaño máximo de datos en bytes: 16256)
+ `HmacSHA256` (Tamaño máximo de datos en bytes: 16288)
+ `HmacSHA384` (Tamaño máximo de datos en bytes: 16224)
+ `HmacSHA512` (Tamaño máximo de datos en bytes: 16224)
## Funciones de código de autenticación de mensajes basados en cifrado (CMAC)
CMACs (Códigos de autenticación de mensajes cifrados) crean códigos de autenticación de mensajes (MACs) mediante un cifrado por bloques y una clave secreta. Se diferencian de ellos HMACs en que utilizan un método de clave simétrica de bloques en MACs lugar de un método de hash.
La biblioteca AWS CloudHSM de software para Java admite los siguientes algoritmos CMAC.
+ `AESCMAC`
## Funciones de acuerdo de claves
La biblioteca AWS CloudHSM de software para Java es compatible con ECDH con funciones de derivación clave (KDF). Se admiten los siguientes tipos de KDF:
+ `ECDHwithX963SHA1KDF`Soporta el algoritmo KDF X9.63 SHA1 [2](#kdf2)
+ `ECDHwithX963SHA224KDF`Soporta el algoritmo KDF X9.63 SHA224 [2](#kdf2)
+ `ECDHwithX963SHA256KDF`Soporta el algoritmo KDF X9.63 SHA256 [2](#kdf2)
+ `ECDHwithX963SHA384KDF`Soporta el algoritmo KDF X9.63 SHA384 [2](#kdf2)
+ `ECDHwithX963SHA512KDF`Soporta el algoritmo KDF X9.63 SHA512 [2](#kdf2)
## Conversión de las claves en especificaciones clave con generadores de claves
Puede utilizar las fábricas clave para convertir las claves en especificaciones clave. AWS CloudHSM tiene dos tipos de fábricas clave para JCE:
**SecretKeyFactory:** Se utiliza para importar o derivar claves simétricas. Con SecretKeyFactory él, puede pasar una clave compatible o una clave compatible KeySpec para importar o derivar claves simétricas. AWS CloudHSM Las siguientes son las especificaciones compatibles para KeyFactory:
+ SecretKeyFactoryEl `generateSecret` método de For admite [KeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/KeySpec.html)las siguientes clases:
+ **KeyAttributesMap**se puede usar para importar bytes de una clave con atributos adicionales como clave de CloudHSM. Puede encontrar un ejemplo [aquí](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)**se puede usar para importar una especificación de clave simétrica como clave de CloudHSM.
+ **AesCmacKdfParameterSpec**se puede utilizar para derivar claves simétricas mediante otra clave AES de CloudHSM.
**nota**
SecretKeyFactory[El `translateKey` método utiliza cualquier clave que implemente la interfaz clave.](https://docs.oracle.com/javase/8/docs/api/java/security/Key.html)
**KeyFactory:** Se utiliza para importar claves asimétricas. Con KeyFactory él, puede pasar una clave compatible o se puede importar una clave asimétrica KeySpec a ella. AWS CloudHSM Para obtener más información, consulte los siguientes recursos:
+ Para KeyFactory el `generatePublic` método de For, se admiten [KeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/KeySpec.html)las siguientes clases:
+ KeyAttributesMap CloudHSM para RSA y EC, que incluye: KeyTypes
+ KeyAttributesMap CloudHSM para el público de RSA y EC. KeyTypes Puede encontrar un ejemplo [aquí](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java).
+ [X509 EncodedKeySpec para clave](https://docs.oracle.com/javase/8/docs/api/java/security/spec/X509EncodedKeySpec.html) pública RSA y EC
+ [RSAPublicKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/RSAPublicKeySpec.html)para clave pública RSA
+ [ECPublicKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/ECPublicKeySpec.html)para la clave pública EC
+ Para KeyFactory el `generatePrivate` método de For, se admiten [KeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/KeySpec.html)las siguientes clases:
+ KeyAttributesMap CloudHSM para RSA y EC, que incluye: KeyTypes
+ KeyAttributesMap CloudHSM para el público de RSA y EC. KeyTypes Puede encontrar un ejemplo [aquí](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)para claves privadas de EC y RSA
+ [RSAPrivateCrtKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/RSAPrivateCrtKeySpec.html)para clave privada RSA
+ [ECPrivateKeySpec](https://docs.oracle.com/javase/8/docs/api/java/security/spec/ECPrivateKeySpec.html)para la clave privada EC
Para KeyFactory el `translateKey` método, incluye cualquier clave que implemente la [interfaz clave](https://docs.oracle.com/javase/8/docs/api/java/security/Key.html).
## Notas del mecanismo
[1] De acuerdo con las directrices del NIST, esto no se permite en los clústeres en modo FIPS después de 2023. En el caso de los clústeres en modo no FIPS, seguirá siendo posible después de 2023. Para obtener más información, consulte [Cumplimiento de la normativa FIPS 140: anulación de mecanismo 2024](compliance-dep-notif.md#compliance-dep-notif-1).
[2] Las funciones de derivación de claves (KDFs) se especifican en la [publicación especial 800-56A del NIST](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Ar3.pdf), revisión 3.
# Atributos clave de Java compatibles con AWS CloudHSM Client SDK 5
En este tema se proporciona información sobre los atributos clave de Java compatibles con el AWS CloudHSM Client SDK 5. Este tema describe cómo puede utilizar una extensión propia para el proveedor JCE para establecer atributos de clave. Utilice esta extensión para establecer los atributos de clave admitidos y sus valores durante estas operaciones:
+ Generación de claves
+ Importación de claves
Para ver ejemplos de cómo utilizar los atributos de clave, consulte [Ejemplos de código de la biblioteca de AWS CloudHSM software para Java for Client SDK 5](java-samples.md).
**Topics**
+ [Descripción de los atributos](#java-understanding-attributes_5)
+ [Atributos de admitidos](#java-attributes_5)
+ [Configuración de atributos para claves](#java-setting-attributes_5)
## Descripción de los atributos
Los atributos de clave se utilizan para especificar qué acciones se permiten en objetos relacionados con las claves, como claves públicas, privadas o secretas. Los atributos y valores de clave se definen durante las operaciones de creación de objetos de clave.
Sin embargo, Java Cryptography Extension (JCE) no especifica cómo deben establecerse los valores de los atributos de clave, por lo que, de forma predeterminada, se permiten la mayoría de las acciones. Por el contrario, el estándar PKCS \$111 define un completo conjunto de atributos con valores predeterminados más restrictivos. Empezando por el proveedor JCE 3.1, AWS CloudHSM proporciona una extensión patentada que permite establecer valores más restrictivos para los atributos de uso común.
## Atributos de admitidos
Puede establecer valores para los atributos que aparecen en la tabla siguiente. Es recomendable que solamente establezca valores para los atributos que desee hacer más restrictivos. Si no especifica ningún valor, AWS CloudHSM utiliza el valor predeterminado que se especifica en la tabla siguiente. Las celdas vacías de la columna «Valor predeterminado» indican que no hay ningún valor predeterminado específico asignado al atributo.
****
| Atributo | Valor predeterminado | Notas | | Clave simétrica | Clave pública del par de claves | Clave privada del par de claves | |
| --- | --- | --- | --- | --- | --- | --- | --- |
| DECRYPT | TRUE | | TRUE | True indica que la clave se puede utilizar para descifrar cualquier búfer. Por lo general, esto se establece como FALSE para una clave cuya propiedad WRAP está configurada como true. |
| DERIVE | | | | Permite utilizar una clave para derivar otras claves. |
| ENCRYPT | TRUE | TRUE | | True indica que la clave se puede utilizar para cifrar cualquier búfer. |
| EXTRACTABLE | TRUE | | TRUE | True indica que esta clave se puede exportar fuera del HSM. |
| ID | | | | Un valor definido por el usuario que se utiliza para identificar la clave. |
| KEY\$1TYPE | | | | Se utiliza para identificar el tipo de clave (AES DESede, secreto genérico, EC o RSA). |
| LABEL | | | | Una cadena definida por el usuario que le permite identificar cómodamente las claves de su HSM. Para seguir las mejores prácticas, utilice una etiqueta única para cada clave para que sea más fácil encontrarla más adelante. |
| LOCAL | | | | Indica una clave generada por el HSM. |
| OBJECT\$1CLASS | | | | Se utiliza para identificar la clase de objeto de una clave (SecretKey, PublicKey o PrivateKey). |
| PRIVATE | TRUE | TRUE | TRUE | True indica que es posible que los usuarios no tengan acceso a la clave hasta que se autentiquen. Para mayor claridad, los usuarios no pueden acceder a ninguna clave AWS CloudHSM hasta que se hayan autenticado, incluso si este atributo está establecido en FALSE. |
| SIGN | TRUE | | TRUE | True indica que la clave se puede utilizar para firmar un resumen del mensaje. Normalmente, se utiliza el valor FALSE con las claves públicas y privadas que se han archivado. |
| SIZE | | | | Atributo que define el tamaño de una clave. Para obtener más información sobre los tamaños de clave compatibles, consulte [Mecanismos compatibles con SDK 5 de cliente](https://docs.aws.amazon.com/cloudhsm/latest/userguide/java-lib-supported_5.html#java-keys_5). |
| TOKEN | FALSE | FALSE | FALSE | Una clave permanente que se replica HSMs en todo el clúster y se incluye en las copias de seguridad. TOKEN = FALSE implica el uso de una clave efímera, que se borra automáticamente cuando se interrumpe la conexión con ese HSM o se cierra la sesión. |
| UNWRAP | TRUE | | TRUE | True indica que la clave se puede utilizar para desencapsular (importar) otra clave. |
| VERIFY | TRUE | TRUE | | True indica que la clave se puede utilizar para verificar una firma. Normalmente, se utiliza el valor FALSE con las claves privadas. |
| WRAP | TRUE | TRUE | | True indica que la clave se puede utilizar para encapsular otra clave. Por lo general, se utilizará el valor FALSE con las claves privadas. |
| WRAP\$1WITH\$1TRUSTED | FALSE | | FALSE | Si su valor es verdadero, indica que una clave solo se puede encapsular y desencapsular con claves que tengan el atributo TRUSTED establecido en true. Una vez que una clave se establece como WRAP\$1WITH\$1TRUSTED, ese atributo es de solo lectura y no se puede establecer como false. Para obtener más información sobre el encapsulamiento de claves de confianza, consulte [Uso de claves de confianza para controlar el desencapsulamiento de claves](https://docs.aws.amazon.com/cloudhsm/latest/userguide/cloudhsm_using_trusted_keys_control_key_wrap.html). |
**nota**
La compatibilidad con los atributos de la biblioteca PKCS \$111 es más amplia. Para obtener más información, consulte [Atributos de PKCS \$111 admitidos](pkcs11-attributes.md).
## Configuración de atributos para claves
`KeyAttributesMap` es un objeto similar a Java Map, que puede usar para establecer valores de atributo en los objetos de clave. Los métodos de la función `KeyAttributesMap` son iguales que los métodos que se utilizan para manipular mapas de Java.
Si desea establecer valores personalizados en los atributos, tiene dos opciones:
+ Utilizar los métodos que se indican en la tabla siguiente
+ Utilizar los modelos de Builder que se ilustran más adelante en este documento
Los objetos de mapa de atributos admiten los siguientes métodos para establecer atributos:
****
| Operación | Valor de retorno | Método de `KeyAttributesMap` |
| --- | --- | --- |
| Obtener el valor de un atributo de clave para una clave existente | Objeto (que contiene el valor) o null | **get**(keyAttribute) |
| Rellenar el valor de un atributo de clave | Valor anterior asociado con el atributo de clave o null si no había ninguna asignación de un atributo de clave | **put**(keyAttribute, valor) |
| Rellenar valores en varios atributos de clave | N/A | **PuTall** () keyAttributesMap |
| Eliminar un par clave-valor del mapa de atributos | Valor anterior asociado con el atributo de clave o *null* si no había ninguna asignación de un atributo de clave | **remove**(keyAttribute) |
**nota**
Los atributos que no se especifican explícitamente se establecen en los valores predeterminados que se indican en la tabla anterior de [Atributos de admitidos](#java-attributes_5).
### Configuración de atributos para un par de claves
Utilice la clase `KeyPairAttributesMap` de Java para administrar los atributos de clave de un par de claves. `KeyPairAttributesMap` encapsula dos objetos `KeyAttributesMap`: uno para una clave pública y otro para una clave privada.
Para establecer por separado atributos específicos en la clave pública y en la clave privada, puede utilizar el método `put()` en el objeto de mapa `KeyAttributes` que corresponda a esa clave. Utilice el método `getPublic()` para recuperar el mapa de atributos de la clave pública y utilice `getPrivate()` para recuperar el mapa de atributos de la clave privada. Puede rellenar el valor de varios atributos de clave a la vez tanto de pares de claves públicas como de pares de claves privadas utilizando `putAll()` con un mapa de atributos de pares de claves como argumento.
# Ejemplos de código de la biblioteca de AWS CloudHSM software para Java for Client SDK 5
En este tema, se proporcionan recursos e información sobre ejemplos de código de Java para Client SDK 5 del AWS CloudHSM .
## Requisitos previos
Antes de ejecutar las muestras, debe configurar el entorno:
+ Instale y configure el [Proveedor de la Extensión Criptográfica de Java (JCE)](java-library-install_5.md#install-java-library_5).
+ Configure un [nombre de usuario y contraseña de HSM](manage-hsm-users.md) válidos. Los permisos del usuario criptográfico (CU) son suficientes para estas tareas. La aplicación utiliza estas credenciales para iniciar sesión en el HSM en cada ejemplo.
+ Decida cómo proporcionar las credenciales al [proveedor de JCE](java-library-install_5.md#java-library-credentials_5).
## Ejemplos de código
Los siguientes ejemplos de código muestran cómo utilizar el [proveedor de JCE de AWS CloudHSM](java-library.md) para realizar tareas básicas. Hay más ejemplos de código disponibles en [GitHub](https://github.com/aws-samples/aws-cloudhsm-jce-examples/tree/sdk5).
+ [Inicio de sesión en un HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java)
+ [Administración de claves](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyUtilitiesRunner.java)
+ [Generación de claves simétricas](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/SymmetricKeys.java)
+ [Generación de claves asimétricas](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AsymmetricKeys.java)
+ [Cifrado y descifrado con AES-GCM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AESGCMEncryptDecryptRunner.java)
+ [Cifrado y descifrado con AES-CTR](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/AESCTREncryptDecryptRunner.java)
+ [Encripta y descifra con DESede -ECB](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/DESedeECBEncryptDecryptRunner.java) (ver nota) [1](#java-samples-code-5-note-1)
+ [Firma y verificación con claves RSA](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/RSAOperationsRunner.java)
+ [Firma y verificación con claves de EC](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/ECOperationsRunner.java)
+ [Usar atributos clave admitidos](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyAttributesRunner.java)
+ [Uso del almacén de claves de CloudHSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/KeyStoreExampleRunner.java)
[1] De acuerdo con las directrices del NIST, esto no se permite en los clústeres en modo FIPS después de 2023. En el caso de los clústeres en modo no FIPS, seguirá siendo posible después de 2023. Para obtener más información, consulte [Cumplimiento de la normativa FIPS 140: anulación de mecanismo 2024](compliance-dep-notif.md#compliance-dep-notif-1).
# AWS CloudHSM Proveedor de ICE Javadocs
Utilice Javadoc, el proveedor de JCE, para obtener información de uso sobre los tipos y métodos de Java definidos en el SDK JCE de AWS CloudHSM. Para descargar los Javadocs más recientes AWS CloudHSM, consulte la [AWS CloudHSM última versión del SDK de cliente](latest-releases.md) sección de la página de descargas.
Puede importar Javadocs a un entorno de desarrollo integrado (IDE) o visualizarlas en un navegador web.
# AWS CloudHSM KeyStore Clase Java para Client SDK 5
La AWS CloudHSM `KeyStore` clase proporciona un almacén de PKCS12 claves para fines especiales. Este almacén de claves puede almacenar certificados junto con datos de la clave y relacionar estos certificados con los datos de clave que están almacenados en AWS CloudHSM. La AWS CloudHSM `KeyStore` clase implementa la interfaz de proveedor `KeyStore` de servicios (SPI) de la extensión de criptografía de Java (JCE). [Para obtener más información sobre su uso`KeyStore`, consulte Class. KeyStore](https://devdocs.io/openjdk~8/java/security/keystore)
**nota**
Dado que los certificados son información pública y, para maximizar la capacidad de almacenamiento de las claves criptográficas, no AWS CloudHSM admite el almacenamiento de certificados en HSMs ellos.
## Elija el almacén de claves adecuado para AWS CloudHSM Client SDK 5
El proveedor de AWS CloudHSM Java Cryptographic Extension (JCE) ofrece un AWS CloudHSM específico. KeyStore La AWS CloudHSM `KeyStore` clase admite la transferencia de operaciones clave al HSM, el almacenamiento local de certificados y las operaciones basadas en certificados.
Cargue el CloudHSM de uso especial de la siguiente manera: KeyStore
```
KeyStore ks = KeyStore.getInstance("CloudHSM")
```
## Inicialice el SDK 5 del cliente AWS CloudHSM KeyStore
Inicie sesión de AWS CloudHSM KeyStore la misma forma en que inicia sesión en el proveedor de JCE. Puede usar variables de entorno o el archivo de propiedades del sistema, y debe iniciar sesión antes de empezar a usar CloudHSM KeyStore. Para ver un ejemplo de inicio de sesión en un HSM mediante el proveedor JCE, consulte [Inicio de sesión en un HSM](https://github.com/aws-samples/aws-cloudhsm-jce-examples/blob/sdk5/src/main/java/com/amazonaws/cloudhsm/examples/LoginRunner.java).
Si lo desea, puede especificar una contraseña para cifrar el PKCS12 archivo local que contiene los datos del almacén de claves. Al crear el AWS CloudHSM almacén de claves, se establece la contraseña y se la proporciona cuando se utilizan los métodos load, set y get.
Cree una instancia de un nuevo objeto KeyStore CloudHSM de la siguiente manera:
```
ks.load(null, null);
```
Para escribir los datos del almacén de claves en un archivo, utilice el método `store`. A partir de ese momento, puede cargar el almacén de claves existente utilizando el método `load` con el archivo de origen y la contraseña de la siguiente manera:
```
ks.load(inputStream, password);
```
## Utilice nuestro SDK de cliente 5 AWS CloudHSM KeyStore AWS CloudHSM
AWS CloudHSM KeyStore cumple con la KeyStore especificación de la [clase](https://devdocs.io/openjdk~8/java/security/keystore) JCE y proporciona las siguientes funciones.
+ `load`
Carga el almacén de claves a partir de la secuencia de entrada especificada. Si se estableció una contraseña al guardar el almacén de claves, debe proporcionarse esta misma contraseña para que la carga se realice correctamente. Establezca los dos parámetros en null para inicializar un nuevo almacén de claves vacío.
```
KeyStore ks = KeyStore.getInstance("CloudHSM");
ks.load(inputStream, password);
```
+ `aliases`
Devuelve una enumeración de los nombres de alias de todas las entradas de la instancia especificada del almacén de claves. Los resultados incluyen los objetos almacenados localmente en el PKCS12 archivo y los objetos que residen en el HSM.
**Código de muestra:**
```
KeyStore ks = KeyStore.getInstance("CloudHSM");
for(Enumeration entry = ks.aliases(); entry.hasMoreElements();) {
String label = entry.nextElement();
System.out.println(label);
}
```
+ `containsalias`
Devuelve true si el almacén de claves tiene acceso al menos a un objeto con el alias especificado. El almacén de claves comprueba los objetos almacenados localmente en el PKCS12 archivo y los objetos que residen en el HSM.
+ `deleteEntry`
Elimina una entrada de certificado del archivo local PKCS12 . No se permite eliminar los datos clave almacenados en un HSM mediante el. AWS CloudHSM KeyStore Puede eliminar las claves mediante el método `destroy` de la interfaz [Destruible](https://devdocs.io/openjdk~8/javax/security/auth/destroyable#destroy--).
```
((Destroyable) key).destroy();
```
+ `getCertificate`
Devuelve el certificado asociado a un alias, si está disponible. Si el alias no existe o hace referencia a un objeto que no es un certificado, la función devuelve NULL.
```
KeyStore ks = KeyStore.getInstance("CloudHSM");
Certificate cert = ks.getCertificate(alias);
```
+ `getCertificateAlias`
Devuelve el nombre (alias) de la primera entrada del almacén de claves cuyos datos coinciden con el certificado especificado.
```
KeyStore ks = KeyStore.getInstance("CloudHSM");
String alias = ks.getCertificateAlias(cert);
```
+ `getCertificateChain`
Devuelve la cadena de certificados asociada con el alias especificado. Si el alias no existe o hace referencia a un objeto que no es un certificado, la función devuelve NULL.
+ `getCreationDate`
Devuelve la fecha de creación de la entrada identificada por el alias especificado. Si no hay disponible ninguna fecha de creación, la función devuelve la fecha en la que el certificado pasó a ser válido.
+ `getKey`
GetKey se pasa al HSM y devuelve un objeto clave correspondiente a la etiqueta dada. Como consulta `getKey` directamente al HSM, se puede utilizar para cualquier clave del HSM, independientemente de si fue generada por el. KeyStore
```
Key key = ks.getKey(keyLabel, null);
```
+ `isCertificateEntry`
Comprueba si la entrada con el alias especificado representa una entrada de certificado.
+ `isKeyEntry`
Comprueba si la entrada con el alias especificado representa una entrada de clave. La acción busca el alias tanto en el PKCS12 archivo como en el HSM.
+ `setCertificateEntry`
Asigna el certificado especificado al alias proporcionado. Si el alias proporcionado ya se utiliza para identificar una clave o un certificado, se inicia una excepción `KeyStoreException`. Puede utilizar el código JCE para obtener el objeto clave y, a continuación, utilizar el KeyStore `SetKeyEntry` método para asociar el certificado a la clave.
+ `setKeyEntry` con una clave `byte[]`
**Actualmente, esta API no es compatible con SDK 5 de cliente.**
+ `setKeyEntry` con un objeto `Key`
Asigna la clave especificada al alias proporcionado y la almacena dentro del HSM. Si la clave aún no existe en el HSM, se importará al HSM como una clave de sesión extraíble.
Si el objeto `Key` es de tipo `PrivateKey`, debe ir acompañado de la cadena de certificados correspondiente.
Si el alias ya existe, la llamada a `SetKeyEntry` inicia una excepción `KeyStoreException` y evita que la clave se sobrescriba. Si es necesario sobrescribir la clave, utilice KMU o JCE para ese propósito.
+ `engineSize`
Devuelve el número de entradas del almacén de claves.
+ `store`
Almacena el almacén de claves del flujo de salida dado como un PKCS12 archivo y lo protege con la contraseña proporcionada. Además, conserva todas las claves cargadas (que se establecen mediante llamadas a `setKey`).
# Configuraciones avanzadas para AWS CloudHSM JCE for Client SDK 5
El proveedor de AWS CloudHSM JCE incluye las siguientes configuraciones avanzadas, que no forman parte de las configuraciones generales que utilizan la mayoría de los clientes.
+ [Conexión a múltiples clústeres](java-lib-configs-multi.md)
+ [Extracción de claves mediante JCE](java-lib-configs-getencoded.md)
+ [Vuelva a intentar la configuración del JCE](java-lib-configs-retry.md).
# Conexión a varios AWS CloudHSM clústeres con el proveedor de JCE
Esta configuración permite que una sola instancia de cliente se comunique con varios clústeres de AWS CloudHSM . En comparación con tener una sola instancia que solo se comunique con un único clúster, esta característica puede suponer un ahorro de costos en algunos casos de uso. La `CloudHsmProvider` clase es AWS CloudHSM la implementación de la [clase Provider de Java Security](https://docs.oracle.com/javase/8/docs/api/java/security/Provider.html). Cada instancia de esta clase representa una conexión a todo el AWS CloudHSM clúster. Cree una instancia de esta clase y añádala a la lista de proveedores de seguridad de Java para poder interactuar con ella mediante clases de JCE estándar.
En el siguiente ejemplo, se crea una instancia de esta clase y se añade a la lista de proveedores de seguridad de Java:
```
if (Security.getProvider(CloudHsmProvider.PROVIDER_NAME) == null) {
Security.addProvider(new CloudHsmProvider());
}
```
`CloudHsmProvider` puede configurarse de dos formas:
1. Configurar con un archivo (configuración predeterminada)
1. Configuración mediante código
En los siguientes temas, se describen estas configuraciones y cómo conectarse a varios clústeres.
**Topics**
+ [Configurar la clase `CloudHsmProvider` de AWS CloudHSM con un archivo (configuración predeterminada)](java-lib-configs-default.md)
+ [Configurar la clase `CloudHsmProvider` de AWS CloudHSM con un código](java-lib-configs-using-code.md)
+ [Conéctese a varios AWS CloudHSM clústeres](java-lib-connecting-to-multiclusters.md)
# Configurar la clase `CloudHsmProvider` de AWS CloudHSM con un archivo (configuración predeterminada)
La forma predeterminada de configurar la AWS CloudHSM `CloudHsmProvider` clase es con un archivo.
Al iniciar `CloudHsmProvider` con el constructor predeterminado, de forma predeterminada buscará el archivo de configuración en la ruta `/opt/cloudhsm/etc/cloudhsm-jce.cfg` en Linux. Este archivo de configuración se puede configurar usando `configure-jce`.
Un objeto creado con el constructor predeterminado utilizará el nombre de proveedor de CloudHSM predeterminado `CloudHSM`. El nombre del proveedor es útil para interactuar con el JCE y decirle qué proveedor debe utilizar para las distintas operaciones. A continuación, se muestra un ejemplo de cómo utilizar el nombre del proveedor de CloudHSM para la operación de cifrado:
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "CloudHSM");
```
# Configurar la clase `CloudHsmProvider` de AWS CloudHSM con un código
A partir de la versión 5.8.0 del SDK de cliente, también puede configurar la AWS CloudHSM `CloudHsmProvider` clase mediante código Java. La forma de hacerlo es utilizando un objeto de clase `CloudHsmProviderConfig`. Puede construir este objeto utilizando `CloudHsmProviderConfigBuilder`.
`CloudHsmProvider` tiene otro constructor que toma el objeto `CloudHsmProviderConfig`, como se muestra en el siguiente ejemplo.
**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);
```
En este ejemplo, el nombre del proveedor JCE es `CloudHsmCluster1`. Este es el nombre que la aplicación puede utilizar posteriormente para interactuar con JCE.
**Example**
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "CloudHsmCluster1");
```
Como alternativa, las aplicaciones también pueden usar el objeto de proveedor creado anteriormente para que JCE sepa que debe usar ese proveedor para la operación:
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", provider);
```
Si no se especifica un identificador único con el método de `withClusterUniqueIdentifier`, se crea para usted un nombre de proveedor generado aleatoriamente. Para obtener este identificador generado aleatoriamente, las aplicaciones pueden llamar `provider.getName()` para obtener el identificador.
# Conéctese a varios AWS CloudHSM clústeres
Cada uno `CloudHsmProvider` representa una conexión a su AWS CloudHSM clúster. Si desea comunicarse con otro clúster desde la misma aplicación, puede crear otro objeto de `CloudHsmProvider` con las configuraciones del otro clúster e interactuar con este otro clúster mediante el objeto del proveedor o el nombre del proveedor, como se muestra en el siguiente ejemplo.
**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);
}
```
Una vez que haya configurado los dos proveedores (ambos clústeres) anteriores, podrá interactuar con ellos mediante el objeto del proveedor o mediante el nombre del proveedor.
Ampliando este ejemplo que muestra cómo hablar con`cluster1`, puede utilizar el siguiente ejemplo para una AES/GCM/NoPadding operación:
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", provider1);
```
Y en la misma aplicación para generar la clave «AES» en el segundo clúster con el nombre del proveedor, también puede usar el siguiente ejemplo:
```
Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", provider2.getName());
```
# Extracción de claves mediante JCE para AWS CloudHSM
La extensión de criptografía de Java (JCE) utiliza una arquitectura que permite conectar diferentes implementaciones de criptografía. AWS CloudHSM envía uno de esos proveedores de JCE que transfiere las operaciones criptográficas al HSM. Para que la mayoría de los demás proveedores de JCE trabajen con claves almacenadas en AWS CloudHSM, deben extraer los bytes clave del texto sin cifrar y llevarlos a la memoria HSMs de la máquina para su uso. HSMs por lo general, solo permiten extraer las claves como objetos empaquetados, no como texto claro. Sin embargo, para facilitar los casos de uso de la integración entre proveedores, ofrece una opción de configuración opcional que AWS CloudHSM permite extraer los bytes clave en blanco.
**importante**
JCE transfiere las operaciones a AWS CloudHSM cada vez que se especifique el proveedor de AWS CloudHSM o se utilice un objeto clave. AWS CloudHSM No necesita extraer las claves sin cifrar si espera que la operación se lleve a cabo dentro del HSM. La extracción de claves en texto no cifrado solo es necesaria cuando la aplicación no puede utilizar mecanismos seguros, como encapsular y desencapsular una clave, debido a las restricciones de una biblioteca externa o de un proveedor de JCE.
De forma predeterminada, el proveedor de AWS CloudHSM JCE permite la extracción de **claves públicas** para que funcionen con proveedores de JCE externos. Siempre se permiten los siguientes métodos:
| Clase | Método | Formato (GetEncoded) |
| --- | --- | --- |
| EcPublicKey | getEncoded() | X.509 |
| | getW() | N/A |
| RSAPublicClave | getEncoded() | X.509 |
| | getPublicExponent() | N/A |
| CloudHsmRsaPrivateCrtKey | getPublicExponent() | N/A |
El proveedor AWS CloudHSM JCE no permite la extracción de los bytes de la clave en blanco para las claves **privadas** o **secretas** de forma predeterminada. Si su caso de uso lo requiere, puede habilitar la extracción de los bytes de claves sin cifrar para claves **privadas** o **secretas** en las siguientes condiciones:
1. El atributo `EXTRACTABLE` para claves privadas y secretas se establece como **true**.
+ De forma predeterminada, el atributo `EXTRACTABLE` de las claves privadas y secretas está establecido como **true**. Las claves de `EXTRACTABLE` son claves que se pueden exportar fuera del HSM. Para obtener más información, consulte Atributos de Java admitidos para [SDK 5 de cliente](java-lib-attributes_5.md).
1. El atributo `WRAP_WITH_TRUSTED` para claves privadas y secretas se establece en **false**.
+ `getEncoded`, `getPrivateExponent` y `getS` no se pueden usar con claves privadas que no se puedan exportar sin cifrar. `WRAP_WITH_TRUSTED` no permite exportar sus claves privadas fuera del HSM de sin cifrar. Para obtener más información, consulte [Cómo usar claves de confianza para controlar el desencapsulamiento de claves](manage-keys-using-trusted-keys.md).
# Permita que el proveedor de JCE extraiga los secretos de las claves privadas de AWS CloudHSM
Siga los siguientes pasos para permitir que el proveedor de AWS CloudHSM JCE extraiga sus secretos de clave privada.
**importante**
Este cambio de configuración permite extraer todos los bytes de claves `EXTRACTABLE` sin procesar del clúster de HSM. Para mejorar la seguridad, debería considerar la posibilidad de utilizar [métodos de encapsulamiento de claves](java-lib-supported_5.md) para extraer la clave del HSM de forma segura. Esto evita la extracción involuntaria de los bytes clave del HSM.
1. Utilice los siguientes comandos para permitir que sus claves **privadas** o **secretas** se extraigan en 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 vez que habilite la extracción de claves sin cifrar, se habilitarán los siguientes métodos para extraer las claves privadas de la memoria.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloudhsm/latest/userguide/get-encoded-take-out-private-keys.html)
Si quiere restaurar el comportamiento predeterminado y no permitir que JCE exporte las claves en formato sin cifrar, ejecute el siguiente 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
```
------
# Vuelva a intentar los comandos de JCE para AWS CloudHSM
AWS CloudHSM El SDK de cliente 5.8.0 y las versiones posteriores tienen una estrategia de reintento automático integrada que reintentará las operaciones reguladas por HSM desde el lado del cliente. Cuando un HSM limita las operaciones porque está demasiado ocupado realizando operaciones anteriores y no puede aceptar más solicitudes, el cliente intentará volver a intentar las operaciones restringidas hasta 3 veces y, al mismo tiempo, SDKs retrocederá exponencialmente. Esta estrategia de reintento automático se puede configurar en uno de estos dos modos: **desactivado** y **estándar**.
+ **desactivado**: el SDK de cliente no realizará ninguna estrategia de reintentos para ninguna operación limitada por parte del HSM.
+ **estándar**: este es el modo predeterminado para la versión 5.8.0 y posteriores de SDK de cliente. En este modo, el cliente SDKs volverá a intentar automáticamente las operaciones restringidas y se retrasará exponencialmente.
Para obtener más información, consulte [Limitación de HSM](troubleshoot-hsm-throttling.md).
## Configuración de los comandos de reintento en modo desactivado
------
#### [ Linux ]
**Cómo configurar los comandos de reintento en **off** para SDK 5 de cliente en Linux**
+ Puede utilizar los siguientes comandos para administrar la configuración de reintento en modo **off**:
```
$ sudo /opt/cloudhsm/bin/configure-jce --default-retry-mode off
```
------
#### [ Windows ]
**Cómo configurar los comandos de reintento en **off** para SDK 5 de cliente en Windows**
+ Puede utilizar los siguientes comandos para administrar la configuración de reintento en modo **off**:
```
PS C:\> & "C:\Program Files\Amazon\CloudHSM\bin\configure-jce.exe" --default-retry-mode off
```
------