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

AWS KMS Chaveiros hierárquicos

Com o AWS KMS chaveiro hierárquico, você pode proteger seus materiais criptográficos com uma chave KMS de criptografia simétrica sem ligar AWS KMS sempre que criptografar ou descriptografar um registro. É uma boa opção para aplicativos que precisam minimizar as chamadas e aplicativos que podem reutilizar alguns materiais criptográficos sem violar seus requisitos de segurança. AWS KMS

O chaveiro hierárquico é uma solução de armazenamento em cache de materiais criptográficos que reduz o número de AWS KMS chamadas usando chaves de ramificação AWS KMS protegidas persistentes em uma tabela do Amazon DynamoDB e, em seguida, armazenando localmente em cache materiais de chave de ramificação usados em operações de criptografia e descriptografia. A tabela do DynamoDB serve como o armazenamento de chaves de ramificação que gerencia e protege as chaves de ramificação. Ele armazena a chave de ramificação ativa e todas as versões anteriores da chave de ramificação. A chave de ramificação ativa é a versão mais recente da chave de ramificação. O token de autenticação hierárquico usa uma chave de dados exclusiva para criptografar cada campo e criptografa cada chave de dados com uma chave de empacotamento exclusiva derivada da chave de ramificação ativa. O token de autenticação hierárquico depende da hierarquia estabelecida entre as chaves de ramificação ativas e suas chaves de empacotamento derivadas.

O token de autenticação hierárquico normalmente usa cada versão da chave de ramificação para atender a várias solicitações. Porém, você controla até que ponto as chaves de ramificação ativas são reutilizadas e determina com que frequência a chave de ramificação ativa é alternada. A versão ativa da chave de ramificação permanece ativa até que você a alterne. As versões anteriores da chave de ramificação ativa não serão usadas para realizar operações de criptografia, mas ainda podem ser consultadas e usadas em operações de descriptografia.

Quando você instancia o token de autenticação hierárquico, ele cria um cache local. Você especifica um limite de cache que define o tempo máximo em que os materiais da chave de ramificação são armazenados no cache local antes de expirarem e serem despejados do cache. O chaveiro hierárquico faz uma AWS KMS chamada para descriptografar a chave de ramificação e montar os materiais da chave de ramificação na primeira vez em que a é especificado em uma branch-key-id operação. Em seguida, os materiais da chave de ramificação são armazenados no cache local e reutilizados para todas as operações de criptografia e descriptografia que especificam branch-key-id até que o limite do cache expire. Armazenar materiais de chave de filial no cache local reduz AWS KMS as chamadas. Por exemplo, considere um limite de cache de 15 minutos. Se você realizar 10.000 operações de criptografia dentro desse limite de cache, o AWS KMS chaveiro tradicional precisaria fazer 10.000 AWS KMS chamadas para satisfazer 10.000 operações de criptografia. Se você tiver um ativobranch-key-id, o chaveiro hierárquico só precisará fazer uma AWS KMS chamada para satisfazer 10.000 operações de criptografia.

O cache local consiste em duas partições, uma para operações de criptografia e outra para operações de descriptografia. A partição criptografada armazena os materiais da chave de ramificação reunidos a partir da chave de ramificação ativa e os reutiliza para todas as operações de criptografia até que o limite de cache expire. A partição de descriptografia armazena os materiais da chave de ramificação reunidos para outras versões de chave de ramificação identificadas nas operações de descriptografia. A partição de decodificação pode armazenar várias versões ativas de materiais de chave de ramificação ao mesmo tempo. Quando configurada para usar um fornecedor de ID de chave de ramificação para um banco de dados multilocatário, a partição criptografada também pode armazenar várias versões de materiais de chave de ramificação ao mesmo tempo. Para ter mais informações, consulte Uso do token de autenticação hierárquico com bancos de dados multilocatários.

Como funciona

As instruções a seguir descrevem como o token de autenticação hierárquico reúne materiais de criptografia e descriptografia e as diferentes chamadas que o token de autenticação faz para operações de criptografia e descriptografia. Para obter detalhes técnicos sobre a derivação da chave de empacotamento e os processos de criptografia da chave de dados em texto simples, consulte Detalhes técnicos do token de autenticação hierárquico do AWS KMS.

Criptografar e assinar

O passo a passo a seguir descreve como o token de autenticação hierárquico reúne materiais de criptografia e obtém uma chave de empacotamento exclusiva.

Descriptografar e verificar

O passo a passo a seguir descreve como o token de autenticação hierárquico reúne materiais de decodificação e decifra a chave de dados criptografada.

Pré-requisitos

O SDK AWS de criptografia de banco de dados não exige um Conta da AWS e não depende de nenhum AWS service (Serviço da AWS). No entanto, o chaveiro hierárquico depende do Amazon AWS KMS DynamoDB.

Para usar um chaveiro hierárquico, você precisa de uma criptografia AWS KMS key simétrica com as permissões kms:Decrypt. Também é possível usar uma chave multirregional de criptografia simétrica. Para obter informações detalhadas sobre permissões para o AWS KMS keys, consulte Autenticação e controle de acesso no Guia do Desenvolvedor do AWS Key Management Service .

Antes de criar e usar um token de autenticação hierárquico, você deve criar seu repositório de chaves de ramificação e preenchê-lo com sua primeira chave de ramificação ativa.

Criar um token de autenticação hierárquico

Para inicializar o token de autenticação hierárquico, você deve fornecer os seguintes valores:

Os exemplos a seguir demonstram como inicializar um chaveiro hierárquico com o AWS Database Encryption SDK for DynamoDB client. O exemplo a seguir especifica um limite de cache TTL de 600 segundos.

Java

final MaterialProviders matProv = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
        .keyStore(branchKeyStoreName)
        .branchKeyId(branch-key-id)
        .ttlSeconds(600)
        .build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);

C# / .NET

var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
   KeyStore = keystore,
   BranchKeyIdSupplier = branchKeyIdSupplier,
   TtlSeconds = 600
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);

Alternar sua chave de ramificação ativa

Só pode haver uma versão ativa para cada chave de ramificação por vez. O token de autenticação hierárquico normalmente usa cada versão ativa da chave de ramificação para atender a várias solicitações. Porém, você controla até que ponto as chaves de ramificação ativas são reutilizadas e determina com que frequência a chave de ramificação ativa é alternada.

As chaves de ramificação não são usadas para criptografar chaves de dados em texto simples. Eles são usados para derivar as chaves de empacotamento exclusivas que criptografam chaves de dados de texto simples. O processo de derivação da chave de empacotamento produz uma chave de empacotamento exclusiva de 32 bytes com 28 bytes de randomização. Isso significa que uma chave de ramificação pode derivar mais de 79 octilhões, ou 2⁹⁶, chaves de empacotamento exclusivas antes que ocorra o desgaste criptográfico. Apesar desse risco de exaustão muito baixo, talvez seja necessário alternar suas chaves de ramificações ativas devido a regras comerciais ou contratuais ou regulamentações governamentais.

A versão ativa da chave de ramificação permanece ativa até que você a alterne. As versões anteriores da chave de ramificação ativa não serão usadas para realizar operações de criptografia e não podem ser usadas para derivar novas chaves de empacotamento. Porém, eles ainda podem ser consultados e fornecer chaves de empacotamento para descriptografar as chaves de dados que eles criptografaram enquanto estavam ativos.

Use a operação VersionKey do serviço de armazenamento de chaves para alternar sua chave de ramificação ativa. Quando você alterna a chave de ramificação ativa, uma nova chave de ramificação é criada para substituir a versão anterior. O branch-key-id não muda quando você alterna a chave de ramificação ativa. Você deve especificar branch-key-id que identificará a chave de ramificação ativa atual quando você chamar VersionKey.

Java

keystore.VersionKey(
    VersionKeyInput.builder()
        .branchKeyIdentifier("branch-key-id")
        .build()
);

C# / .NET

 keystore.VersionKey(new VersionKeyInput{BranchKeyIdentifier = branchKeyId});

Uso do token de autenticação hierárquico com bancos de dados multilocatários

É possível usar a hierarquia de chaves estabelecida entre as chaves de ramificação ativas e suas chaves de empacotamento derivadas para oferecer suporte a bancos de dados multilocatários criando uma chave de ramificação para cada locatário em seu banco de dados. O token de autenticação hierárquico então criptografa e assina todos os dados de um determinado locatário com sua chave de ramificação distinta. Isso permite que você armazene dados de vários locatários em um único banco de dados e isole os dados do locatário por chave de ramificação.

Cada locatário tem sua própria chave de ramificação, definida por uma branch-key-id exclusiva. Só pode haver uma versão ativa para cada branch-key-id por vez.

Fornecedor de ID de chave de filial

Antes de inicializar seu token de autenticação hierárquico para uso multilocatário, você deve criar uma chave de ramificação para cada locatário e criar um fornecedor de ID de chave de ramificação. O fornecedor da ID da chave da filial usa os campos armazenados no contexto de criptografia para determinar qual chave da filial do inquilino é necessária para descriptografar um registro. Por padrão, somente as chaves de partição e classificação são incluídas no contexto de criptografia. No entanto, você pode usar a ação SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT criptográfica para incluir campos adicionais no contexto de criptografia.

Você pode usar o fornecedor da ID da chave da filial para criar um nome amigável branch-key-ids para facilitar o reconhecimento do correto branch-key-id para um inquilino. Por exemplo, o nome amigável permite que você se refira a uma chave de ramificação como tenant1 em vez de b3f61619-4d35-48ad-a275-050f87e15122.

Para operações de descriptografia, você pode configurar estaticamente um único token de autenticação hierárquico para restringir a descriptografia a um único locatário ou usar o fornecedor da ID da chave da ramificação para identificar qual locatário é responsável por descriptografar um registro.

Primeiro, siga as etapas 1 e 2 dos procedimentos de pré-requisitos. Em seguida, use os procedimentos a seguir para criar uma chave de ramificação para cada locatário, criar um fornecedor de ID de chave de ramificação e inicializar seu token de autenticação hierárquico para uso multilocatário.

Uso do token de autenticação hierárquico para criptografia pesquisável

A criptografia pesquisável permite pesquisar registros criptografados sem descriptografar todo o banco de dados. Isso é feito indexando o valor de texto simples de um campo criptografado com um beacon. Para implementar a criptografia pesquisável, você deve usar um token de autenticação hierárquico.

A operação CreateKey de armazenamento de chaves gera uma chave de ramificação e uma chave de beacon. A chave de ramificação é usada em operações de criptografia e descriptografia de registros. A chave do beacon é usada para gerar beacons.

A chave de ramificação e a chave de beacon são protegidas pelo mesmo AWS KMS key que você especifica ao criar seu serviço de armazenamento de chaves. Depois que a CreateKey operação chama AWS KMS para gerar a chave de ramificação, ela chama kms: GenerateDataKeyWithoutPlaintext uma segunda vez para gerar a chave de beacon usando a seguinte solicitação.

{
   "EncryptionContext": { 
      "branch-key-id" : "branch-key-id",
      "type" : type,
      "create-time" : "timestamp",
      "logical-key-store-name" : "the logical table name for your branch key store",
      "kms-arn" : the KMS key ARN,
      "hierarchy-version" : 1
   },
   "KeyId": "the KMS key ARN",
   "NumberOfBytes": "32"
}

Depois de gerar as duas chaves, a CreateKey operação chama ddb: TransactWriteItems para escrever dois novos itens que manterão a chave de ramificação e a chave de beacon em seu armazenamento de chaves de ramificação.

Quando você configura um beacon padrão, o SDK do AWS Database Encryption consulta o repositório de chaves da ramificação em busca da chave do beacon. Em seguida, ele usa uma função de derivação de extract-and-expand chave baseada em HMAC (HKDF) para combinar a chave do farol com o nome do farol padrão para criar a chave HMAC para um determinado farol.

Ao contrário das chaves de ramificação, há apenas uma versão de chave de beacon por branch-key-id em um armazenamento de chaves de ramificação. A chave do beacon nunca é alternada.

Definição da fonte de chave de beacon

Ao definir a versão do beacon para seus beacons padrão e compostos, você deve identificar a chave do beacon e definir um limite de tempo de vida do cache (TTL) para os materiais da chave do beacon. Os materiais das chaves do beacon são armazenados em um cache local separado das chaves da ramificação. O trecho a seguir demonstra como definir o keySource para um banco de dados de locatário único. Identifique sua chave de beacon pelo branch-key-id que ela está associada.

Java

keySource(BeaconKeySource.builder()
        .single(SingleKeyStore.builder()
                .keyId(branch-key-id)
                .cacheTTL(6000)
                .build())
        .build())

C# / .NET

KeySource = new BeaconKeySource
{
    Single = new SingleKeyStore
    {
       KeyId = branch-key-id,
       CacheTTL = 6000
    }
}