Usando chaves confiáveis em AWS CloudHSM - AWS CloudHSM
Noções básicas sobre chaves confiáveisAtributos de chave confiáveisComo usar chaves confiáveis para agrupar chaves de dadosComo desagrupar uma chave de dados com uma chave confiável

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á.

Usando chaves confiáveis em AWS CloudHSM

AWS CloudHSM oferece suporte ao agrupamento confiável de chaves para proteger as chaves de dados contra ameaças internas. Este tópico descreve como criar chaves confiáveis para proteger os dados.

Noções básicas sobre chaves confiáveis

Uma chave confiável é uma chave usada para agrupar outras chaves e que administradores e agentes criptográficos (COs) identificam especificamente como confiáveis usando o atributo do CKA_TRUSTED. Além disso, administradores e responsáveis pela criptografia (COs) usam CKA_UNWRAP_TEMPLATE e atributos relacionados para especificar quais ações as chaves de dados podem realizar quando são desagrupadas por uma chave confiável. As chaves de dados desagrupadas pela chave confiável também devem conter esses atributos para que a operação de desagrupamento seja bem-sucedida, o que ajuda a garantir que as chaves de dados desagrupadas sejam permitidas somente para o uso pretendido.

Use o atributo CKA_WRAP_WITH_TRUSTED para identificar todas as chaves de dados que você deseja agrupar com chaves confiáveis. Isso permite restringir as chaves de dados para que os aplicativos só possam usar chaves confiáveis para desagrupá-las. Depois de definir esse atributo nas chaves de dados, o atributo se tornará somente leitura e não será possível alterá-lo. Com esses atributos em vigor, os aplicativos só podem desagrupar suas chaves de dados com as chaves em que você confia, e desagrupamentos sempre resultam em chaves de dados com atributos que limitam a forma como essas chaves podem ser usadas.

Atributos de chave confiáveis

Os atributos a seguir permitem marcar uma chave como confiável, especificar que uma chave de dados só pode ser agrupada e desagrupada com uma chave confiável e controlar o que uma chave de dados pode fazer depois de desagrupada:

  • CKA_TRUSTED: aplique esse atributo (além de CKA_UNWRAP_TEMPLATE) à chave que agrupará as chaves de dados para especificar que um administrador ou responsável pela criptografia (CO) fez a diligência necessária e confia nessa chave. Somente um administrador ou CO pode configurar um CKA_TRUSTED. O usuário de criptografia (UC) possui a chave, mas somente um CO pode definir o atributo CKA_TRUSTED.

  • CKA_WRAP_WITH_TRUSTED: Aplique esse atributo a uma chave de dados exportável para especificar que você só pode agrupar essa chave com chaves marcadas como CKA_TRUSTED. Depois que CKA_WRAP_WITH_TRUSTED for definido como verdadeiro, o atributo se torna somente para leitura e não é possível alterar ou remover o atributo.

  • CKA_UNWRAP_TEMPLATE: aplique esse atributo à chave de agrupamento (além de CKA_TRUSTED) para especificar quais nomes e valores de atributos o serviço deve aplicar automaticamente às chaves de dados que o serviço desagrupa. Quando um aplicativo envia uma chave para desencapsulamento, ele pode fornecer separadamente um modelo de desencapsulamento. Se você especificar um modelo de desagrupamento e o aplicativo fornecer seu próprio modelo de desagrupamento, o HSM usará os dois modelos para aplicar nomes e valores de atributos à chave. No entanto, se um valor no CKA_UNWRAP_TEMPLATE para a chave de encapsulamento entrar em conflito com um atributo fornecido pelo aplicativo durante a solicitação de desencapsulamento, ocorrerá uma falha na solicitação de desencapsulamento.

Para obter mais informações, consulte os tópicos a seguir:

Como usar chaves confiáveis para agrupar chaves de dados

Para usar uma chave confiável para agrupar uma chave de dados, você deve concluir três etapas básicas:

  1. Para a chave de dados que você planeja agrupar com uma chave confiável, defina seu atributo CKA_WRAP_WITH_TRUSTED como verdadeiro.

  2. Para a chave confiável com a qual você planeja agrupar a chave de dados, defina seu atributo CKA_TRUSTED como verdadeiro.

  3. Use a chave confiável para agrupar a chave de dados.

Etapa 1: defina a chave de dados CKA_WRAP_WITH_TRUSTED como verdadeira

Para a chave de dados que você deseja agrupar, escolha uma das opções a seguir para definir o atributo CKA_WRAP_WITH_TRUSTED da chave como verdadeiro. Isso restringe a chave de dados para que os aplicativos possam usar apenas chaves confiáveis ​​para agrupá-las.

Opção 1: se estiver gerando uma nova chave, defina CKA_WRAP_WITH_TRUSTED como verdadeira

Gere uma chave usando PKCS #11, JCE ou CloudHSM CLI. Consulte o código a seguir para ver um exemplo.

PKCS #11

Para gerar uma chave com PKCS #11, você precisa definir o atributo CKA_WRAP_WITH_TRUSTED da chave como verdadeiro. Conforme mostrado no exemplo a seguir, faça isso incluindo este atributo no CK_ATTRIBUTE template da chave e, em seguida, definindo o atributo como verdadeiro:

CK_BYTE_PTR label = "test_key";
CK_ATTRIBUTE template[] = {
        {CKA_WRAP_WITH_TRUSTED, &true_val,         sizeof(CK_BBOOL)},
        {CKA_LABEL,             label,             strlen(label)},
        ...
};

Para obter mais informações, consulte nossos exemplos públicos que demonstram a geração de chaves com o PKCS #11.

JCE

Para gerar uma chave com JCE, você precisa definir o atributo WRAP_WITH_TRUSTED da chave como verdadeiro. Conforme mostrado no exemplo a seguir, faça isso incluindo este atributo no KeyAttributesMap da chave e, em seguida, definindo o atributo como verdadeiro:

final String label = "test_key";
final KeyAttributesMap keySpec = new KeyAttributesMap();
keySpec.put(KeyAttribute.WRAP_WITH_TRUSTED, true);
keySpec.put(KeyAttribute.LABEL, label);
...

Para obter mais informações, consulte nossos exemplos públicos que demonstram a geração de chaves com JCE.

CloudHSM CLI

Para gerar uma chave com a CLI do CloudHSM, você precisa definir o atributo wrap-with-trusted da chave como verdadeiro. Faça isso incluindo wrap-with-trusted=true no argumento apropriado para o comando de geração de chave:

  • Para chaves simétricas, adicione wrap-with-trusted ao argumento attributes.

  • Para chaves públicas, adicione wrap-with-trusted ao argumento public-attributes.

  • Para chaves privadas, adicione wrap-with-trusted ao argumento private-attributes.

Para obter mais informações sobre pares de chaves, consulte chave generate-asymmetric-pair .

Para obter mais informações sobre pares de chaves simétricas, consulte key generate-symmetric .

Opção 2: se estiver usando uma chave existente, use a CLI do CloudHSM para defini-la como verdadeira CKA_WRAP_WITH_TRUSTED

Para definir o atributo CKA_WRAP_WITH_TRUSTED de uma chave existente como verdadeiro, siga estas etapas:

  1. Use o comando login para fazer login como usuário de criptografia (CU).

  2. Use o comando atributo do conjunto de chaves para definir o atributo da chave wrap-with-trusted como verdadeiro.

    aws-cloudhsm > key set-attribute --filter attr.label=test_key --name wrap-with-trusted --value true
{
  "error_code": 0,
  "data": {
    "message": "Attribute set successfully"
  }
}

Etapa 2: defina as chaves confiáveis ​​CKA_TRUSTED como verdadeiras

Para tornar uma chave confiável, o atributo CKA_TRUSTED deve ser definido como verdadeiro. É possível usar a CLI do CloudHSM ou o CloudHSM Management Utility (CMU) para fazer isso.

Etapa 3. Use a chave confiável para agrupar a chave de dados

Para agrupar a chave de dados mencionada na Etapa 1 com a chave confiável que você definiu na Etapa 2, consulte os links a seguir para ver exemplos de código. Cada um demonstra como agrupar as chaves.

Como desagrupar uma chave de dados com uma chave confiável

Para desagrupar uma chave de dados, você precisa de uma chave confiável CKA_UNWRAP que tenha sido definida como verdadeira. Para ser uma chave desse tipo, ela também deve atender aos seguintes critérios:

  • O atributo CKA_TRUSTED da chave deve ser definido como verdadeiro.

  • A chave deve usar atributos CKA_UNWRAP_TEMPLATE relacionados para especificar quais ações as chaves de dados podem realizar depois de desagrupadas. Se, por exemplo, você quiser que uma chave desagrupada não seja exportável, defina CKA_EXPORTABLE = FALSE como parte do CKA_UNWRAP_TEMPLATE.

nota

CKA_UNWRAP_TEMPLATE só está disponível com o PKCS #11.

Quando um aplicativo envia uma chave para ser desagrupada, ele pode fornecer separadamente um modelo de desagrupamento. Se você especificar um modelo de desagrupamento e o aplicativo fornecer seu próprio modelo de desagrupamento, o HSM usará os dois modelos para aplicar nomes e valores de atributos à chave. No entanto, se durante a solicitação de desagrupamento um valor na chave confiável entrar em CKA_UNWRAP_TEMPLATE conflito com um atributo fornecido pelo aplicativo, a solicitação de desagrupamento falhará.

Para ver um exemplo de como desagrupar uma chave de dados com uma chave confiável, consulte este exemplo de PKCS #11.