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

Alterar seu modelo de dados

Sempre que criptografa ou descriptografa um item, você precisa fornecer dações de atributos que informam ao DynamoDB Encryption Client quais atributos criptografar e assinar, quais assinar (mas não criptografar) e quais ignorar. As ações de atributos não são salvas no item criptografado e o DynamoDB Encryption Client não atualiza as ações de atributos automaticamente.

Sempre que alterar seu modelo de dados, ou seja, ao adicionar ou remover atributos de seus itens de tabela, você corre o risco de um erro. Se as ações de atributo especificadas por você não justificam todos os atributos no item, ele não poderá ser criptografado nem assinado como você deseja. O mais importante é que se as ações dos atributos fornecidas por você ao descriptografar um item forem diferentes das ações de atributos fornecidas ao criptografar o item, poderá ocorrer uma falha na verificação da assinatura.

Por exemplo, se as ações de atributo usadas para criptografar o item o instruem a assinar o atributo test, a assinatura no item incluirá o atributo test. Mas se as ações de atributo usadas para descriptografar o item não justificam o atributo test, ocorrerá uma falha na verificação porque o cliente tentará verificar uma assinatura que não inclui o atributo test.

Esse é um problema específico quando vários aplicativos leem e gravam os mesmos itens do DynamoDB porque o DynamoDB Encryption Client precisa calcular a mesma assinatura para itens em todos os aplicativos. Também é um problema para qualquer aplicativo distribuído porque as alterações nas ações de atributos devem ser propagadas para todos os hosts. Mesmo que suas tabelas do DynamoDB sejam acessadas por um único host em um processo, o estabelecimento de um processo de melhores práticas ajudará a evitar erros se o projeto se tornar mais complexo.

Para evitar erros de validação de assinatura que impedem a leitura de itens de tabela, use as orientações a seguir.

Erros de validação de assinatura podem ser extremamente difíceis de resolver, portanto, a melhor abordagem é evitá-los.

Adicionar um atributo

Ao adicionar um novo atributo a itens de tabela, talvez seja necessário alterar as ações de seus atributos. Para evitar erros de validação de assinatura, é recomendável implementar essa alteração em um processo de dois estágios. Verifique se o primeiro estágio está completo antes de iniciar o segundo estágio.

Essa abordagem em dois estágios garante que todos os aplicativos e hosts tenham as mesmas ações de atributos e calculará a mesma assinatura, antes de qualquer encontro com o novo atributo. Isso é importante mesmo quando a ação do atributo for Não fazer nada (não criptografar ou assinar), porque o padrão para alguns criptografadores é criptografar e assinar.

Os exemplos a seguir mostram o código para o primeiro estágio desse processo. Eles adicionam um novo atributo de item, link, que armazena um link para outro item da tabela. Como esse link deve permanecer em texto simples, o exemplo atribui a ele a ação somente assinar. Depois de implantar totalmente essa alteração e verificar se todos os aplicativos e hosts têm as novas ações de atributos, é possível começar a usar o atributo link em seus itens de tabela.

Java DynamoDB Mapper

Por padrão, ao usar o DynamoDB Mapper e o AttributeEncryptor, todos os atributos são criptografados e assinados, exceto as chaves primárias que são assinadas, mas não são criptografadas. Para especificar uma ação de somente assinatura, use a anotação @DoNotEncrypt.

Este exemplo usa a anotação @DoNotEncrypt para o novo atributo link.

@DynamoDBTable(tableName = "ExampleTable")
public static final class DataPoJo {
  private String partitionAttribute;
  private int sortAttribute;
  private String link;

  @DynamoDBHashKey(attributeName = "partition_attribute")
  public String getPartitionAttribute() {
    return partitionAttribute;
  }
    
  public void setPartitionAttribute(String partitionAttribute) {
    this.partitionAttribute = partitionAttribute;
  }

  @DynamoDBRangeKey(attributeName = "sort_attribute")
  public int getSortAttribute() {
    return sortAttribute;
  }

  public void setSortAttribute(int sortAttribute) {
    this.sortAttribute = sortAttribute;
  }

  @DynamoDBAttribute(attributeName = "link")
  @DoNotEncrypt
  public String getLink() {
    return link;
  }

  public void setLink(String link) {
    this.link = link;
  }

  @Override
  public String toString() {
    return "DataPoJo [partitionAttribute=" + partitionAttribute + ",
        sortAttribute=" + sortAttribute + ",
        link=" + link + "]";
  }
}            

Java DynamoDB encryptor

No DynamoDB Encryptor de nível inferior, você deve definir ações para cada atributo. Este exemplo usa uma instrução switch em que o padrão é encryptAndSign e exceções são especificadas para a chave de partição, a chave de classificação e o novo atributo link. Neste exemplo, se o código do atributo link não for totalmente implantado antes de ser usado, o atributo link será criptografado e assinado por alguns aplicativos, mas somente assinado por outros.

for (final String attributeName : record.keySet()) {
    switch (attributeName) {
        case partitionKeyName:
            // fall through to the next case
        case sortKeyName:
            // partition and sort keys must be signed, but not encrypted
            actions.put(attributeName, signOnly);
            break;
        case "link":
            // only signed
            actions.put(attributeName, signOnly);
            break;
        default:
            // Encrypt and sign all other attributes
            actions.put(attributeName, encryptAndSign);
            break;
    }
}               

Python

No DynamoDB Encryption Client para Python, é possível especificar uma ação padrão para todos os atributos e especificar exceções.

Se você usa uma classe auxiliar do cliente do Python, não será necessário especificar uma ação de atributo para os atributos de chave primária. As classes auxiliares do cliente evitam que você criptografe sua chave primária. No entanto, se você não estiver usando uma classe auxiliar de cliente, deverá definir a ONLY ação SIGN _ na chave de partição e na chave de classificação. Se você criptografar acidentalmente sua chave de partição ou de classificação, não será possível recuperar seus dados sem uma verificação completa da tabela.

Este exemplo especifica uma exceção para o novo atributo link, que obtém a ação SIGN_ONLY.

actions = AttributeActions(
    default_action=CryptoAction.ENCRYPT_AND_SIGN,
    attribute_actions={
      'example': CryptoAction.DO_NOTHING,  
      'link': CryptoAction.SIGN_ONLY
    }
)

Remover um atributo

Se você não precisar mais de um atributo em itens que foram criptografados com o DynamoDB Encryption Client, poderá parar de usar o atributo. No entanto, não exclua nem altere a ação desse atributo. Se o fizer e depois encontrar um item com esse atributo, a assinatura calculada para o item não corresponderá à assinatura original, e a validação da assinatura falhará.

Embora você possa ser tentado a remover todos os traços do atributo do seu código, adicione um comentário informando que o item não é mais usado em vez de excluí-lo. Mesmo que você faça uma verificação de tabela completa para excluir todas as instâncias do atributo, um item criptografado com esse atributo pode ser armazenado em cache ou em processo em algum lugar da configuração.