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. # Biblioteca PKCS \$111 para AWS CloudHSM Client SDK 3 PKCS \$111 es un estándar para realizar operaciones criptográficas en módulos de seguridad de hardware (HSM) en AWS CloudHSM. Para obtener más información sobre el arranque, consulte [Conexión al clúster](cluster-connect.md). **Topics** + [Instalar la biblioteca PKCS \$111](install-pkcs11-v3.md) + [Autenticar en la biblioteca PKCS \$111](pkcs11-v3-pin.md) + [Tipos de clave](pkcs11-v3-key-types.md) + [Mecanismos](pkcs11-v3-mechanisms.md) + [Operaciones de la API](pkcs11-v3-apis.md) + [Atributos de clave](pkcs11-v3-attributes.md) + [Ejemplos de código](pkcs11-v3-samples.md) # Instale la biblioteca PKCS \$111 para el SDK de AWS CloudHSM cliente 3 En este tema se proporcionan instrucciones para instalar la biblioteca PKCS \$111 para la serie de versiones AWS CloudHSM Client SDK 3. Para obtener más información sobre el SDK de cliente o la biblioteca PKCS \$111, consulte [Usar el SDK de cliente](use-hsm.md) y [Biblioteca de PKCS \$111](pkcs11-library.md). ## Requisitos previos para el SDK 3 de cliente La biblioteca PKCS \$111 requiere el AWS CloudHSM cliente. Si no ha instalado ni configurado el AWS CloudHSM cliente, hágalo ahora siguiendo los pasos que se indican en[Instalar el cliente (Linux)](cmu-install-and-configure-client-linux.md). Después de instalar y configurar el cliente, utilice el siguiente comando para iniciarlo. ------ #### [ Amazon Linux ] ``` $ sudo start cloudhsm-client ``` ------ #### [ Amazon Linux 2 ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ CentOS 7 ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ CentOS 8 ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ RHEL 7 ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ RHEL 8 ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ Ubuntu 16.04 LTS ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ Ubuntu 18.04 LTS ] ``` $ sudo systemctl start cloudhsm-client ``` ------ #### [ Ubuntu 20.04 LTS ] ``` $ sudo systemctl start cloudhsm-client ``` ------ ## Instale la biblioteca PKCS \$111 para el SDK 3 de cliente El siguiente comando descarga e instala la biblioteca PKCS \$111. ------ #### [ Amazon Linux ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL6/cloudhsm-client-pkcs11-latest.el6.x86_64.rpm ``` ``` $ sudo yum install ./cloudhsm-client-pkcs11-latest.el6.x86_64.rpm ``` ------ #### [ Amazon Linux 2 ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-pkcs11-latest.el7.x86_64.rpm ``` ``` $ sudo yum install ./cloudhsm-client-pkcs11-latest.el7.x86_64.rpm ``` ------ #### [ CentOS 7 ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-pkcs11-latest.el7.x86_64.rpm ``` ``` $ sudo yum install ./cloudhsm-client-pkcs11-latest.el7.x86_64.rpm ``` ------ #### [ CentOS 8 ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-pkcs11-latest.el8.x86_64.rpm ``` ``` $ sudo yum install ./cloudhsm-client-pkcs11-latest.el8.x86_64.rpm ``` ------ #### [ RHEL 7 ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL7/cloudhsm-client-pkcs11-latest.el7.x86_64.rpm ``` ``` $ sudo yum install ./cloudhsm-client-pkcs11-latest.el7.x86_64.rpm ``` ------ #### [ RHEL 8 ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/EL8/cloudhsm-client-pkcs11-latest.el8.x86_64.rpm ``` ``` $ sudo yum install ./cloudhsm-client-pkcs11-latest.el8.x86_64.rpm ``` ------ #### [ Ubuntu 16.04 LTS ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Xenial/cloudhsm-client-pkcs11_latest_amd64.deb ``` ``` $ sudo apt install ./cloudhsm-client-pkcs11_latest_amd64.deb ``` ------ #### [ Ubuntu 18.04 LTS ] ``` $ wget https://s3.amazonaws.com/cloudhsmv2-software/CloudHsmClient/Bionic/cloudhsm-client-pkcs11_latest_u18.04_amd64.deb ``` ``` $ sudo apt install ./cloudhsm-client-pkcs11_latest_u18.04_amd64.deb ``` ------ + Si la instancia EC2 en la que instaló la biblioteca PKCS \$111 no tiene instalados otros componentes del SDK 3 de cliente, debe iniciar el SDK 3 de cliente. Solo tiene que hacerlo una vez para cada instancia con un componente del SDK 3 de cliente. + Puede encontrar los archivos de la biblioteca PKCS \$111 en las siguientes ubicaciones: Binarios, scripts de configuración, certificados y archivos de registro de Linux: ``` /opt/cloudhsm/lib ``` # Autenticese en la biblioteca PKCS \$111 para el SDK 3 del cliente AWS CloudHSM Cuando utilizas la biblioteca PKCS \$111, tu aplicación se ejecuta como un [usuario criptográfico (CU)](manage-hsm-users.md) concreto en tu interior. HSMs AWS CloudHSM La aplicación solo puede ver y administrar las claves que posee y comparte el CU. Puede utilizar una CU existente en su CU HSMs o crear una nueva. Para obtener información sobre la administración CUs, consulte [Administración de usuarios de HSM con la CLI de CloudHSM y Administración de usuarios de HSM](manage-hsm-users-chsm-cli.md) [con CloudHSM Management Utility](manage-hsm-users-cmu.md) (CMU). Para especificar el CU para la biblioteca PKCS \$111, utilice el parámetro de pin de la [función C\$1Login](http://docs.oasis-open.org/pkcs11/pkcs11-base/v2.40/os/pkcs11-base-v2.40-os.html#_Toc385057915) de PKCS \$111. En efecto AWS CloudHSM, el parámetro pin tiene el siguiente formato: ``` : ``` Por ejemplo, el siguiente comando establece el pin de la biblioteca PKCS \$111 para el CU con el nombre de usuario `CryptoUser` y la contraseña `CUPassword123!`. ``` CryptoUser:CUPassword123! ``` # Tipos de clave compatibles con la biblioteca PKCS \$111 del AWS CloudHSM Client SDK 3 La biblioteca PKCS \$111 admite los siguientes tipos de claves con el AWS CloudHSM Client SDK 3. **** | Tipo de clave | Description (Descripción) | | --- | --- | | RSA | Genere claves RSA de 2048 a 4096 bits, en incrementos de 256 bits | | EC | Genere claves con las curvas secp224r1 (P-224), secp256r1 (P-256), secp256k1 (Blockchain), secp384r1 (P-384) y secp521r1 (P-521). | | AES | Genere claves AES de 128, 192 y 256 bits. | | DES3 (DES triple) | Genere claves de 192 bits DES3 . Consulte la nota [1](#pkcs11-v3-key-note) que aparece a continuación para ver los próximos cambios. | | GENERIC\$1SECRET | Genere secretos genéricos de 1 a 64 bytes. | + [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). # Mecanismos compatibles con el SDK 3 AWS CloudHSM del cliente La biblioteca PKCS \$111 admite los siguientes algoritmos para el SDK de AWS CloudHSM cliente 3: + **Cifrado y descifrado**: AES-CBC, AES-CTR, AES-ECB, AES-GCM, -CBC, -ECB, RSA-OAEP y RSA-PKCS DES3 DES3 + **Firma y verificación**: RSA, HMAC y ECDSA; con y sin hash + ** SHA1 SHA256 SHA384Hash/Digest SHA224 —,,, y** SHA512 + **Encapsulación de claves**: encapsulación de claves AES,[4](#pkcs11-v3-mech4) AES-GCM, RSA-AES y RSA-OAEP + **Derivación de claves**: ECDH, -108 CTR KDF [5](#pkcs11-v3-mech5) SP800 ## Tabla de mecanismos y funciones de la biblioteca PKCS \$111 La biblioteca PKCS \$111 es compatible con la versión 2.40 de la especificación PKCS \$111. Para invocar una característica criptográfica con PKCS \$111, llame a una función con un mecanismo determinado. En la siguiente tabla, se resumen las combinaciones de funciones y mecanismos admitidos por AWS CloudHSM. **Interpretación de la tabla de mecanismos y funciones compatibles con PKCS \$111** La marca ✔ indica que es AWS CloudHSM compatible con el mecanismo de la función. No se admiten todas las funciones posibles que se muestran en la especificación de PKCS \$111. La marca ✖ indica que aún AWS CloudHSM no es compatible con el mecanismo para la función en cuestión, aunque el estándar PKCS \$111 lo permita. Las celdas vacías indican que el estándar de PKCS \$111 no admite el mecanismo para esa función. **Mecanismos y funciones compatibles con la biblioteca PKCS \$111** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloudhsm/latest/userguide/pkcs11-v3-mechanisms.html) **Notas del mecanismo** + [1] Únicamente para operaciones de una sola parte. + [2] Este mecanismo es funcionalmente idéntico al mecanismo `CKM_RSA_PKCS_KEY_PAIR_GEN`, pero ofrece más garantías en la generación de `p` y `q`. + [3.1] AWS CloudHSM aborda el hash de forma diferente en función del SDK del cliente. En el caso de SDK 3 de cliente, el hashing depende del tamaño de los datos y de si se utilizan operaciones de una o varias partes. **Operaciones de una sola parte en SDK 3 de cliente** En la tabla 3.1 se muestra el tamaño máximo del conjunto de datos para cada mecanismo de SDK 3 de cliente. El hash completo se calcula dentro del HSM. No admite tamaños de datos superiores a 16 KB. **Tabla 3.1, tamaño máximo del conjunto de datos para operaciones de una sola parte** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloudhsm/latest/userguide/pkcs11-v3-mechanisms.html) **Operaciones de varias partes en SDK 3 de cliente** Admite tamaños de datos superiores a 16 KB, pero el tamaño de los datos determina el lugar del hashing. Los búferes de datos de menos de 16 KB se codifican con un hash dentro del HSM. Los búferes de entre 16 KB y el tamaño máximo de datos de su sistema se codifican localmente en el software. *Recuerde*: Las funciones de hash no requieren de secretos criptográficos, por lo que puede calcularlas de forma segura fuera del HSM. + [3.2] AWS CloudHSM aborda el hash de forma diferente en función del SDK del cliente. En el caso de SDK 3 de cliente, el hashing depende del tamaño de los datos y de si se utilizan operaciones de una o varias partes. **Operaciones de una sola parte en SDK 3 de cliente** En la tabla 3.2 se muestra el tamaño máximo del conjunto de datos para cada mecanismo de SDK 3 de cliente. No admite tamaños de datos superiores a 16 KB. **Tabla 3.2, tamaño máximo del conjunto de datos para operaciones de una sola parte** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloudhsm/latest/userguide/pkcs11-v3-mechanisms.html) **Operaciones de varias partes en SDK 3 de cliente** Admite tamaños de datos superiores a 16 KB, pero el tamaño de los datos determina el lugar del hashing. Los búferes de datos de menos de 16 KB se codifican con un hash dentro del HSM. Los búferes de entre 16 KB y el tamaño máximo de datos de su sistema se codifican localmente en el software. *Recuerde*: Las funciones de hash no requieren de secretos criptográficos, por lo que puede calcularlas de forma segura fuera del HSM. + [3.3] Cuando se opera con datos mediante cualquiera de los mecanismos siguientes, si el búfer de datos supera el tamaño máximo de datos, la operación produce un error. Para estos mecanismos, todo el procesamiento de los datos debe realizarse dentro del HSM. En la tabla siguiente, se muestra el tamaño máximo de datos establecido para cada mecanismo: **Tabla 3.3, tamaño máximo del conjunto de datos** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloudhsm/latest/userguide/pkcs11-v3-mechanisms.html) + [4] Al realizar el cifrado AES-GCM, el HSM no acepta los datos del vector de inicialización (IV) de la aplicación. Debe utilizar un vector de inicialización generado. El IV de 12 bytes proporcionado por el HSM se escribe en la referencia de memoria a la que apunta el elemento pIV de la estructura de parámetros `CK_GCM_PARAMS` especificada por el usuario. Para asegurarse de no generar confusión en el usuario, el SDK de PKCS\$111 versión 1.1.1 y posteriores obliga a que el elemento pIV apunte a un búfer puesto a cero cuando se inicializa el cifrado AES-GCM. + [5] **Solo SDK 3 de cliente**. Este mecanismo se implementa para admitir casos de descarga de SSL/TLS y solo se ejecuta parcialmente en el HSM. Antes de usar este mecanismo, consulte «Issue: ECDH key derivation is executed only partially within the HSM» en [Problemas conocidos de la biblioteca PKCS \$111 de AWS CloudHSMProblemas conocidos de la biblioteca PKCS \$111](ki-pkcs11-sdk.md).`CKM_ECDH1_DERIVE` no admite la curva secp521r1 (P-521). + [6] Los siguientes `CK_MECHANISM_TYPE` y `CK_RSA_PKCS_MGF_TYPE` se admiten como `CK_RSA_PKCS_OAEP_PARAMS` para `CKM_RSA_PKCS_OAEP`: + `CKM_SHA_1` con `CKG_MGF1_SHA1` + `CKM_SHA224` con `CKG_MGF1_SHA224` + `CKM_SHA256` con `CKG_MGF1_SHA256` + `CKM_SHA384` con `CKM_MGF1_SHA384` + `CKM_SHA512` con `CKM_MGF1_SHA512` + [7.1] Mecanismo definido por el proveedor. Para poder utilizar los mecanismos definidos por el proveedor de CloudHSM, las aplicaciones PKCS\$111 deben incluir `/opt/cloudhsm/include/pkcs11/cloudhsm_pkcs11_vendor_defs.h` durante la compilación. `CKM_CLOUDHSM_AES_GCM`: este mecanismo exclusivo es una alternativa programáticamente segura del estándar `CKM_AES_GCM`. Antepone el IV generado por el HSM al texto cifrado en lugar de volver a escribirlo en la estructura `CK_GCM_PARAMS` que se proporciona durante la inicialización del cifrado. Puede utilizar este mecanismo con las funciones `C_Encrypt`, `C_WrapKey`, `C_Decrypt` y `C_UnwrapKey`. Cuando se utiliza este mecanismo, la variable pIV de la estructura `CK_GCM_PARAMS` debe establecerse en `NULL`. Cuando se utiliza este mecanismo con `C_Decrypt` y `C_UnwrapKey`, se espera que el IV se anteponga al texto cifrado que se está desencapsulando. `CKM_CLOUDHSM_AES_KEY_WRAP_PKCS5_PAD`: encapsulamiento de claves AES con relleno PKCS \$15 `CKM_CLOUDHSM_AES_KEY_WRAP_ZERO_PAD`: encapsulamiento de claves AES con relleno de ceros Para obtener más opciones de encapsulamiento de claves AES, consulte [Encapsulamiento de claves con AES](manage-aes-key-wrapping.md). + [8] 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). # Operaciones de API compatibles con el SDK de AWS CloudHSM cliente 3 La biblioteca PKCS \$111 admite las siguientes operaciones de la API PKCS \$111 para el SDK de AWS CloudHSM cliente 3. + `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_SignRecover` (Solo compatible con SDK 3 de cliente) + `C_SignRecoverInit` (Solo compatible con SDK 3 de cliente) + `C_SignUpdate` + `C_UnWrapKey` + `C_Verify` + `C_VerifyFinal` + `C_VerifyInit` + `C_VerifyRecover` (Solo compatible con SDK 3 de cliente) + `C_VerifyRecoverInit` (Solo compatible con SDK 3 de cliente) + `C_VerifyUpdate` + `C_WrapKey` # Atributos clave de la biblioteca PKCS \$111 del SDK 3 del Client SDK AWS CloudHSM Un objeto de clave puede ser una clave pública, privada o secreta. Las acciones permitidas en un objeto de clave se especifican mediante atributos. Los atributos se definen cuando se crea el objeto de clave. Al utilizar la biblioteca PKCS \$111 AWS CloudHSM, asignamos los valores predeterminados según lo especificado en el estándar PKCS \$111. AWS CloudHSM no admite todos los atributos enumerados en la especificación PKCS \$111. Seguimos esta especificación en todos los atributos que admitimos. Estos atributos se indican en sus respectivas tablas. Las funciones criptográficas como `C_CreateObject`, `C_GenerateKey`, `C_GenerateKeyPair`, `C_UnwrapKey` y `C_DeriveKey` que crean, modifican o copian objetos toman una plantilla de atributos como uno de sus parámetros. Para obtener más información acerca de cómo pasar una plantilla de atributos durante la creación de objetos, consulte el ejemplo [Generar claves mediante la biblioteca de PKCS \$111](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/generate). En los temas siguientes se proporciona más información sobre los atributos AWS CloudHSM clave del SDK de cliente 3. **Topics** + [Tabla de atributos](pkcs11-v3-attributes-interpreting.md) + [Modificación de atributos](pkcs11-v3-modify-attr.md) + [Interpretación de los códigos de error de la biblioteca PKCS \$111 para el SDK de AWS CloudHSM cliente 3](pkcs11-v3-attr-errors.md) # Tabla de atributos de la biblioteca PKCS \$111 para el AWS CloudHSM Client SDK 3 La tabla de bibliotecas PKCS \$111 del SDK 3 del AWS CloudHSM Client SDK 3 contiene una lista de atributos que difieren según el tipo de clave. Indica si un atributo determinado es compatible con un tipo de clave concreto cuando se utiliza una función criptográfica específica con. AWS CloudHSM **Leyenda** + ✔ indica que CloudHSM admite el atributo para el tipo de clave específico. + ✖ indica que CloudHSM no admite el atributo para el tipo de clave específico. + R indica que el valor del atributo se establece en de solo lectura para el tipo de clave específico. + S indica que `GetAttributeValue` no puede leer el atributo porque distingue entre mayúsculas y minúsculas. + Una celda vacía en la columna Valor predeterminado indica que no hay ningún valor predeterminado específico asignado al atributo. ## GenerateKeyPair [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloudhsm/latest/userguide/pkcs11-v3-attributes-interpreting.html) ## GenerateKey [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloudhsm/latest/userguide/pkcs11-v3-attributes-interpreting.html) ## CreateObject [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloudhsm/latest/userguide/pkcs11-v3-attributes-interpreting.html) ## UnwrapKey [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloudhsm/latest/userguide/pkcs11-v3-attributes-interpreting.html) ## DeriveKey [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloudhsm/latest/userguide/pkcs11-v3-attributes-interpreting.html) ## GetAttributeValue [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloudhsm/latest/userguide/pkcs11-v3-attributes-interpreting.html) **Notas de atributo** + [1] Este atributo es parcialmente compatible con el firmware y debe configurarse de forma explícita únicamente en el valor predeterminado. + [2] Atributo obligatorio. + [3] **Solo SDK 3 de cliente**. El atributo `CKA_SIGN_RECOVER` se obtiene del atributo `CKA_SIGN`. Si debe configurarse, solo se puede establecer en el mismo valor que el establecido para `CKA_SIGN`. Si no se establece, se obtiene el valor predeterminado de `CKA_SIGN`. Como CloudHSM solo admite los mecanismos de firma recuperable basados en RSA, este atributo solo se puede aplicar a clases públicas de RSA actualmente. + [4] **Solo SDK 3 de cliente**. El atributo `CKA_VERIFY_RECOVER` se obtiene del atributo `CKA_VERIFY`. Si debe configurarse, solo se puede establecer en el mismo valor que el establecido para `CKA_VERIFY`. Si no se establece, se obtiene el valor predeterminado de `CKA_VERIFY`. Como CloudHSM solo admite los mecanismos de firma recuperable basados en RSA, este atributo solo se puede aplicar a clases públicas de RSA actualmente. # Modificación de los atributos de la biblioteca PKCS \$111 para el SDK 3 AWS CloudHSM del cliente Algunos atributos de un objeto se pueden modificar una vez creado el objeto, mientras que otros no. Para modificar los atributos, utilice el comando [setAttribute](cloudhsm_mgmt_util-setAttribute.md) de cloudhsm\$1mgmt\$1util. También puede generar una lista de atributos y las constantes que los representan mediante el comando [listAttribute](cloudhsm_mgmt_util-listAttributes.md) de cloudhsm\$1mgmt\$1util. En la siguiente lista se muestran los atributos que se pueden modificar después de crear un objeto: + `CKA_LABEL` + `CKA_TOKEN` **nota** La modificación solo se permite para cambiar una clave de sesión por una clave de token. Utilice el comando [setAttribute](key_mgmt_util-setAttribute.md) de key\$1mgmt\$1util para cambiar el valor del atributo. + `CKA_ENCRYPT` + `CKA_DECRYPT` + `CKA_SIGN` + `CKA_VERIFY` + `CKA_WRAP` + `CKA_UNWRAP` + `CKA_LABEL` + `CKA_SENSITIVE` + `CKA_DERIVE` **nota** Este atributo admite la derivación de claves. Debe ser `False` para todas las claves públicas y no puede establecerse en `True`. Para las claves secretas y privadas de EC, se puede establecer en `True` o `False`. + `CKA_TRUSTED` **nota** Este atributo se puede establecer en `True` o `False` solo mediante Crypto Officer (CO). + `CKA_WRAP_WITH_TRUSTED` **nota** Aplique este atributo a una clave de datos exportable para especificar que solo puede encapsular esta clave con claves marcadas como `CKA_TRUSTED`. Una vez establecido `CKA_WRAP_WITH_TRUSTED` como true, el atributo pasa a ser de solo lectura y no se puede cambiar ni eliminar. # Interpretación de los códigos de error de la biblioteca PKCS \$111 para el SDK de AWS CloudHSM cliente 3 La especificación en la plantilla de un atributo de la biblioteca PKCS \$111 que no es compatible con una clave específica produce un error. La siguiente tabla contiene los códigos de error que se generan cuando se infringen las especificaciones: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/cloudhsm/latest/userguide/pkcs11-v3-attr-errors.html) # Ejemplos de código de la biblioteca PKCS \$111 del AWS CloudHSM Client SDK 3 Los ejemplos de código que aparecen a continuación GitHub muestran cómo realizar tareas básicas con la biblioteca PKCS \$111 para. AWS CloudHSM ## Requisitos previos para el código de muestra Antes de ejecutar las muestras, siga estos pasos para configurar su entorno: + Instale y configure la [biblioteca PKCS \$111](install-pkcs11-v3.md) para SDK 3 de cliente. + Configure un [usuario de criptografía (CU)](manage-hsm-users.md). La aplicación usa esta cuenta de HSM para ejecutar los ejemplos de código en el HSM. ## Ejemplos de código Los ejemplos de código de la biblioteca de AWS CloudHSM software de PKCS \$111 están disponibles en. [GitHub](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples) Este repositorio contiene ejemplos acerca de cómo realizar operaciones comunes con PKCS\$111, como el cifrado, el descifrado, la firma y la verificación. + [Generar claves (AES, RSA, EC)](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/generate) + [Mostrar atributos de clave](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/attributes/) + [Cifrado y descifrado de datos con AES-GCM](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/encrypt/aes_gcm.c) + [Cifrado y descifrado de datos con AES\$1CTR](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/encrypt/aes_ctr.c) + [Cifrado y descifrado de datos con 3DES](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/encrypt/des_ecb.c) + [Firmar y verificar datos con RSA](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/sign/rsa_sign.c) + [Derivar claves usando HMAC KDF](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/derivation/hmac_kdf.c) + [Encapsule y desencapsule las claves con AES utilizando el relleno PKCS \$15](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_wrapping.c) + [Encapsule y desencapsule las claves con AES sin relleno](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_no_padding_wrapping.c) + [Encapsule y desencapsule las claves con AES usando cero relleno](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/aes_zero_padding_wrapping.c) + [Encapsulamiento y desencapsulamiento de claves con AES-GCM](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/tree/master/src/wrapping/aes_gcm_wrapping.c) + [Cómo encapsular y desencapsular claves con RSA](https://github.com/aws-samples/aws-cloudhsm-pkcs11-examples/blob/master/src/wrapping/rsa_wrapping.c)