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á.
# Uso do DynamoDB Encryption Client para Java
**nota**
Nossa biblioteca de criptografia do lado do cliente foi [renomeada como SDK de criptografia de banco de dados da AWS](DDBEC-rename.md). O tópico a seguir fornece informações sobre as versões 1.*x*—2.*x* do DynamoDB Encryption Client para Java e versões 1.*x*—3*x* do DynamoDB Encryption Client para Python. Para obter mais informações, consulte [SDK de criptografia de banco de dados da AWS para obter suporte à versão do DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Este tópico explica alguns dos recursos do DynamoDB Encryption Client para Java que talvez não sejam encontrados em outras implementações de linguagem de programação.
[Para obter detalhes sobre a programação com o DynamoDB Encryption Client, consulte [os exemplos em Java, os](java-examples.md) exemplos em GitHub on e [o](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) Javadoc para `aws-dynamodb-encryption-java repository` o DynamoDB Encryption Client.](https://aws.github.io/aws-dynamodb-encryption-java/)
**Topics**
+ [Criptografadores de itens](#attribute-encryptor)
+ [Configurar o comportamento de salvamento](#save-behavior)
+ [Ações de atributos em Java](#attribute-actions-java)
+ [Substituir nomes de tabelas](#override-table-name)
## Criptografadores de itens: AttributeEncryptor e Dynamo DBEncryptor
[O DynamoDB Encryption Client em Java tem [dois criptografadores de itens](DDBEC-legacy-concepts.md#item-encryptor): o Dynamo de nível inferior e o. DBEncryptor [AttributeEncryptor](#attribute-encryptor)](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
`AttributeEncryptor`É uma classe auxiliar que ajuda você a usar [o Dynamo AWS SDK para Java com o DBMapper](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) no DynamoDB `DynamoDB Encryptor` Encryption Client. Ao usar o `AttributeEncryptor` com o `DynamoDBMapper`, ele criptografa e assina seus itens de forma transparente quando você os salva. Ele também verifica e descriptografa seus itens de forma transparente quando você os carrega.
## Configurar o comportamento de salvamento
É possível usar o `AttributeEncryptor` e o `DynamoDBMapper` para adicionar ou substituir itens de tabela com atributos assinados somente ou criptografados e assinados. Para essas tarefas, recomendamos que você o configure para usar o comportamento de salvamento `PUT`, conforme mostrado no exemplo a seguir. Caso contrário, talvez você não possa descriptografar os dados.
```
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Se você usar o comportamento padrão de salvamento, que atualiza somente os atributos que são modelados no item da tabela, os atributos não serão incluídos na assinatura e não serão alterado nas gravações da tabela. Como resultado, em leituras posteriores de todos os atributos, a assinatura não será validada porque não inclui atributos não modelados.
Também é possível usar o comportamento de salvamento `CLOBBER`. Esse comportamento é idêntico ao comportamento de salvamento `PUT`, exceto pelo fato de que ele desabilita o bloqueio otimista e substitui o item na tabela.
Para evitar erros de assinatura, o DynamoDB Encryption Client lança uma exceção de runtime se um `AttributeEncryptor` for usado com um `DynamoDBMapper` que não esteja configurado com um comportamento de salvamento de `CLOBBER` ou `PUT`.
Para ver esse código usado em um exemplo, consulte [Usando o Dynamo DBMapper](java-examples.md#java-example-dynamodb-mapper) o exemplo [AwsKmsEncryptedObjectde.java](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java) no `aws-dynamodb-encryption-java` repositório em. GitHub
## Ações de atributos em Java
As [Ações de atributos](DDBEC-legacy-concepts.md#legacy-attribute-actions) determinam quais valores de atributo são criptografados e assinados, quais são apenas assinados e quais são ignorados. [O método usado para especificar ações de atributos depende de você usar o `DynamoDBMapper` e ou o `AttributeEncryptor` Dynamo de nível inferior. DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
**Importante**
Depois de usar as ações do atributo para criptografar os itens da tabela, adicionar ou remover atributos do modelo de dados poderá gerar um erro de validação de assinatura que impede a descriptografia dos dados. Para obter uma explicação detalhada, consulte [Alterar seu modelo de dados](data-model.md).
### Ações de atributos para o Dynamo DBMapper
Ao usar o `DynamoDBMapper` e o `AttributeEncryptor`, use anotações para especificar as ações de atributos. O DynamoDB Encryption Client usa as [anotações de atributo padrão do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Annotations.html) que definem o tipo do atributo para determinar como proteger um atributo. Por padrão, todos os atributos são criptografados e assinados, exceto as chaves primárias, que são assinadas, mas não são criptografadas.
**nota**
Não criptografe o valor dos atributos com a [anotação @Dynamo DBVersion Attribute](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptimisticLocking.html), embora você possa (e deva) assiná-los. Caso contrário, as condições que usam o valor terão efeitos indesejados.
```
// Attributes are encrypted and signed
@DynamoDBAttribute(attributeName="Description")
// Partition keys are signed but not encrypted
@DynamoDBHashKey(attributeName="Title")
// Sort keys are signed but not encrypted
@DynamoDBRangeKey(attributeName="Author")
```
Para especificar exceções, use as anotações de criptografia definidas no DynamoDB Encryption Client para Java. Se você especificá-las no nível da classe, elas se tornam o valor padrão para a classe.
```
// Sign only
@DoNotEncrypt
// Do nothing; not encrypted or signed
@DoNotTouch
```
Por exemplo, essas anotações assinam, mas não criptografam o atributo `PublicationYear`, e não criptografam nem assinam o valor de atributo `ISBN`.
```
// Sign only (override the default)
@DoNotEncrypt
@DynamoDBAttribute(attributeName="PublicationYear")
// Do nothing (override the default)
@DoNotTouch
@DynamoDBAttribute(attributeName="ISBN")
```
### Ações de atributos para o Dynamo DBEncryptor
Para especificar ações de atributos ao usar [o Dynamo DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html) diretamente, crie um `HashMap` objeto no qual os pares nome-valor representem os nomes dos atributos e as ações especificadas.
Os valores válidos para as ações de atributo estão definidos no tipo enumerado de `EncryptionFlags`. Você pode usar `ENCRYPT` e `SIGN` juntos, usar `SIGN` isoladamente ou omitir os dois. No entanto, se você usar `ENCRYPT` sozinho, o DynamoDB Encryption Client gerará um erro. Você não pode criptografar um atributo que você não assine.
```
ENCRYPT
SIGN
```
**Atenção**
Não criptografe os atributos da chave primária. Eles devem permanecer em texto simples para que o DynamoDB possa encontrar o item sem executar uma varredura completa da tabela.
Se você especificar uma chave primária no contexto de criptografia e especificar `ENCRYPT` na ação de um atributo de chave primária, o DynamoDB Encryption Client gerará uma exceção.
Por exemplo, o código Java a seguir cria um `actions` HashMap que criptografa e assina todos os atributos no `record` item. As exceções são os atributos de chave de partição e de chave de classificação que são assinados, mas não criptografados, e o atributo `test` que não é assinado nem criptografado.
```
final EnumSet signOnly = EnumSet.of(EncryptionFlags.SIGN);
final EnumSet encryptAndSign = EnumSet.of(EncryptionFlags.ENCRYPT, EncryptionFlags.SIGN);
final Map> actions = new HashMap<>();
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName: // no break; falls through to next case
case sortKeyName:
// Partition and sort keys must not be encrypted, but should be signed
actions.put(attributeName, signOnly);
break;
case "test":
// Don't encrypt or sign
break;
default:
// Encrypt and sign everything else
actions.put(attributeName, encryptAndSign);
break;
}
}
```
Ao chamar o método [encryptRecord](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html#encryptRecord-java.util.Map-java.util.Map-com.amazonaws.services.dynamodbv2.datamodeling.encryption.EncryptionContext-) do `DynamoDBEncryptor`, especifique o mapa como o valor do parâmetro `attributeFlags`. Por exemplo, esta chamada para `encryptRecord` usa o mapa `actions`.
```
// Encrypt the plaintext record
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
## Substituir nomes de tabelas
No DynamoDB Encryption Client, o nome da tabela do DynamoDB é um elemento do [contexto de criptografia do DynamoDB](concepts.md#encryption-context) que é passado para os métodos de criptografia e de descriptografia. Quando você criptografa ou assina itens de tabela, o contexto de criptografia do DynamoDB, inclusive o nome da tabela, é vinculado criptograficamente ao texto cifrado. Se o contexto de criptografia do DynamoDB passado para o método de descriptografia não corresponder ao contexto de criptografia do DynamoDB passado para o método de criptografia, a operação de descriptografia falhará.
Ocasionalmente, o nome de uma tabela muda, como quando você faz backup de uma tabela ou executa uma [point-in-time recuperação](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html). Ao descriptografar ou verificar a assinatura desses itens, passe o mesmo contexto de criptografia do DynamoDB usado para criptografar e assinar os itens, inclusive o nome da tabela original. O nome da tabela atual não é necessário.
Quando você usa o `DynamoDBEncryptor`, você monta o contexto de criptografia do manualmente. No entanto, se você estiver usando o `DynamoDBMapper`, o `AttributeEncryptor` criará o contexto de criptografia do DynamoDB para você, incluindo o nome da tabela atual. Para informar ao `AttributeEncryptor` para criar um contexto de criptografia com um nome de tabela diferente, use o `EncryptionContextOverrideOperator`.
Por exemplo, o código a seguir cria instâncias do provedor de materiais de criptografia (CMP) e do `DynamoDBEncryptor`. Depois, ele chama o método `setEncryptionContextOverrideOperator` do `DynamoDBEncryptor`. Ele usa o operador `overrideEncryptionContextTableName`, que substitui um nome de tabela. Quando ele é configurado dessa maneira, o `AttributeEncryptor` cria um contexto de criptografia do DynamoDB que inclui `newTableName` no lugar de `oldTableName`. Para ver um exemplo completo, consulte [EncryptionContextOverridesWithDynamoDBMapper.java.](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/EncryptionContextOverridesWithDynamoDBMapper.java)
```
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
encryptor.setEncryptionContextOverrideOperator(EncryptionContextOperators.overrideEncryptionContextTableName(
oldTableName, newTableName));
```
Quando você chama o método de carregamento do `DynamoDBMapper`, que descriptografa e verifica o item, você especifica o nome da tabela original.
```
mapper.load(itemClass, DynamoDBMapperConfig.builder()
.withTableNameOverride(DynamoDBMapperConfig.TableNameOverride.withTableNameReplacement(oldTableName))
.build());
```
Também é possível usar o operador `overrideEncryptionContextTableNameUsingMap`, que substitui vários nomes de tabela.
Normalmente, os operadores de substituição de nome de tabela são usados ao descriptografar dados e verificar assinaturas. No entanto, é possível usá-los para definir o nome da tabela no contexto de criptografia do DynamoDB como um valor diferente ao criptografar e assinar.
Não use os operadores de substituição de nome de tabela se estiver usando o `DynamoDBEncryptor`. Em vez disso, crie um contexto de criptografia com o nome da tabela original e envie-o para o método de descriptografia.