As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Mecanismos suportados pela biblioteca PKCS \#11 para AWS CloudHSM Client SDK 5 A biblioteca PKCS \#11 é compatível com a versão 2.40 da especificação PKCS \#11. Para invocar um recurso de criptografia usando o PKCS\#11, chame uma função com um determinado mecanismo. As seções a seguir resumem as combinações de funções e mecanismos suportados pelo AWS CloudHSM Client SDK 5. A biblioteca de software do para PKCS \#11 oferece suporte aos seguintes algoritmos: + **Criptografia e decodificação ** — AES-CBC AES-CTR, AES-ECB, AES-GCM, DES3-CBC,, DES3-ECB RSA-OAEP, e RSA-PKCS + **Assine e verifique ** — RSA, HMAC, ECDSA (com e sem hashing), EdDSA (Ed25519 e ED25519pH) e (com modos mu puro e externo) ML-DSA + **Hash/digest**— SHA1, SHA224, SHA256, SHA384 e SHA512 + **Envoltório de chaves ** — AES Key Wrap [1](#mech1) AES-GCM, RSA-AES, e RSA-OAEP + **Derivação de chave ** — Combata SP800-108 KDF e ECDH com KDF (os algoritmos KDF suportados são X9.63 com SHA1, SHA224, SHA256, SHA384, SHA512) **Topics** + [Gere funções de chave e par de chaves](#pkcs11-mech-function-genkey) + [Funções de assinatura e verificação](#pkcs11-mech-function-signverify) + [Assine, recupere e verifique as funções de recuperação](#pkcs11-mech-function-sr-vr) + [Funções de resumo](#pkcs11-mech-function-digest) + [Funções de criptografia e descriptografia](#pkcs11-mech-function-enc-dec) + [Derivar funções de chave](#pkcs11-mech-function-derive-key) + [Funções de agrupamento e desagrupamento](#pkcs11-mech-function-wrap-unwrap) + [Tamanho máximo de dados para cada mecanismo](#pkcs11-mech-max) + [Anotações do mecanismo](#pkcs11-mech-annotations) ## Gere funções de chave e par de chaves A biblioteca AWS CloudHSM de software da biblioteca PKCS \#11 permite que você use os seguintes mecanismos para gerar funções de chave e par de chaves. + `CKM_RSA_PKCS_KEY_PAIR_GEN` + `CKM_RSA_X9_31_KEY_PAIR_GEN`: esse mecanismo é funcionalmente idêntico ao mecanismo `CKM_RSA_PKCS_KEY_PAIR_GEN`, mas oferece maiores garantias para geração de `p` e de `q`. + `CKM_EC_KEY_PAIR_GEN` + `CKM_CLOUDHSM_ML_DSA_KEY_PAIR_GEN`[3](#mech3) + `CKM_GENERIC_SECRET_KEY_GEN` + `CKM_AES_KEY_GEN` + `CKM_DES3_KEY_GEN`: próxima mudança listada na nota de rodapé [5](#mech5). ## Funções de assinatura e verificação A biblioteca AWS CloudHSM de software da biblioteca PKCS \#11 permite que você use os seguintes mecanismos para as funções de assinatura e verificação. Com o Client SDK 5, os dados são codificados localmente no software. Isso significa que não há limite no tamanho dos dados que podem ser criptografados pelo SDK. Com o Client SDK 5, o hashing RSA e ECDSA é feito localmente; portanto, não há limite de dados. Com o HMAC e o PureEd DSA (Ed25519), há um limite de dados. Consulte a nota de rodapé [2](#mech2) para obter mais informações. **RSA** + `CKM_RSA_X_509` + `CKM_RSA_PKCS`: somente operações de uma única parte. + `CKM_RSA_PKCS_PSS`: somente operações de uma única parte. + `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`: somente operações de uma única parte. + `CKM_ECDSA_SHA1` + `CKM_ECDSA_SHA224` + `CKM_ECDSA_SHA256` + `CKM_ECDSA_SHA384` + `CKM_ECDSA_SHA512` **ML-DSA** + `CKM_CLOUDHSM_ML_DSA_KEY_PAIR_GEN`[3](#mech3)— Gera pares de ML-DSA chaves. + `CKM_CLOUDHSM_ML_DSA`[3](#mech3)— ML-DSA Assinar e verificar de forma pura. + `CKM_CLOUDHSM_EXT_MU_ML_DSA`[3](#mech3)— ML-DSA assine e verifique com um mu externo. **EdDSA ** + `CKM_CLOUDHSM_EDDSA`[6](#kdf6), [7](#mech7) — com parâmetros NULL (PureEdDSA), somente operações de peça única. **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` ## Assine, recupere e verifique as funções de recuperação O Client SDK 5 não oferece suporte às funções Sign Recover (recuperação de assinatura) e Verify Recover (verificar recuperação). ## Funções de resumo A biblioteca AWS CloudHSM de software da biblioteca PKCS \#11 permite que você use os seguintes mecanismos para as funções Digest. Com o Client SDK 5, os dados são codificados localmente no software. Isso significa que não há limite no tamanho dos dados que podem ser criptografados pelo SDK. + `CKM_SHA_1` + `CKM_SHA224` + `CKM_SHA256` + `CKM_SHA384` + `CKM_SHA512` ## Funções de criptografia e descriptografia A biblioteca AWS CloudHSM de software da biblioteca PKCS \#11 permite que você use os seguintes mecanismos para as funções de criptografar e descriptografar. + `CKM_RSA_X_509` + `CKM_RSA_PKCS`: somente operações de uma única parte. Próxima mudança listada na nota de rodapé [5](#mech5). + `CKM_RSA_PKCS_OAEP`: somente operações de uma única parte. + `CKM_AES_ECB` + `CKM_AES_CTR` + `CKM_AES_CBC` + `CKM_AES_CBC_PAD` + `CKM_DES3_CBC`: próxima mudança listada na nota de rodapé [5](#mech5). + `CKM_DES3_ECB`: próxima mudança listada na nota de rodapé [5](#mech5). + `CKM_DES3_CBC_PAD`: próxima mudança listada na nota de rodapé [5](#mech5). + `CKM_AES_GCM` [1](#mech1), [2](#mech2) + `CKM_CLOUDHSM_AES_GCM`[3](#mech3) ## Derivar funções de chave A biblioteca AWS CloudHSM de software da biblioteca PKCS \#11 suporta os seguintes mecanismos de derivação de chaves: + `CKM_SP800_108_COUNTER_KDF` + `CKM_ECDH1_DERIVE`: é compatível com derivação de chave ECDH com os seguintes tipos de KDF definidos pelo fornecedor: [6](#kdf6) + `CKD_CLOUDHSM_X963_SHA1_KDF`- X9.63 KDF com SHA1 [8](#kdf7) + `CKD_CLOUDHSM_X963_SHA224_KDF`- X9.63 KDF com SHA224 [8](#kdf7) + `CKD_CLOUDHSM_X963_SHA256_KDF`- X9.63 KDF com SHA256 [8](#kdf7) + `CKD_CLOUDHSM_X963_SHA384_KDF`- X9.63 KDF com SHA384 [8](#kdf7) + `CKD_CLOUDHSM_X963_SHA512_KDF`- X9.63 KDF com SHA512 [8](#kdf7) ## Funções de agrupamento e desagrupamento A biblioteca AWS CloudHSM de software da biblioteca PKCS \#11 permite que você use os seguintes mecanismos para as funções Wrap e Unwrap. Para obter opções adicionais de empacotamento de chaves AES, consulte [Empacotamento de chaves AES](manage-aes-key-wrapping.md). + `CKM_RSA_PKCS`: somente operações de uma única parte. Uma nova mudança futura listada na nota de rodapé [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) ## Tamanho máximo de dados para cada mecanismo A tabela a seguir lista o tamanho máximo de dados definido para cada mecanismo: **Tamanho máximo do conjunto de dados** | **Mecanismo** | **Tamanho máximo de dados em bytes** | | --- | --- | | CKM\_SHA\_1\_HMAC | 16288 | | CKM\_SHA224\_HMAC | 16256 | | CKM\_SHA256\_HMAC | 16288 | | CKM\_SHA384\_HMAC | 16224 | | CKM\_SHA512\_HMAC | 16224 | | CKM\_AES\_CBC | 16272 | | CKM\_AES\_GCM | 16224 | | CKM\_CLOUDHSM\_AES\_GCM | 16224 | | CKM\_DES3\_CBC | 16280 | | CKM\_CLOUDHSM\_EDDSA(PureEdDSA, parâmetros NULL) | 16000 | ## Anotações do mecanismo + [1] Ao realizar a AES-GCM criptografia, o HSM não aceita dados do vetor de inicialização (IV) do aplicativo. Você deve usar um IV gerado por ele. O IV de 12 bytes fornecido pelo HSM é gravado na referência da memória apontada pelo elemento pIV da estrutura de parâmetros `CK_GCM_PARAMS` que você fornece. Para evitar confusão entre os usuários, o SDK PKCS \#11 na versão 1.1.1 e posterior garante que o PiV aponte para um buffer zerado quando a criptografia é inicializada. AES-GCM + [2] Ao trabalhar com dados usando qualquer um dos mecanismos a seguir, se o buffer de dados exceder o tamanho máximo de dados, a operação resultará em um erro. Para esses mecanismos, todo o processamento de dados deve ocorrer dentro do HSM. Para obter informações sobre conjuntos de tamanho máximo de dados para cada mecanismo, consulte [Tamanho máximo de dados para cada mecanismo](#pkcs11-mech-max). + [3] Vendor-defined mecanismo. Para usar os mecanismos definidos pelo fornecedor do CloudHSM, os aplicativos PKCS \#11 devem incluir `/opt/cloudhsm/include/pkcs11/pkcs11t.h` durante a compilação. `CKM_CLOUDHSM_AES_GCM`: Este mecanismo proprietário é uma alternativa programaticamente mais segura para o padrão `CKM_AES_GCM`. Ele antecede o IV gerado pelo HSM para o texto cifrado em vez de escrevê-lo de volta na estrutura `CK_GCM_PARAMS` fornecida durante a inicialização da cifra. Você pode usar esse mecanismo com as funções `C_Encrypt`, `C_WrapKey`, `C_Decrypt`, e `C_UnwrapKey`. Ao usar esse mecanismo, a variável pIV no struct `CK_GCM_PARAMS` deve ser definida como `NULL`. Ao usar este mecanismo com `C_Decrypt` e `C_UnwrapKey`, espera-se que o IV seja precedido pelo texto cifrado que está sendo desencapsulado. `CKM_CLOUDHSM_AES_KEY_WRAP_PKCS5_PAD`: Agrupamento de chaves AES com preenchimento PKCS \#5. `CKM_CLOUDHSM_AES_KEY_WRAP_ZERO_PAD`: Agrupamento de chaves AES com preenchimento de zeros. `CKM_CLOUDHSM_ML_DSA_KEY_PAIR_GEN`: gera um par de ML-DSA chaves. Use o `CKA_CLOUDHSM_PARAMETER_SET` atributo (tipo`CK_CLOUDHSM_ML_DSA_PARAMETER_SET_TYPE`) para especificar o conjunto de parâmetros. Valores válidos: `CKP_CLOUDHSM_ML_DSA_44`, `CKP_CLOUDHSM_ML_DSA_65`, `CKP_CLOUDHSM_ML_DSA_87`. `CKM_CLOUDHSM_ML_DSA`: Pure, ML-DSA assine e verifique. Assina ou verifica dados brutos usando um par de ML-DSA chaves. `CKM_CLOUDHSM_EXT_MU_ML_DSA`: ML-DSA assine e verifique com um mu externo. Assina ou verifica dados que foram pré-processados em um valor mu externo. `CKM_CLOUDHSM_EDDSA`: Mecanismo de assinatura EdDSA. Com parâmetros NULL: PureEd DSA (Ed25519), somente peça única, máximo de 16.000 bytes. Com `CK_EDDSA_PARAMS` (`phFlag = CK_TRUE`,`ulContextDataLen = 0`): ED25519Ph, peça única e multipeça, sem limite de tamanho. A `CK_EDDSA_PARAMS` estrutura segue a especificação [ PKCS \#11 v3.0. ](https://docs.oasis-open.org/pkcs11/pkcs11-curr/v3.0/pkcs11-curr-v3.0.html) + [4] Os seguintes `CK_MECHANISM_TYPE` e `CK_RSA_PKCS_MGF_TYPE` são compatíveis como `CK_RSA_PKCS_OAEP_PARAMS` para `CKM_RSA_PKCS_OAEP`: + `CKM_SHA_1` usando `CKG_MGF1_SHA1` + `CKM_SHA224` usando `CKG_MGF1_SHA224` + `CKM_SHA256` usando `CKG_MGF1_SHA256` + `CKM_SHA384` usando `CKM_MGF1_SHA384` + `CKM_SHA512` usando `CKM_MGF1_SHA512` + [5] De acordo com a orientação do NIST, isso não é permitido em clusters no modo FIPS após 2023. Para clusters no modo não FIPS, isso ainda é permitido após 2023. Para mais detalhes, consulte [Conformidade com o FIPS 140: suspensão do mecanismo de 2024](compliance-dep-notif.md#compliance-dep-notif-1). + [6] Tipos definidos pelo fornecedor. Para usar os tipos definidos pelo fornecedor do CloudHSM, as aplicação PKCS \#11 devem incluir `cloudhsm_pkcs11_vendor_defs.h` durante a compilação. Isso pode ser localizado em `/opt/cloudhsm/include/pkcs11/cloudhsm_pkcs11_vendor_defs.h` para plataformas baseadas em Linux e em `C:\Program Files\Amazon\CloudHSM\include\pkcs11\cloudhsm_pkcs11_vendor_defs.h` para plataformas baseadas no Windows + [7] Suportado apenas em instâncias hsm2m.medium no modo não FIPS. + [8] As funções de derivação chave (KDFs) são especificadas na Publicação Especial 800-56A do [ NIST, Revisão 3. ](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-56Ar3.pdf)