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 SDK de criptografia de banco de dados para linguagens de programação disponíveis do DynamoDB
O SDK AWS de criptografia de banco de dados para DynamoDB está disponível para as seguintes linguagens de programação. As bibliotecas específicas de linguagem variam, mas as implementações resultantes são interoperáveis. É possível criptografar com uma implementação de linguagem e descriptografar com outra. A interoperabilidade pode estar sujeita às restrições de linguagem. Em caso afirmativo, essas restrições estarão descritas no tópico sobre a implementação de linguagem.
**Topics**
+ [Java](ddb-java.md)
+ [.NET](ddb-net.md)
+ [Rust](ddb-rust.md)
# Java
****
| |
| --- |
| Nossa biblioteca de criptografia do lado do cliente foi renomeada para SDK de criptografia de AWS banco de dados. Este guia do desenvolvedor ainda fornece informações sobre o [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Este tópico explica como instalar a versão 3.*x* da biblioteca Java de criptografia do lado do cliente para o DynamoDB. Para obter detalhes sobre a programação com o SDK AWS de criptografia de banco de dados para DynamoDB, consulte os exemplos de [Java no](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) repositório -dynamodb em aws-database-encryption-sdk. GitHub
**nota**
Os tópicos a seguir se concentram na versão 3.*x* da biblioteca Java de criptografia do lado do cliente para o DynamoDB.
Nossa biblioteca de criptografia do lado do cliente foi [renomeada como SDK de criptografia de banco de dados da AWS](DDBEC-rename.md). O SDK do AWS Database Encryption continua oferecendo suporte às versões [antigas do DynamoDB](legacy-dynamodb-encryption-client.md) Encryption Client.
**Topics**
+ [Pré-requisitos](#ddb-java-prerequisites)
+ [Instalação](#ddb-java-installation)
+ [Usar o cliente Java](ddb-java-using.md)
+ [Exemplos de Java](ddb-java-examples.md)
+ [Adicionar versão 3.x a uma tabela existente](ddb-java-config-existing-table.md)
+ [Migrar para a versão 3.x](ddb-java-migrate.md)
## Pré-requisitos
Antes de instalar a versão 3.*x* da bibioteca Java de criptografia do lado do cliente, verifique se você tem os pré-requisitos a seguir.
**Um ambiente de desenvolvimento Java**
Você precisará do Java 8 ou posterior. No site da Oracle, acesse [Java SE Downloads](https://www.oracle.com/java/technologies/downloads/) e faça download e instale o Java SE Development Kit (JDK).
Se você usa o Oracle JDK, também precisara fazer download e instalar os [arquivos de política de jurisdição de força ilimitada JCE (Java Cryptography Extension)](http://www.oracle.com/java/technologies/javase-jce8-downloads.html).
**AWS SDK for Java 2.x**
O SDK AWS de criptografia de banco de dados para DynamoDB requer [o módulo DynamoDB Enhanced Client do.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) AWS SDK for Java 2.xÉ possível instalar todo o SDK ou apenas esse módulo.
Para obter informações sobre como atualizar sua versão do AWS SDK para Java, consulte [Migração da versão 1.x para a 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) do. AWS SDK para Java
O AWS SDK para Java está disponível por meio do Apache Maven. Você pode declarar uma dependência para todo AWS SDK para Java o módulo ou apenas para o `dynamodb-enhanced` módulo.
**Instale o AWS SDK para Java usando o Apache Maven**
+ Para [importar todo o AWS SDK para Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#build-the-entire-sdk-into-your-project) como uma dependência, declare-o no arquivo `pom.xml`.
+ Para criar uma dependência somente para o módulo Amazon DynamoDB no AWS SDK para Java, siga as instruções para [especificar módulos específicos](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#modules-dependencies). Defina o `groupId` como `software.amazon.awssdk` e `artifactID` como `dynamodb-enhanced`.
**nota**
Se você usar o AWS KMS chaveiro ou o AWS KMS chaveiro hierárquico, também precisará criar uma dependência para o módulo. AWS KMS Defina o `groupId` como `software.amazon.awssdk` e `artifactID` como `kms`.
## Instalação
É possível instalar a versão 3.*x* da biblioteca Java de criptografia do lado do cliente para o DynamoDB das formas a seguir.
**Uso do Apache Maven**
O Amazon DynamoDB Encryption Client para Java está disponível por meio do [Apache Maven](https://maven.apache.org/) com a definição de dependência a seguir.
```
software.amazon.cryptography
aws-database-encryption-sdk-dynamodb
version-number
```
**Uso do Gradle Kotlin**
É possível usar o [Gradle](https://gradle.org/) para declarar uma dependência no Amazon DynamoDB Encryption Client para Java adicionando o que se segue à seção de *dependências* do projeto Gradle.
```
implementation("software.amazon.cryptography:aws-database-encryption-sdk-dynamodb:version-number")
```
**Manualmente**
[Para instalar a biblioteca de criptografia Java do lado do cliente para o DynamoDB, clone ou baixe o repositório -dynamodb. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
Depois de instalar o SDK, comece examinando o código de exemplo neste guia e os [exemplos de Java no repositório](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) aws-database-encryption-sdk -dynamodb em. GitHub
# Uso do biblioteca Java de criptografia do lado do cliente para o DynamoDB
****
| |
| --- |
| Nossa biblioteca de criptografia do lado do cliente foi renomeada para SDK de criptografia de AWS banco de dados. Este guia do desenvolvedor ainda fornece informações sobre o [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Este tópico explica algumas das funções e das classes auxiliares da versão 3.*x* da biblioteca Java de criptografia do lado do cliente para o DynamoDB.
[Para obter detalhes sobre a programação com a biblioteca de criptografia Java do lado do cliente para o DynamoDB, consulte os exemplos de Java, os [exemplos de Java](java-examples.md) no repositório -dynamodb em.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) aws-database-encryption-sdk GitHub
**Topics**
+ [Criptografadores de itens](#ddb-item-encryptors)
+ [Ações de atributos](#ddb-attribute-actions)
+ [Configuração de criptografia](#ddb-config-encrypt)
+ [Atualização de itens](#ddb-update-items)
+ [Descriptografar conjuntos assinados](#ddb-java-signed-sets)
## Criptografadores de itens
Basicamente, o SDK AWS de criptografia de banco de dados para DynamoDB é um criptografador de itens. É possível usar a versão 3.*x* da biblioteca Java de criptografia do lado do cliente para o DynamoDB para criptografar, assinar, verificar e descriptografar os itens da tabela do DynamoDB das maneiras a seguir.
**O DynamoDB Enhanced Client**
É possível configurar o [DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) com `DynamoDbEncryptionInterceptor` o para criptografar e assinar automaticamente itens do lado do cliente com suas solicitações `PutItem` do DynamoDB. Com o DynamoDB Enhanced Client, é possível definir as ações de atributos usando uma [classe de dados anotada](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean). Recomendamos usar o DynamoDB Enhanced Client sempre que possível.
O DynamoDB Enhanced Client [não oferece suporte à criptografia pesquisável](searchable-encryption.md).
[O SDK AWS de criptografia de banco de dados não oferece suporte a anotações em atributos aninhados.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)
**A API de nível inferior do DynamoDB**
É possível configurar a [API de nível inferior do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html) com `DynamoDbEncryptionInterceptor` para criptografar e assinar automaticamente itens no lado do cliente com suas solicitações `PutItem` do DynamoDB.
Você deve usar a API de nível inferior do DynamoDB para usar a [criptografia pesquisável](searchable-encryption.md).
**O `DynamoDbItemEncryptor` de nível inferior**
O `DynamoDbItemEncryptor` de nível inferior criptografa, assina ou descriptografa e verifica diretamente os itens da tabela sem chamar o DynamoDB. Ele não faz solicitações `PutItem` ou `GetItem` para o DynamoDB. Por exemplo, é possível usar o `DynamoDbItemEncryptor` de nível inferior para descriptografar e verificar diretamente um item do DynamoDB que você já recuperou.
O nível inferior do `DynamoDbItemEncryptor` não oferece suporte à [criptografia pesquisável](searchable-encryption.md).
## Ações de atributos no SDK AWS de criptografia de banco de dados para DynamoDB
[As ações](concepts.md#crypt-actions) de atributo determinam quais valores de atributos são criptografados e assinados, quais são somente assinados, quais são assinados e incluídos no contexto de criptografia e quais são ignorados.
**nota**
Para usar a ação `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` criptográfica, você deve usar a versão 3.3 ou posterior do SDK de criptografia de AWS banco de dados. Implante a nova versão para todos os leitores antes de [atualizar seu modelo de dados](ddb-update-data-model.md) para incluí-la`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Se você usar a API do DynamoDB de nível inferior ou a `DynamoDbItemEncryptor` de nível inferior, deverá definir manualmente suas ações de atributos. Se você usar o DynamoDB Enhanced Client, poderá definir manualmente suas ações de atributo ou usar uma classe de dados anotada para [gerar um `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html). Para simplificar o processo de configuração, recomendamos o uso de uma classe de dados anotada. Ao usar uma classe de dados anotada, você só precisa modelar seu objeto uma vez.
**nota**
Depois de definir suas ações de atributo, você deverá definir quais atributos serão excluídos das assinaturas. Para facilitar a adição de novos atributos não assinados no futuro, recomendamos escolher um prefixo distinto (como "`:`") para identificar os atributos não assinados. Inclua esse prefixo no nome do atributo para todos os atributos marcados como `DO_NOTHING` ao definir o esquema e as ações de atributos do DynamoDB.
### Uso de uma classe de dados anotada
Use uma [classe de dados anotada](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) para especificar suas ações de atributos com o DynamoDB Enhanced Client e `DynamoDbEncryptionInterceptor`. O SDK de criptografia de banco de dados da AWS usa as [anotações de atributo padrão do DynamoDB](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.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**
Para usar a ação `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` criptográfica, você deve usar a versão 3.3 ou posterior do SDK de criptografia de AWS banco de dados. Implante a nova versão para todos os leitores antes de [atualizar seu modelo de dados](ddb-update-data-model.md) para incluí-la`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Consulte [SimpleClass.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) no repositório aws-database-encryption-sdk -dynamodb em GitHub para obter mais orientações sobre as anotações do DynamoDB Enhanced Client.
Por padrão, os atributos da chave primária são assinados, mas não criptografados (`SIGN_ONLY`), e todos os outros atributos são criptografados e assinados (`ENCRYPT_AND_SIGN`). Se você definir qualquer atributo como`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Para especificar exceções, use as anotações de criptografia definidas na biblioteca de criptografia do lado do cliente para Java do DynamoDB. Por exemplo, se você quiser que um atributo específico seja somente assinado, use a anotação `@DynamoDbEncryptionSignOnly`. Se você quiser que um atributo específico seja assinado e incluído no contexto de criptografia, use `@DynamoDbEncryptionSignAndIncludeInEncryptionContext` o. Se desejar que um atributo específico não seja assinado nem criptografado (`DO_NOTHING`), use a anotação `@DynamoDbEncryptionDoNothing`.
**nota**
[O SDK AWS de criptografia de banco de dados não oferece suporte a anotações em atributos aninhados.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)
O exemplo a seguir mostra as anotações usadas para definir `ENCRYPT_AND_SIGN` e `DO_NOTHING` atribuir ações. `SIGN_ONLY` [Para ver um exemplo que mostra as anotações usadas para definir`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, consulte SimpleClass 4.java.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java)
```
@DynamoDbBean
public class SimpleClass {
private String partitionKey;
private int sortKey;
private String attribute1;
private String attribute2;
private String attribute3;
@DynamoDbPartitionKey
@DynamoDbAttribute(value = "partition_key")
public String getPartitionKey() {
return this.partitionKey;
}
public void setPartitionKey(String partitionKey) {
this.partitionKey = partitionKey;
}
@DynamoDbSortKey
@DynamoDbAttribute(value = "sort_key")
public int getSortKey() {
return this.sortKey;
}
public void setSortKey(int sortKey) {
this.sortKey = sortKey;
}
public String getAttribute1() {
return this.attribute1;
}
public void setAttribute1(String attribute1) {
this.attribute1 = attribute1;
}
@DynamoDbEncryptionSignOnly
public String getAttribute2() {
return this.attribute2;
}
public void setAttribute2(String attribute2) {
this.attribute2 = attribute2;
}
@DynamoDbEncryptionDoNothing
public String getAttribute3() {
return this.attribute3;
}
@DynamoDbAttribute(value = ":attribute3")
public void setAttribute3(String attribute3) {
this.attribute3 = attribute3;
}
}
```
Use a classe de dados anotada para criar o `TableSchema`, conforme mostrado no snippet a seguir.
```
final TableSchema tableSchema = TableSchema.fromBean(SimpleClass.class);
```
### Definir as ações de atributos manualmente
Para especificar manualmente ações de atributos, crie um objeto `Map` em que pares de nome-valor representam os nomes de atributos e as ações especificadas.
Especifique `ENCRYPT_AND_SIGN` para criptografar e assinar um atributo. Especifique `SIGN_ONLY` para assinar, mas não criptografar um atributo. Especifique `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` para assinar um atributo e incluí-lo no contexto de criptografia. Não é possível criptografar um atributo sem também assiná-lo. Especifique `DO_NOTHING` para ignorar um atributo.
Os atributos de partição e classificação devem ser `SIGN_ONLY` ou`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se você definir qualquer atributo como`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**nota**
Para usar a ação `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` criptográfica, você deve usar a versão 3.3 ou posterior do SDK de criptografia de AWS banco de dados. Implante a nova versão para todos os leitores antes de [atualizar seu modelo de dados](ddb-update-data-model.md) para incluí-la`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be signed
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
// The sort attribute must be signed
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute3", CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT);
attributeActionsOnEncrypt.put(":attribute4", CryptoAction.DO_NOTHING);
```
## Configuração de criptografia no SDK AWS de criptografia de banco de dados para DynamoDB
Ao usar o AWS Database Encryption SDK, você deve definir explicitamente uma configuração de criptografia para sua tabela do DynamoDB. Os valores necessários em sua configuração de criptografia dependem se você definiu suas ações de atributo manualmente ou com uma classe de dados anotada.
O snippet a seguir define uma configuração de criptografia de tabela do DynamoDB usando o DynamoDB Enhanced Client, [https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html), e permite atributos não assinados definidos por um prefixo distinto.
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
// Optional: only required if you use beacons
.search(SearchConfig.builder()
.writeVersion(1) // MUST be 1
.versions(beaconVersions)
.build())
.build());
```
**Nome da tabela lógica**
Um nome de tabela lógica para sua tabela do DynamoDB.
O nome da tabela lógica é vinculado criptograficamente a todos os dados armazenados na tabela para simplificar as operações de restauração do DynamoDB. É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez. Você deve sempre especificar o mesmo nome de tabela lógica. Para que a descriptografia seja bem-sucedida, o nome da tabela lógica deve corresponder ao nome especificado na criptografia. Se o nome da tabela do DynamoDB mudar após a [restauração da tabela do DynamoDB a partir de um backup](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html), o nome da tabela lógica garantirá que a operação de descriptografia ainda reconheça a tabela.
**Atributos não assinados permitidos**
Os atributos marcados `DO_NOTHING` em suas ações de atributos.
Os atributos não assinados permitidos informam ao cliente quais atributos são excluídos das assinaturas. O cliente presume que todos os outros atributos estão incluídos na assinatura. Em seguida, ao descriptografar um registro, o cliente determina quais atributos ele precisa verificar e quais ignorar dos atributos não assinados permitidos que você especificou. Não é possível remover um atributo dos atributos não assinados permitidos.
É possível definir explicitamente os atributos não assinados permitidos criando uma matriz que lista todos os atributos `DO_NOTHING`. Também é possível especificar um prefixo distinto ao nomear os atributos `DO_NOTHING` e usar o prefixo para informar ao cliente quais atributos não estão assinados. É altamente recomendável especificar um prefixo distinto, pois isso simplifica o processo de adicionar um novo atributo `DO_NOTHING` no futuro. Para obter mais informações, consulte [Atualizar seu modelo de dados](ddb-update-data-model.md).
Se você não especificar um prefixo para todos os atributos `DO_NOTHING`, poderá configurar uma matriz `allowedUnsignedAttributes` que liste explicitamente todos os atributos que o cliente deve esperar que não estejam assinados ao encontrá-los na descriptografia. Você só deve definir explicitamente seus atributos não assinados permitidos se for absolutamente necessário.
**Configuração de pesquisa (opcional)**
O `SearchConfig` define a [versão do beacon](using-beacons.md#beacon-version).
O `SearchConfig` deve ser especificado para usar [criptografia pesquisável](searchable-encryption.md) ou [beacons assinados](configure.md#signed-beacons).
**Conjunto de algoritmos (opcional)**
O `algorithmSuiteId` define qual conjunto de algoritmos o SDK de criptografia de banco de dados da AWS usará.
A menos que você especifique explicitamente um conjunto alternativo de algoritmos, o SDK do AWS Database Encryption usa o conjunto de [algoritmos padrão](supported-algorithms.md#recommended-algorithms). O conjunto de algoritmos padrão usa o algoritmo AES-GCM com derivação de chaves, [assinaturas digitais](concepts.md#digital-sigs) e [comprometimento de chaves](concepts.md#key-commitment). Embora o conjunto de algoritmos padrão provavelmente seja adequado para a maioria dos aplicativos, é possível escolher um conjunto alternativo de algoritmos. Por exemplo, alguns modelos de confiança seriam satisfeitos com um pacote de algoritmos sem assinaturas digitais. Para obter informações sobre os conjuntos de algoritmos compatíveis com o SDK do AWS Database Encryption, consulte[Suítes de algoritmos compatíveis no SDK AWS de criptografia de banco de dados](supported-algorithms.md).
Para selecionar o [conjunto de algoritmos AES-GCM sem assinaturas digitais ECDSA](supported-algorithms.md#other-algorithms), inclua o seguinte trecho em sua configuração de criptografia de tabela.
```
.algorithmSuiteId(
DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384)
```
## Atualização de itens com o SDK AWS de criptografia de banco de dados
O SDK AWS de criptografia de banco de dados não oferece suporte a [ddb: UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) para itens que foram criptografados ou assinados. Para atualizar um item criptografado ou assinado, você deve usar [ddb: PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html). Se algum item existir em uma tabela específica com a mesma chave primária de um item existente na consulta `PutItem`, o novo item substituirá completamente o item já existente. Também é possível usar o [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) para limpar e substituir todos os atributos ao salvar após atualizar seus itens.
## Descriptografar conjuntos assinados
Nas versões 3.0.0 e 3.1.0 do SDK de criptografia de AWS banco de dados, se você definir um atributo de [tipo de conjunto](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes.SetTypes) como`SIGN_ONLY`, os valores do conjunto serão canonizados na ordem em que são fornecidos. O DynamoDB não preserva a ordem dos conjuntos. Como resultado, é possível que a validação da assinatura do item que contém o conjunto falhe. A validação da assinatura falha quando os valores do conjunto são retornados em uma ordem diferente da fornecida ao SDK do AWS Database Encryption, mesmo que os atributos do conjunto contenham os mesmos valores.
**nota**
As versões 3.1.1 e posteriores do SDK do AWS Database Encryption canonizam os valores de todos os atributos do tipo definido, de forma que os valores sejam lidos na mesma ordem em que foram gravados no DynamoDB.
Se houver falha na validação da assinatura, a operação de descriptografia falhará e retornará a seguinte mensagem de erro:
| |
| --- |
| software.amazon.cryptography.dbencryptionsdk.structuredencryption.model. StructuredEncryptionException: Nenhuma etiqueta de destinatário correspondeu. |
Se você receber a mensagem de erro acima e acreditar que o item que está tentando descriptografar inclui um conjunto que foi assinado usando a versão 3.0.0 ou 3.1.0, consulte o [DecryptWithPermute](https://github.com/aws/aws-database-encryption-sdk-dynamodb-java/tree/v3.1.1/DecryptWithPermute)diretório do repositório aws-database-encryption-sdk -dynamodb-java em para obter detalhes sobre GitHub como validar o conjunto com êxito.
# Exemplos de Java
****
| |
| --- |
| Nossa biblioteca de criptografia do lado do cliente foi renomeada para SDK de criptografia de AWS banco de dados. Este guia do desenvolvedor ainda fornece informações sobre o [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Os exemplos a seguir mostram como usar a biblioteca de criptografia do lado do cliente para o DynamoDB para proteger os itens da tabela no aplicativo. Você pode encontrar mais exemplos (e contribuir com os seus) nos [exemplos de Java no repositório](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) aws-database-encryption-sdk -dynamodb em. GitHub
Os exemplos a seguir demonstram como configurar a biblioteca Java de criptografia do lado do cliente para o DynamoDB em uma nova tabela não preenchida do Amazon DynamoDB. Se você quiser configurar suas tabelas existentes do Amazon DynamoDB para criptografia do lado do cliente, consulte [Adicionar versão 3.x a uma tabela existente](ddb-java-config-existing-table.md).
**Topics**
+ [Uso do cliente aprimorado do DynamoDB](#ddb-java-enhanced-client-example)
+ [Uso da API de nível inferior do DynamoDB](#ddb-java-lowlevel-API-example)
+ [Usando o nível inferior DynamoDbItemEncryptor](#ddb-java-itemencryptor)
## Uso do cliente aprimorado do DynamoDB
O exemplo a seguir mostra como usar o DynamoDB Enhanced Client e o `DynamoDbEncryptionInterceptor` com um [token de autenticação do AWS KMS](use-kms-keyring.md) para criptografar itens da tabela do DynamoDB como parte de suas chamadas de API do DynamoDB.
Você pode usar qualquer [chaveiro](keyrings.md) compatível com o DynamoDB Enhanced Client, mas recomendamos usar um dos AWS KMS chaveiros sempre que possível.
**nota**
O DynamoDB Enhanced Client [não oferece suporte à criptografia pesquisável](searchable-encryption.md). Use o `DynamoDbEncryptionInterceptor` com a API de nível inferior do DynamoDB para usar criptografia pesquisável.
**Veja a amostra de código completa**: [EnhancedPutGetExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/EnhancedPutGetExample.java)
**Etapa 1: criar o AWS KMS chaveiro**
O exemplo a seguir é usado `CreateAwsKmsMrkMultiKeyring` para criar um AWS KMS chaveiro com uma chave KMS de criptografia simétrica. O método `CreateAwsKmsMrkMultiKeyring` garante que o token de autenticação manipule corretamente chaves de região única e de várias regiões.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Etapa 2: criar um esquema de tabela a partir da classe de dados anotada**
O exemplo a seguir usa a classe de dados anotada para criar o `TableSchema`.
[Este exemplo pressupõe que as ações de classe e atributo de dados anotadas foram definidas usando o .java. SimpleClass](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) Para obter mais orientações sobre como anotar suas ações de atributos, consulte [Uso de uma classe de dados anotada](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
[O SDK AWS de criptografia de banco de dados não oferece suporte a anotações em atributos aninhados.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)
```
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
```
**Etapa 3: definir quais atributos são excluídos das assinaturas**
O exemplo a seguir pressupõe que todos os atributos `DO_NOTHING` compartilham o prefixo distinto "`:`" e usam o prefixo para definir os atributos não assinados permitidos. O cliente presume que qualquer nome de atributo com o prefixo "`:`" está excluído das assinaturas. Para obter mais informações, consulte [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Etapa 4: criar a configuração de criptografia**
O exemplo a seguir define um mapa `tableConfigs` que representa a configuração de criptografia dessa tabela do DynamoDB.
Este exemplo especifica o nome da tabela do DynamoDB como o [nome lógico da tabela.](ddb-java-using.md#logical-table-name) É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez. Para obter mais informações, consulte [Configuração de criptografia no SDK AWS de criptografia de banco de dados para DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Para usar [criptografia pesquisável](searchable-encryption.md) ou [beacons assinados](configure.md#signed-beacons), você também deve incluir [`SearchConfig`](ddb-java-using.md#ddb-search-config) na configuração de criptografia.
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
.build());
```
**Etapa 5: cria o `DynamoDbEncryptionInterceptor`**
O exemplo a seguir cria o `DynamoDbEncryptionInterceptor` usando `tableConfigs` da **Etapa 4**.
```
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
```
**Etapa 6: criar um novo cliente AWS SDK do DynamoDB**
**O exemplo a seguir cria um novo cliente AWS SDK do DynamoDB usando `interceptor` o da Etapa 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Etapa 7: criar o DynamoDB Enhanced Client e criar uma tabela**
O exemplo a seguir cria o DynamoDB Enhanced Client usando o cliente AWS SDK DynamoDB criado na **Etapa 6** e cria uma tabela usando a classe de dados anotada.
```
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
```
**Etapa 8: criptografar e salvar um item da tabela**
O exemplo a seguir coloca um item na tabela do DynamoDB usando o DynamoDB Enhanced Client. O item é criptografado e assinado no lado do cliente antes de ser enviado ao DynamoDB.
```
final SimpleClass item = new SimpleClass();
item.setPartitionKey("EnhancedPutGetExample");
item.setSortKey(0);
item.setAttribute1("encrypt and sign me!");
item.setAttribute2("sign me!");
item.setAttribute3("ignore me!");
table.putItem(item);
```
## Uso da API de nível inferior do DynamoDB
O exemplo a seguir mostra como usar a API de nível inferior do DynamoDB com um [token de autenticação do AWS KMS](use-kms-keyring.md) para criptografar e assinar automaticamente itens no lado do cliente com suas solicitações `PutItem` do DynamoDB.
Você pode usar qualquer [chaveiro](keyrings.md) compatível, mas recomendamos usar um dos AWS KMS chaveiros sempre que possível.
**Veja a amostra de código completa**: [BasicPutGetExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/BasicPutGetExample.java)
**Etapa 1: criar o AWS KMS chaveiro**
O exemplo a seguir é usado `CreateAwsKmsMrkMultiKeyring` para criar um AWS KMS chaveiro com uma chave KMS de criptografia simétrica. O método `CreateAwsKmsMrkMultiKeyring` garante que o token de autenticação manipule corretamente chaves de região única e de várias regiões.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Etapa 2: Configurar ações de atributos**
O exemplo a seguir define um mapa `attributeActionsOnEncrypt` que representa exemplos de [ações de atributos](concepts.md#crypt-actions) para um item da tabela.
O exemplo a seguir não define nenhum atributo como`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se você especificar algum `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**Etapa 3: definir quais atributos são excluídos das assinaturas**
O exemplo a seguir pressupõe que todos os atributos `DO_NOTHING` compartilham o prefixo distinto "`:`" e usam o prefixo para definir os atributos não assinados permitidos. O cliente presume que qualquer nome de atributo com o prefixo "`:`" está excluído das assinaturas. Para obter mais informações, consulte [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Etapa 4: definir a configuração de criptografia de tabelas do DynamoDB**
O exemplo a seguir define um mapa `tableConfigs` que representa a configuração de criptografia dessa tabela do DynamoDB.
Este exemplo especifica o nome da tabela do DynamoDB como o [nome lógico da tabela.](ddb-java-using.md#logical-table-name) É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez. Para obter mais informações, consulte [Configuração de criptografia no SDK AWS de criptografia de banco de dados para DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Para usar [criptografia pesquisável](searchable-encryption.md) ou [beacons assinados](configure.md#signed-beacons), você também deve incluir [`SearchConfig`](ddb-java-using.md#ddb-search-config) na configuração de criptografia.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.attributeActionsOnEncrypt(attributeActionsOnEncrypt)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.build();
tableConfigs.put(ddbTableName, config);
```
**Etapa 5: criar o perfil do `DynamoDbEncryptionInterceptor`**
O exemplo a seguir cria o `DynamoDbEncryptionInterceptor` usando `tableConfigs` da **Etapa 4**.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
**Etapa 6: criar um novo cliente AWS SDK do DynamoDB**
**O exemplo a seguir cria um novo cliente AWS SDK do DynamoDB usando `interceptor` o da Etapa 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Etapa 7: criptografar e assinar um item da tabela do DynamoDB**
O exemplo a seguir define um mapa `item` que representa um item da tabela de exemplo e coloca o item na tabela do DynamoDB. O item é criptografado e assinado no lado do cliente antes de ser enviado ao DynamoDB.
```
final HashMap item = new HashMap<>();
item.put("partition_key", AttributeValue.builder().s("BasicPutGetExample").build());
item.put("sort_key", AttributeValue.builder().n("0").build());
item.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
item.put("attribute2", AttributeValue.builder().s("sign me!").build());
item.put(":attribute3", AttributeValue.builder().s("ignore me!").build());
final PutItemRequest putRequest = PutItemRequest.builder()
.tableName(ddbTableName)
.item(item)
.build();
final PutItemResponse putResponse = ddb.putItem(putRequest);
```
## Usando o nível inferior DynamoDbItemEncryptor
O exemplo a seguir mostra como usar o nível inferior de `DynamoDbItemEncryptor` com um [token de autenticação do AWS KMS](use-kms-keyring.md) para criptografar e assinar diretamente os itens da tabela. O `DynamoDbItemEncryptor` não coloca o item na tabela do DynamoDB.
Você pode usar qualquer [chaveiro](keyrings.md) compatível com o DynamoDB Enhanced Client, mas recomendamos usar um dos AWS KMS chaveiros sempre que possível.
**nota**
O nível inferior do `DynamoDbItemEncryptor` não oferece suporte à [criptografia pesquisável](searchable-encryption.md). Use o `DynamoDbEncryptionInterceptor` com a API de nível inferior do DynamoDB para usar criptografia pesquisável.
**Veja a amostra de código completa**: [ItemEncryptDecryptExample.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/itemencryptor/ItemEncryptDecryptExample.java)
**Etapa 1: criar o AWS KMS chaveiro**
O exemplo a seguir é usado `CreateAwsKmsMrkMultiKeyring` para criar um AWS KMS chaveiro com uma chave KMS de criptografia simétrica. O método `CreateAwsKmsMrkMultiKeyring` garante que o token de autenticação manipule corretamente chaves de região única e de várias regiões.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Etapa 2: Configurar ações de atributos**
O exemplo a seguir define um mapa `attributeActionsOnEncrypt` que representa exemplos de [ações de atributos](concepts.md#crypt-actions) para um item da tabela.
O exemplo a seguir não define nenhum atributo como`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se você especificar algum `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**Etapa 3: definir quais atributos são excluídos das assinaturas**
O exemplo a seguir pressupõe que todos os atributos `DO_NOTHING` compartilham o prefixo distinto "`:`" e usam o prefixo para definir os atributos não assinados permitidos. O cliente presume que qualquer nome de atributo com o prefixo "`:`" está excluído das assinaturas. Para obter mais informações, consulte [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Etapa 4: definir a configuração de `DynamoDbItemEncryptor`**
O exemplo a seguir define a configuração para `DynamoDbItemEncryptor`.
Este exemplo especifica o nome da tabela do DynamoDB como o [nome lógico da tabela.](ddb-java-using.md#logical-table-name) É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez. Para obter mais informações, consulte [Configuração de criptografia no SDK AWS de criptografia de banco de dados para DynamoDB](ddb-java-using.md#ddb-config-encrypt).
```
final DynamoDbItemEncryptorConfig config = DynamoDbItemEncryptorConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.attributeActionsOnEncrypt(attributeActionsOnEncrypt)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.build();
```
**Etapa 5: criar o perfil do `DynamoDbItemEncryptor`**
O exemplo a seguir cria um novo `DynamoDbItemEncryptor` usando `config` da **Etapa 4**.
```
final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor.builder()
.DynamoDbItemEncryptorConfig(config)
.build();
```
**Etapa 6: criptografar e assinar diretamente um item da tabela**
O exemplo a seguir criptografa e assina diretamente um item usando o `DynamoDbItemEncryptor`. O `DynamoDbItemEncryptor` não coloca o item na tabela do DynamoDB.
```
final Map originalItem = new HashMap<>();
originalItem.put("partition_key", AttributeValue.builder().s("ItemEncryptDecryptExample").build());
originalItem.put("sort_key", AttributeValue.builder().n("0").build());
originalItem.put("attribute1", AttributeValue.builder().s("encrypt and sign me!").build());
originalItem.put("attribute2", AttributeValue.builder().s("sign me!").build());
originalItem.put(":attribute3", AttributeValue.builder().s("ignore me!").build());
final Map encryptedItem = itemEncryptor.EncryptItem(
EncryptItemInput.builder()
.plaintextItem(originalItem)
.build()
).encryptedItem();
```
# Configurar uma tabela existente do DynamoDB para usar o SDK de criptografia de banco de dados para AWS o DynamoDB
****
| |
| --- |
| Nossa biblioteca de criptografia do lado do cliente foi renomeada para SDK de criptografia de AWS banco de dados. Este guia do desenvolvedor ainda fornece informações sobre o [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Com a versão 3.*x* da biblioteca Java de criptografia do lado do cliente para DynamoDB, é possível configurar as tabelas existentes do Amazon DynamoDB para a criptografia do lado do cliente. Este tópico fornece orientação sobre as três etapas que você deve seguir para adicionar a versão 3.*x* para uma tabela existente e preenchida do DynamoDB.
**Pré-requisitos**
A versão 3.*x* da biblioteca Java de criptografia do lado do cliente para o DynamoDB requer o [DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) fornecido em AWS SDK for Java 2.x . Se você ainda usa o [Dynamo DBMapper](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html), deve migrar AWS SDK for Java 2.x para o DynamoDB Enhanced Client.
Siga as instruções para [migrar da versão 1.x para a 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) do AWS SDK para Java.
Em seguida, siga as instruções para [Começar a usar a API do DynamoDB Enhanced Client.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started.html)
Antes de configurar sua tabela para usar a biblioteca Java de criptografia do lado do cliente para o DynamoDB, você precisa gerar `TableSchema` [usando uma classe de dados anotada](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) e [criar um cliente aprimorado](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient).
## Etapa 1: preparar para ler e gravar itens criptografados
Conclua as etapas a seguir para preparar seu cliente SDK AWS de criptografia de banco de dados para ler e gravar itens criptografados. Depois de implantar as alterações a seguir, seu cliente continuará lendo e gravando itens de texto simples. Ele não criptografará nem assinará nenhum novo item gravado na tabela, mas poderá descriptografar itens criptografados assim que eles aparecerem. Essas mudanças preparam o cliente para começar a [criptografar novos itens](#ddb-java-add-step2). As alterações a seguir devem ser implantadas em cada leitor antes de prosseguir para a próxima etapa.
**1. Definir suas [ações de atributos](concepts.md#crypt-actions)**
Atualize sua classe de dados anotada para incluir ações de atributos que definam quais valores de atributos serão criptografados e assinados, quais serão somente assinados e quais serão ignorados.
Consulte o [SimpleClassarquivo.java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass.java) no repositório aws-database-encryption-sdk -dynamodb em GitHub para obter mais orientações sobre as anotações do DynamoDB Enhanced Client.
Por padrão, os atributos da chave primária são assinados, mas não criptografados (`SIGN_ONLY`), e todos os outros atributos são criptografados e assinados (`ENCRYPT_AND_SIGN`). Para especificar exceções, use as anotações de criptografia definidas na biblioteca de criptografia do lado do cliente para Java do DynamoDB. Por exemplo, se você quiser que um atributo específico seja assinado, use apenas a anotação `@DynamoDbEncryptionSignOnly`. Se você quiser que um atributo específico seja assinado e incluído no contexto de criptografia, use a `@DynamoDbEncryptionSignAndIncludeInEncryptionContext` anotação. Se desejar que um atributo específico não seja assinado nem criptografado (`DO_NOTHING`), use a anotação `@DynamoDbEncryptionDoNothing`.
Se você especificar algum `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. [Para ver um exemplo que mostra as anotações usadas para definir`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, consulte SimpleClass 4.java.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java)
Por obter exemplos de anotações, consulte [Uso de uma classe de dados anotada](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
**2. Definir quais atributos são excluídos das assinaturas**
O exemplo a seguir pressupõe que todos os atributos `DO_NOTHING` compartilham o prefixo distinto "`:`" e usam o prefixo para definir os atributos não assinados permitidos. O cliente presumirá que qualquer nome de atributo com o prefixo "`:`" está excluído das assinaturas. Para obter mais informações, consulte [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**3. Criar um [token de autenticação](keyrings.md)**
O exemplo a seguir cria um [token de autenticação do AWS KMS](use-kms-keyring.md). O AWS KMS chaveiro usa criptografia simétrica ou RSA assimétrica AWS KMS keys para gerar, criptografar e descriptografar chaves de dados.
Este exemplo usa `CreateMrkMultiKeyring` para criar um token de autenticação do AWS KMS com uma chave do KMS de criptografia simétrica. O método `CreateAwsKmsMrkMultiKeyring` garante que o token de autenticação manipule corretamente chaves de região única e de várias regiões.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**4. Definir a configuração de criptografia de tabelas do DynamoDB **
O exemplo a seguir define um mapa `tableConfigs` que representa a configuração de criptografia dessa tabela do DynamoDB.
Este exemplo especifica o nome da tabela do DynamoDB como o [nome lógico da tabela.](ddb-java-using.md#logical-table-name) É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez. Para obter mais informações, consulte [Configuração de criptografia no SDK AWS de criptografia de banco de dados para DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Você deve especificar `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` como substituição de texto simples. Essa política continua lendo e gravando itens de texto simples, lendo itens criptografados e preparando o cliente para gravar itens criptografados.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.plaintextOverride(PlaintextOverride.FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
**5. Criar a `DynamoDbEncryptionInterceptor`**
O exemplo a seguir cria o `DynamoDbEncryptionInterceptor` usando `tableConfigs` da **Etapa 3**.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
## Etapa 2: gravar itens criptografados e assinados
Atualize a política de texto simples em sua configuração `DynamoDbEncryptionInterceptor` para permitir que o cliente grave itens criptografados e assinados. Depois de implantar a seguinte alteração, o cliente criptografará e assinará novos itens com base nas ações de atributos que você configurou na **Etapa 1**. O cliente poderá ler itens de texto simples e itens criptografados e assinados.
Antes de prosseguir para a [Etapa 3](#ddb-java-add-step3), você deve criptografar e assinar todos os itens de texto sem formatação existentes em sua tabela. Não há uma única métrica ou consulta que você possa executar para criptografar rapidamente seus itens de texto sem formatação existentes. Use o processo que faz mais sentido para o seu sistema. Por exemplo, é possível usar um processo assíncrono que varre lentamente a tabela e reescreve os itens usando as ações de atributos e a configuração de criptografia que você definiu. Para identificar os itens de texto simples em sua tabela, recomendamos escanear todos os itens que não contêm os `aws_dbe_foot` atributos `aws_dbe_head` e que o SDK de criptografia de AWS banco de dados adiciona aos itens quando eles são criptografados e assinados.
O exemplo a seguir atualiza a configuração de criptografia de tabela da **Etapa 1**. Você deve atualizar a substituição de texto simples com `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT`. Essa política continua lendo itens de texto simples, mas também lê e grava itens criptografados. Crie um novo `DynamoDbEncryptionInterceptor` usando o atualizado`tableConfigs`.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.plaintextOverride(PlaintextOverride.FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
## Etapa 3: somente ler itens criptografados e assinados
Depois de criptografar e assinar todos os seus itens, atualize a substituição de texto simples na configuração `DynamoDbEncryptionInterceptor` para permitir que o cliente somente leia e grave itens criptografados e assinados. Depois de implantar a seguinte alteração, o cliente criptografará e assinará novos itens com base nas ações de atributos que você configurou na **Etapa 1**. O cliente só poderá ler itens criptografados e assinados.
O exemplo a seguir atualiza a configuração de criptografia de tabela da **Etapa 2**. É possível atualizar a substituição de texto sem formatação com `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` ou remover a política de texto sem formatação da sua configuração. Por padrão, o cliente só lê e grava itens criptografados e assinados. Crie um novo `DynamoDbEncryptionInterceptor` usando o atualizado`tableConfigs`.
```
final Map tableConfigs = new HashMap<>();
final DynamoDbTableEncryptionConfig config = DynamoDbTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.partitionKeyName("partition_key")
.sortKeyName("sort_key")
.schemaOnEncrypt(tableSchema)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
// Optional: you can also remove the plaintext policy from your configuration
.plaintextOverride(PlaintextOverride.FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT)
.build();
tableConfigs.put(ddbTableName, config);
```
# Migrar para a versão 3.x da biblioteca Java de criptografia do lado do cliente para o DynamoDB
****
| |
| --- |
| Nossa biblioteca de criptografia do lado do cliente foi renomeada para SDK de criptografia de AWS banco de dados. Este guia do desenvolvedor ainda fornece informações sobre o [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
A Versão 3.*x* da biblioteca Java de criptografia do lado do cliente para DynamoDB é uma grande reescrita da base de código 2.*x*. Ela inclui muitas atualizações, como um novo formato de dados estruturados, suporte aprimorado para multilocação, alterações de esquema contínuas e suporte à criptografia pesquisável. Este tópico fornece orientação sobre como migrar seu código para a versão 3.*x*.
## Migrar da versão 1.x para a versão 2.x
Migre para a versão 2.*x* antes de migrar para a versão 3.*x.*. A versão 2.*x* mudou o símbolo do provedor mais recente de `MostRecentProvider` para `CachingMostRecentProvider`. Se você usa atualmente a versão 1.*x* da biblioteca Java de criptografia do lado do cliente para o DynamoDB com o símbolo `MostRecentProvider`, você deverá atualizar o nome do símbolo em seu código para `CachingMostRecentProvider`. Para obter mais informações, consulte [Atualizações do provedor mais recente](most-recent-provider.md#mrp-versions).
## Migrar da versão 2.x para a versão 3.x
Os procedimentos a seguir descrevem como migrar seu código da versão 2.*x* para a versão 3.*x* da biblioteca Java de criptografia do lado do cliente para o DynamoDB.
### Etapa 1. Preparar para ler itens no novo formato
Conclua as etapas a seguir para preparar seu cliente SDK do AWS Database Encryption para ler itens no novo formato. Depois de implantar as alterações a seguir, seu cliente continuará se comportando da mesma maneira que na versão 2.*x*. Seu cliente continuará lendo e gravando itens no formato da versão 2.*x*, mas essas alterações preparam o cliente para [ler itens no novo formato](#ddb-java-migrate-step2).
**Atualize seu AWS SDK para Java para a versão 2.x**
A versão 3.*x* da biblioteca Java de criptografia do lado do cliente para o DynamoDB requer o [DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html). O DynamoDB Enhanced Client substitui o [DBMapperDynamo usado nas versões anteriores](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html). Para usar o cliente aprimorado, você deve usar o AWS SDK for Java 2.x.
Siga as instruções para [migrar da versão 1.x para a 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) do AWS SDK para Java.
Para obter mais informações sobre quais AWS SDK for Java 2.x módulos são necessários, consulte[Pré-requisitos](ddb-java.md#ddb-java-prerequisites).
**Configurar seu cliente para ler itens criptografados por versões legadas**
Os procedimentos a seguir fornecem uma visão geral das etapas demonstradas no exemplo de código abaixo.
1. Crie um [token de autenticação](keyrings.md).
Os tokens de autenticação e os [gerenciadores de materiais criptográficos](concepts.md#crypt-materials-manager) substituem os fornecedores de materiais criptográficos usados nas versões anteriores da biblioteca Java de criptografia do lado do cliente para o DynamoDB.
**Importante**
As chaves de empacotamento que você especifica ao criar um token de autenticação devem ser as mesmas que você usou com seu provedor de materiais criptográficos na versão 2.*x*.
1. Crie um esquema de tabela sobre sua classe anotada.
Essa etapa define as ações de atributos que serão usadas quando você começar a gravar itens no novo formato.
Para obter orientação sobre como usar o novo DynamoDB Enhanced Client, consulte [Gerar um `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) no *Guia do desenvolvedor do AWS SDK para Java *.
O exemplo a seguir pressupõe que você atualizou sua classe anotada da versão 2.*x* usando as novas anotações de ações de atributos. Para obter mais orientações sobre como anotar suas ações de atributos, consulte [Uso de uma classe de dados anotada](ddb-java-using.md#ddb-attribute-actions-annotated-data-class).
**nota**
Se você especificar algum `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. [Para ver um exemplo que mostra as anotações usadas para definir`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, consulte SimpleClass 4.java.](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/enhanced/SimpleClass4.java)
1. Defina quais [atributos serão excluídos das assinaturas](ddb-java-using.md#allowed-unauth).
1. Configure um mapa explícito das ações de atributos configuradas em sua classe modelada na versão 2.x.
Essa etapa define as ações de atributos usadas para gravar itens no formato antigo.
1. Configure o `DynamoDBEncryptor` que você usou na versão 2.*x* da biblioteca Java de criptografia do lado do cliente para o DynamoDB.
1. Configure o comportamento legado.
1. Crie um `DynamoDbEncryptionInterceptor`.
1. Crie um novo cliente AWS SDK do DynamoDB.
1. Crie o `DynamoDBEnhancedClient` e crie uma tabela com sua classe modelada.
Para obter mais informações sobre o DynamoDB Enhanced Client, consulte [criar um cliente aprimorado](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient).
```
public class MigrationExampleStep1 {
public static void MigrationStep1(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Create a Keyring.
// This example creates an AWS KMS Keyring that specifies the
// same kmsKeyId previously used in the version 2.x configuration.
// It uses the 'CreateMrkMultiKeyring' method to create the
// keyring, so that the keyring can correctly handle both single
// region and Multi-Region KMS Keys.
// Note that this example uses the AWS SDK for Java v2 KMS client.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
// 2. Create a Table Schema over your annotated class.
// For guidance on using the new attribute actions
// annotations, see SimpleClass.java in the
// aws-database-encryption-sdk-dynamodb GitHub repository.
// All primary key attributes must be signed but not encrypted
// and by default all non-primary key attributes
// are encrypted and signed (ENCRYPT_AND_SIGN).
// If you want a particular non-primary key attribute to be signed but
// not encrypted, use the 'DynamoDbEncryptionSignOnly' annotation.
// If you want a particular attribute to be neither signed nor encrypted
// (DO_NOTHING), use the 'DynamoDbEncryptionDoNothing' annotation.
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
// 3. Define which attributes the client should expect to be excluded
// from the signature when reading items.
// This value represents all unsigned attributes across the entire
// dataset.
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
// 4. Configure an explicit map of the attribute actions configured
// in your version 2.x modeled class.
final Map legacyActions = new HashMap<>();
legacyActions.put("partition_key", CryptoAction.SIGN_ONLY);
legacyActions.put("sort_key", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
legacyActions.put("attribute2", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute3", CryptoAction.DO_NOTHING);
// 5. Configure the DynamoDBEncryptor that you used in version 2.x.
final AWSKMS kmsClient = AWSKMSClientBuilder.defaultClient();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kmsClient, kmsKeyId);
final DynamoDBEncryptor oldEncryptor = DynamoDBEncryptor.getInstance(cmp);
// 6. Configure the legacy behavior.
// Input the DynamoDBEncryptor and attribute actions created in
// the previous steps. For Legacy Policy, use
// 'FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT'. This policy continues to read
// and write items using the old format, but will be able to read
// items written in the new format as soon as they appear.
final LegacyOverride legacyOverride = LegacyOverride
.builder()
.encryptor(oldEncryptor)
.policy(LegacyPolicy.FORCE_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT)
.attributeActionsOnEncrypt(legacyActions)
.build();
// 7. Create a DynamoDbEncryptionInterceptor with the above configuration.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.legacyOverride(legacyOverride)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 8. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 7.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 9. Create the DynamoDbEnhancedClient using the AWS SDK DynamoDb client
// created in Step 8, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
### Etapa 2. Gravar itens no novo formato
Depois de implantar as alterações da Etapa 1 em todos os leitores, conclua as etapas a seguir para configurar seu cliente SDK do AWS Database Encryption para gravar itens no novo formato. Depois de implantar as seguintes alterações, seu cliente continuará lendo itens no formato antigo e começará a gravar e ler itens no novo formato.
Os procedimentos a seguir fornecem uma visão geral das etapas demonstradas no exemplo de código abaixo.
1. Continue configurando seu token de autenticação, esquema de tabela, ações de atributos herdados e `allowedUnsignedAttributes` e `DynamoDBEncryptor` como você fez na [**Etapa 1**](#ddb-java-migrate-step1).
1. Atualize seu comportamento legado para gravar somente novos itens usando o novo formato.
1. Criar uma `DynamoDbEncryptionInterceptor `
1. Crie um novo cliente AWS SDK do DynamoDB.
1. Crie o `DynamoDBEnhancedClient` e crie uma tabela com sua classe modelada.
Para obter mais informações sobre o DynamoDB Enhanced Client, consulte [criar um cliente aprimorado](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient).
```
public class MigrationExampleStep2 {
public static void MigrationStep2(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Continue to configure your keyring, table schema, legacy
// attribute actions, allowedUnsignedAttributes, and
// DynamoDBEncryptor as you did in Step 1.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
final Map legacyActions = new HashMap<>();
legacyActions.put("partition_key", CryptoAction.SIGN_ONLY);
legacyActions.put("sort_key", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
legacyActions.put("attribute2", CryptoAction.SIGN_ONLY);
legacyActions.put("attribute3", CryptoAction.DO_NOTHING);
final AWSKMS kmsClient = AWSKMSClientBuilder.defaultClient();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kmsClient, kmsKeyId);
final DynamoDBEncryptor oldEncryptor = DynamoDBEncryptor.getInstance(cmp);
// 2. Update your legacy behavior to only write new items using the new
// format.
// For Legacy Policy, use 'FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT'. This policy
// continues to read items in both formats, but will only write items
// using the new format.
final LegacyOverride legacyOverride = LegacyOverride
.builder()
.encryptor(oldEncryptor)
.policy(LegacyPolicy.FORBID_LEGACY_ENCRYPT_ALLOW_LEGACY_DECRYPT)
.attributeActionsOnEncrypt(legacyActions)
.build();
// 3. Create a DynamoDbEncryptionInterceptor with the above configuration.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.legacyOverride(legacyOverride)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 4. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 3.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 5. Create the DynamoDbEnhancedClient using the AWS SDK DynamoDb Client created
// in Step 4, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
Depois de implantar as alterações da Etapa 2, você deve criptografar novamente todos os itens antigos em sua tabela com o novo formato antes de continuar na [Etapa 3](#ddb-java-migrate-step3). Não há uma única métrica ou consulta que você possa executar para criptografar rapidamente seus itens existentes. Use o processo que faz mais sentido para o seu sistema. Por exemplo, é possível usar um processo assíncrono que varre lentamente a tabela e reescreve os itens usando as ações do novo atributo e a configuração de criptografia que você definiu.
### Etapa 3. Ler e gravar somente itens no novo formato
Depois de criptografar novamente todos os itens da tabela com o novo formato, é possível remover o comportamento legado da configuração. Conclua as etapas a seguir para configurar o cliente para ler e gravar somente itens no novo formato.
Os procedimentos a seguir fornecem uma visão geral das etapas demonstradas no exemplo de código abaixo.
1. Continue configurando seu token de autenticação, esquema de tabela e `allowedUnsignedAttributes` como você fez na [**Etapa 1**](#ddb-java-migrate-step1). Remova as ações do atributo legado e `DynamoDBEncryptor` da sua configuração.
1. Crie um `DynamoDbEncryptionInterceptor`.
1. Crie um novo cliente AWS SDK do DynamoDB.
1. Crie o `DynamoDBEnhancedClient` e crie uma tabela com sua classe modelada.
Para obter mais informações sobre o DynamoDB Enhanced Client, consulte [criar um cliente aprimorado](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started-dynamodbTable.html#ddb-en-client-getting-started-dynamodbTable-eclient).
```
public class MigrationExampleStep3 {
public static void MigrationStep3(String kmsKeyId, String ddbTableName, int sortReadValue) {
// 1. Continue to configure your keyring, table schema,
// and allowedUnsignedAttributes as you did in Step 1.
// Do not include the configurations for the DynamoDBEncryptor or
// the legacy attribute actions.
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
final List allowedUnsignedAttributes = Arrays.asList("attribute3");
// 3. Create a DynamoDbEncryptionInterceptor with the above configuration.
// Do not configure any legacy behavior.
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributes(allowedUnsignedAttributes)
.schemaOnEncrypt(tableSchema)
.build());
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
// 4. Create a new AWS SDK DynamoDb client using the
// interceptor from Step 3.
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
// 5. Create the DynamoDbEnhancedClient using the AWS SDK Client
// created in Step 4, and create a table with your modeled class.
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
}
}
```
# .NET
Este tópico explica como instalar e usar a versão 3. *x* da biblioteca de criptografia do lado do cliente.NET para o DynamoDB. Para obter detalhes sobre a programação com o SDK AWS de criptografia de banco de dados para DynamoDB, consulte os exemplos [do.NET no](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/) repositório -dynamodb em aws-database-encryption-sdk. GitHub
A biblioteca de criptografia do lado do cliente.NET para o DynamoDB é para desenvolvedores que estão escrevendo aplicativos em C\$1 e em outras linguagens de programação.NET. É compatível com Windows, macOS e Linux.
Todas as implementações da [linguagem de programação](ddb-programming-languages.md) do SDK de criptografia de AWS banco de dados para DynamoDB são interoperáveis. No entanto, o SDK para .NET não suporta valores vazios para tipos de dados de lista ou mapa. Isso significa que, se você usar a biblioteca de criptografia Java do lado do cliente para o DynamoDB para escrever um item que contém valores vazios para um tipo de dados de lista ou mapa, não poderá descriptografar e ler esse item usando a biblioteca de criptografia do lado do cliente.NET para o DynamoDB.
**Topics**
+ [Instalar](#ddb-net-install)
+ [Depuração](#ddb-net-debugging)
+ [Usando o cliente.NET](ddb-net-using.md)
+ [Exemplos do.NET](ddb-net-examples.md)
+ [Adicionar versão 3.x a uma tabela existente](ddb-net-config-existing-table.md)
## Instalação da biblioteca de criptografia do lado do cliente.NET para o DynamoDB
[A biblioteca de criptografia do lado do cliente.NET para o DynamoDB está disponível como AWS.Cryptography. DbEncryptionSDK. DynamoDb](https://www.nuget.org/packages/AWS.Cryptography.DbEncryptionSDK.DynamoDb/)pacote em NuGet. Para obter detalhes sobre como instalar e criar a biblioteca, consulte o [arquivo.NET README.md](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/DynamoDbEncryption/runtimes/net/README.md) no repositório -dynamodb. aws-database-encryption-sdk A biblioteca de criptografia do lado do cliente.NET para o DynamoDB exige as chaves SDK para .NET mesmo que você não esteja usando (). AWS Key Management Service AWS KMS O SDK para .NET é instalado com o NuGet pacote.
Versão 3. *x* da biblioteca de criptografia do lado do cliente.NET para DynamoDB é compatível com o.NET 6.0 e .NET Framework net48 e versões posteriores.
## Depuração com o.NET
A biblioteca de criptografia do lado do cliente.NET para o DynamoDB não gera nenhum registro. As exceções na biblioteca de criptografia do lado do cliente.NET para o DynamoDB geram uma mensagem de exceção, mas não rastreiam a pilha.
Para ajudar na depuração, certifique-se de habilitar o login no SDK para .NET. Os registros e as mensagens de erro do SDK para .NET podem ajudá-lo a distinguir os erros decorrentes do e os da biblioteca de criptografia SDK para .NET do lado do cliente.NET para o DynamoDB. Para obter ajuda com o SDK para .NET registro, consulte [AWSLogging](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-config-other.html#config-setting-awslogging)o *Guia do AWS SDK para .NET desenvolvedor*. (Para ver o tópico, expanda a seção **Abrir para ver o conteúdo do .NET Framework**.)
# Usando a biblioteca de criptografia do lado do cliente.NET para o DynamoDB
Este tópico explica algumas das funções e classes auxiliares na versão 3. *x* da biblioteca de criptografia do lado do cliente.NET para o DynamoDB.
Para obter detalhes sobre a programação com a biblioteca de criptografia do lado do cliente.NET para o DynamoDB, consulte os [exemplos do.NET](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/) no repositório -dynamodb em. aws-database-encryption-sdk GitHub
**Topics**
+ [Criptografadores de itens](#ddb-net-item-encryptors)
+ [Ações de atributos](#ddb-net-attribute-actions)
+ [Configuração de criptografia](#ddb-net-config-encrypt)
+ [Atualização de itens](#ddb-net-update-items)
## Criptografadores de itens
Basicamente, o SDK AWS de criptografia de banco de dados para DynamoDB é um criptografador de itens. Você pode usar a versão 3. *x* da biblioteca de criptografia do lado do cliente.NET para que o DynamoDB criptografe, assine, verifique e descriptografe os itens da tabela do DynamoDB das seguintes maneiras.
**O SDK de criptografia de AWS banco de dados de baixo nível para a API do DynamoDB**
Você pode usar sua [configuração de criptografia de tabela](#ddb-net-config-encrypt) para criar um cliente do DynamoDB que criptografe e assine automaticamente itens do lado do cliente com suas solicitações do DynamoDB. `PutItem` Você pode usar esse cliente diretamente ou criar um modelo de [documento ou modelo](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/dynamodb-intro.html#dynamodb-intro-apis-document) de [persistência de objetos](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/dynamodb-intro.html#dynamodb-intro-apis-object-persistence).
[Você deve usar o SDK de criptografia de AWS banco de dados de baixo nível para a API do DynamoDB para usar a criptografia pesquisável.](searchable-encryption.md)
**O `DynamoDbItemEncryptor` de nível inferior**
O `DynamoDbItemEncryptor` de nível inferior criptografa, assina ou descriptografa e verifica diretamente os itens da tabela sem chamar o DynamoDB. Ele não faz solicitações `PutItem` ou `GetItem` para o DynamoDB. Por exemplo, é possível usar o `DynamoDbItemEncryptor` de nível inferior para descriptografar e verificar diretamente um item do DynamoDB que você já recuperou. Se você usar o nível inferior`DynamoDbItemEncryptor`, recomendamos usar o [modelo de programação de baixo nível SDK para .NET fornecido](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/dynamodb-intro.html#dynamodb-intro-apis-low-level) para comunicação com o DynamoDB.
O nível inferior do `DynamoDbItemEncryptor` não oferece suporte à [criptografia pesquisável](searchable-encryption.md).
## Ações de atributos no SDK AWS de criptografia de banco de dados para DynamoDB
[As ações](concepts.md#crypt-actions) de atributo determinam quais valores de atributos são criptografados e assinados, quais são somente assinados, quais são assinados e incluídos no contexto de criptografia e quais são ignorados.
Para especificar ações de atributos com o cliente.NET, defina manualmente ações de atributos usando um modelo de objeto. Especifique suas ações de atributo criando um `Dictionary` objeto no qual os pares nome-valor representam os nomes dos atributos e as ações especificadas.
Especifique `ENCRYPT_AND_SIGN` para criptografar e assinar um atributo. Especifique `SIGN_ONLY` para assinar, mas não criptografar um atributo. Especifique `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` para assinar um atributo e incluí-lo no contexto de criptografia. Não é possível criptografar um atributo sem também assiná-lo. Especifique `DO_NOTHING` para ignorar um atributo.
Os atributos de partição e classificação devem ser `SIGN_ONLY` ou`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se você definir qualquer atributo como`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**nota**
Depois de definir suas ações de atributo, você deverá definir quais atributos serão excluídos das assinaturas. Para facilitar a adição de novos atributos não assinados no futuro, recomendamos escolher um prefixo distinto (como "`:`") para identificar os atributos não assinados. Inclua esse prefixo no nome do atributo para todos os atributos marcados como `DO_NOTHING` ao definir o esquema e as ações de atributos do DynamoDB.
O modelo de objeto a seguir demonstra como especificar`ENCRYPT_AND_SIGN`, `SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, e `DO_NOTHING` atribuir ações com o cliente.NET. Este exemplo usa o prefixo "`:`" para identificar `DO_NOTHING` atributos.
**nota**
Para usar a ação `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` criptográfica, você deve usar a versão 3.3 ou posterior do SDK de criptografia de AWS banco de dados. Implante a nova versão para todos os leitores antes de [atualizar seu modelo de dados](ddb-update-data-model.md) para incluí-la`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
var attributeActionsOnEncrypt = new Dictionary
{
["partition_key"] = CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT, // The partition attribute must be signed
["sort_key"] = CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT, // The sort attribute must be signed
["attribute1"] = CryptoAction.ENCRYPT_AND_SIGN,
["attribute2"] = CryptoAction.SIGN_ONLY,
["attribute3"] = CryptoAction.SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT,
[":attribute4"] = CryptoAction.DO_NOTHING
};
```
## Configuração de criptografia no SDK AWS de criptografia de banco de dados para DynamoDB
Ao usar o AWS Database Encryption SDK, você deve definir explicitamente uma configuração de criptografia para sua tabela do DynamoDB. Os valores necessários em sua configuração de criptografia dependem se você definiu suas ações de atributo manualmente ou com uma classe de dados anotada.
O trecho a seguir define uma configuração de criptografia de tabela do DynamoDB usando o SDK de criptografia de AWS banco de dados de baixo nível para a API do DynamoDB e atributos não assinados permitidos definidos por um prefixo distinto.
```
Dictionary tableConfigs =
new Dictionary();
DynamoDbTableEncryptionConfig config = new DynamoDbTableEncryptionConfig
{
LogicalTableName = ddbTableName,
PartitionKeyName = "partition_key",
SortKeyName = "sort_key",
AttributeActionsOnEncrypt = attributeActionsOnEncrypt,
Keyring = kmsKeyring,
AllowedUnsignedAttributePrefix = unsignAttrPrefix,
// Optional: SearchConfig only required if you use beacons
Search = new SearchConfig
{
WriteVersion = 1, // MUST be 1
Versions = beaconVersions
}
};
tableConfigs.Add(ddbTableName, config);
```
**Nome da tabela lógica**
Um nome de tabela lógica para sua tabela do DynamoDB.
O nome da tabela lógica é vinculado criptograficamente a todos os dados armazenados na tabela para simplificar as operações de restauração do DynamoDB. É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez. Você deve sempre especificar o mesmo nome de tabela lógica. Para que a descriptografia seja bem-sucedida, o nome da tabela lógica deve corresponder ao nome especificado na criptografia. Se o nome da tabela do DynamoDB mudar após a [restauração da tabela do DynamoDB a partir de um backup](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html), o nome da tabela lógica garantirá que a operação de descriptografia ainda reconheça a tabela.
**Atributos não assinados permitidos**
Os atributos marcados `DO_NOTHING` em suas ações de atributos.
Os atributos não assinados permitidos informam ao cliente quais atributos são excluídos das assinaturas. O cliente presume que todos os outros atributos estão incluídos na assinatura. Em seguida, ao descriptografar um registro, o cliente determina quais atributos ele precisa verificar e quais ignorar dos atributos não assinados permitidos que você especificou. Não é possível remover um atributo dos atributos não assinados permitidos.
É possível definir explicitamente os atributos não assinados permitidos criando uma matriz que lista todos os atributos `DO_NOTHING`. Também é possível especificar um prefixo distinto ao nomear os atributos `DO_NOTHING` e usar o prefixo para informar ao cliente quais atributos não estão assinados. É altamente recomendável especificar um prefixo distinto, pois isso simplifica o processo de adicionar um novo atributo `DO_NOTHING` no futuro. Para obter mais informações, consulte [Atualizar seu modelo de dados](ddb-update-data-model.md).
Se você não especificar um prefixo para todos os atributos `DO_NOTHING`, poderá configurar uma matriz `allowedUnsignedAttributes` que liste explicitamente todos os atributos que o cliente deve esperar que não estejam assinados ao encontrá-los na descriptografia. Você só deve definir explicitamente seus atributos não assinados permitidos se for absolutamente necessário.
**Configuração de pesquisa (opcional)**
O `SearchConfig` define a [versão do beacon](using-beacons.md#beacon-version).
O `SearchConfig` deve ser especificado para usar [criptografia pesquisável](searchable-encryption.md) ou [beacons assinados](configure.md#signed-beacons).
**Conjunto de algoritmos (opcional)**
O `algorithmSuiteId` define qual conjunto de algoritmos o SDK de criptografia de banco de dados da AWS usará.
A menos que você especifique explicitamente um conjunto alternativo de algoritmos, o SDK do AWS Database Encryption usa o conjunto de [algoritmos padrão](supported-algorithms.md#recommended-algorithms). O conjunto de algoritmos padrão usa o algoritmo AES-GCM com derivação de chaves, [assinaturas digitais](concepts.md#digital-sigs) e [comprometimento de chaves](concepts.md#key-commitment). Embora o conjunto de algoritmos padrão provavelmente seja adequado para a maioria dos aplicativos, é possível escolher um conjunto alternativo de algoritmos. Por exemplo, alguns modelos de confiança seriam satisfeitos com um pacote de algoritmos sem assinaturas digitais. Para obter informações sobre os conjuntos de algoritmos compatíveis com o SDK do AWS Database Encryption, consulte[Suítes de algoritmos compatíveis no SDK AWS de criptografia de banco de dados](supported-algorithms.md).
Para selecionar o [conjunto de algoritmos AES-GCM sem assinaturas digitais ECDSA](supported-algorithms.md#other-algorithms), inclua o seguinte trecho em sua configuração de criptografia de tabela.
```
AlgorithmSuiteId = DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384
```
## Atualização de itens com o SDK AWS de criptografia de banco de dados
O SDK AWS de criptografia de banco de dados não oferece suporte a [ddb: UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) para itens que incluem atributos criptografados ou assinados. Para atualizar um atributo criptografado ou assinado, você deve usar [ddb: PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html). Se algum item existir em uma tabela específica com a mesma chave primária de um item existente na consulta `PutItem`, o novo item substituirá completamente o item já existente. Também é possível usar o [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) para limpar e substituir todos os atributos ao salvar após atualizar seus itens.
# Exemplos do.NET
Os exemplos a seguir mostram como usar a biblioteca de criptografia do lado do cliente.NET para o DynamoDB para proteger os itens da tabela em seu aplicativo. Para encontrar mais exemplos (e contribuir com seus próprios), consulte os [exemplos do.NET](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/net/src) no repositório aws-database-encryption-sdk -dynamodb em. GitHub
Os exemplos a seguir demonstram como configurar a biblioteca de criptografia do lado do cliente.NET para o DynamoDB em uma nova tabela não preenchida do Amazon DynamoDB. Se você quiser configurar suas tabelas existentes do Amazon DynamoDB para criptografia do lado do cliente, consulte [Adicionar versão 3.x a uma tabela existente](ddb-net-config-existing-table.md).
**Topics**
+ [Usando o SDK de criptografia de AWS banco de dados de baixo nível para a API do DynamoDB](#ddb-net-lowlevel-API-example)
+ [Usando o nível inferior `DynamoDbItemEncryptor`](#ddb-net-itemencryptor)
## Usando o SDK de criptografia de AWS banco de dados de baixo nível para a API do DynamoDB
O exemplo a seguir mostra como usar o SDK de criptografia de AWS banco de dados de baixo nível para a API do DynamoDB com um [AWS KMS chaveiro](use-kms-keyring.md) para criptografar e assinar automaticamente itens do lado do cliente com suas solicitações do DynamoDB. `PutItem`
Você pode usar qualquer [chaveiro](keyrings.md) compatível, mas recomendamos usar um dos AWS KMS chaveiros sempre que possível.
**Veja o exemplo de código completo**: [BasicPutGetExample.cs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/BasicPutGetExample.cs)
**Etapa 1: criar o AWS KMS chaveiro**
O exemplo a seguir é usado `CreateAwsKmsMrkMultiKeyring` para criar um AWS KMS chaveiro com uma chave KMS de criptografia simétrica. O método `CreateAwsKmsMrkMultiKeyring` garante que o token de autenticação manipule corretamente chaves de região única e de várias regiões.
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsMrkMultiKeyringInput { Generator = kmsKeyId };
var kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Etapa 2: Configurar ações de atributos**
O exemplo a seguir define um `attributeActionsOnEncrypt` dicionário que representa exemplos de [ações de atributos](concepts.md#crypt-actions) para um item da tabela.
O exemplo a seguir não define nenhum atributo como`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se você especificar algum `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
var attributeActionsOnEncrypt = new Dictionary
{
["partition_key"] = CryptoAction.SIGN_ONLY, // The partition attribute must be SIGN_ONLY
["sort_key"] = CryptoAction.SIGN_ONLY, // The sort attribute must be SIGN_ONLY
["attribute1"] = CryptoAction.ENCRYPT_AND_SIGN,
["attribute2"] = CryptoAction.SIGN_ONLY,
[":attribute3"] = CryptoAction.DO_NOTHING
};
```
**Etapa 3: definir quais atributos são excluídos das assinaturas**
O exemplo a seguir pressupõe que todos os atributos `DO_NOTHING` compartilham o prefixo distinto "`:`" e usam o prefixo para definir os atributos não assinados permitidos. O cliente presume que qualquer nome de atributo com o prefixo "`:`" está excluído das assinaturas. Para obter mais informações, consulte [Allowed unsigned attributes](ddb-net-using.md#net-allowed-unauth).
```
const String unsignAttrPrefix = ":";
```
**Etapa 4: definir a configuração de criptografia de tabelas do DynamoDB**
O exemplo a seguir define um mapa `tableConfigs` que representa a configuração de criptografia dessa tabela do DynamoDB.
Este exemplo especifica o nome da tabela do DynamoDB como o [nome lógico da tabela.](ddb-net-using.md#net-logical-table-name) É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez. Para obter mais informações, consulte [Configuração de criptografia no SDK AWS de criptografia de banco de dados para DynamoDB](ddb-net-using.md#ddb-net-config-encrypt).
Para usar [criptografia pesquisável](searchable-encryption.md) ou [beacons assinados](configure.md#signed-beacons), você também deve incluir [`SearchConfig`](ddb-java-using.md#ddb-search-config) na configuração de criptografia.
```
Dictionary tableConfigs =
new Dictionary();
DynamoDbTableEncryptionConfig config = new DynamoDbTableEncryptionConfig
{
LogicalTableName = ddbTableName,
PartitionKeyName = "partition_key",
SortKeyName = "sort_key",
AttributeActionsOnEncrypt = attributeActionsOnEncrypt,
Keyring = kmsKeyring,
AllowedUnsignedAttributePrefix = unsignAttrPrefix
};
tableConfigs.Add(ddbTableName, config);
```
**Etapa 5: criar um novo cliente AWS SDK do DynamoDB**
**O exemplo a seguir cria um novo cliente AWS SDK do DynamoDB usando `TableEncryptionConfigs` o da Etapa 4.**
```
var ddb = new Client.DynamoDbClient(
new DynamoDbTablesEncryptionConfig { TableEncryptionConfigs = tableConfigs });
```
**Etapa 6: criptografar e assinar um item de tabela do DynamoDB**
O exemplo a seguir define um `item` dicionário que representa um item de tabela de amostra e coloca o item na tabela do DynamoDB. O item é criptografado e assinado no lado do cliente antes de ser enviado ao DynamoDB.
```
var item = new Dictionary
{
["partition_key"] = new AttributeValue("BasicPutGetExample"),
["sort_key"] = new AttributeValue { N = "0" },
["attribute1"] = new AttributeValue("encrypt and sign me!"),
["attribute2"] = new AttributeValue("sign me!"),
[":attribute3"] = new AttributeValue("ignore me!")
};
PutItemRequest putRequest = new PutItemRequest
{
TableName = ddbTableName,
Item = item
};
PutItemResponse putResponse = await ddb.PutItemAsync(putRequest);
```
## Usando o nível inferior `DynamoDbItemEncryptor`
O exemplo a seguir mostra como usar o nível inferior de `DynamoDbItemEncryptor` com um [token de autenticação do AWS KMS](use-kms-keyring.md) para criptografar e assinar diretamente os itens da tabela. O `DynamoDbItemEncryptor` não coloca o item na tabela do DynamoDB.
Você pode usar qualquer [chaveiro](keyrings.md) compatível com o DynamoDB Enhanced Client, mas recomendamos usar um dos AWS KMS chaveiros sempre que possível.
**nota**
O nível inferior do `DynamoDbItemEncryptor` não oferece suporte à [criptografia pesquisável](searchable-encryption.md). Use o SDK de criptografia de AWS banco de dados de baixo nível para a API do DynamoDB para usar criptografia pesquisável.
**Veja o exemplo de código completo**: [ItemEncryptDecryptExample.cs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/itemencryptor/ItemEncryptDecryptExample.cs)
**Etapa 1: criar o AWS KMS chaveiro**
O exemplo a seguir é usado `CreateAwsKmsMrkMultiKeyring` para criar um AWS KMS chaveiro com uma chave KMS de criptografia simétrica. O método `CreateAwsKmsMrkMultiKeyring` garante que o token de autenticação manipule corretamente chaves de região única e de várias regiões.
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsMrkMultiKeyringInput { Generator = kmsKeyId };
var kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Etapa 2: Configurar ações de atributos**
O exemplo a seguir define um `attributeActionsOnEncrypt` dicionário que representa exemplos de [ações de atributos](concepts.md#crypt-actions) para um item da tabela.
O exemplo a seguir não define nenhum atributo como`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se você especificar algum `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
var attributeActionsOnEncrypt = new Dictionary
{
["partition_key"] = CryptoAction.SIGN_ONLY, // The partition attribute must be SIGN_ONLY
["sort_key"] = CryptoAction.SIGN_ONLY, // The sort attribute must be SIGN_ONLY
["attribute1"] = CryptoAction.ENCRYPT_AND_SIGN,
["attribute2"] = CryptoAction.SIGN_ONLY,
[":attribute3"] = CryptoAction.DO_NOTHING
};
```
**Etapa 3: definir quais atributos são excluídos das assinaturas**
O exemplo a seguir pressupõe que todos os atributos `DO_NOTHING` compartilham o prefixo distinto "`:`" e usam o prefixo para definir os atributos não assinados permitidos. O cliente presume que qualquer nome de atributo com o prefixo "`:`" está excluído das assinaturas. Para obter mais informações, consulte [Allowed unsigned attributes](ddb-net-using.md#net-allowed-unauth).
```
String unsignAttrPrefix = ":";
```
**Etapa 4: definir a configuração de `DynamoDbItemEncryptor`**
O exemplo a seguir define a configuração para `DynamoDbItemEncryptor`.
Este exemplo especifica o nome da tabela do DynamoDB como o [nome lógico da tabela.](ddb-net-using.md#net-logical-table-name) É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez. Para obter mais informações, consulte [Configuração de criptografia no SDK AWS de criptografia de banco de dados para DynamoDB](ddb-net-using.md#ddb-net-config-encrypt).
```
var config = new DynamoDbItemEncryptorConfig
{
LogicalTableName = ddbTableName,
PartitionKeyName = "partition_key",
SortKeyName = "sort_key",
AttributeActionsOnEncrypt = attributeActionsOnEncrypt,
Keyring = kmsKeyring,
AllowedUnsignedAttributePrefix = unsignAttrPrefix
};
```
**Etapa 5: criar o perfil do `DynamoDbItemEncryptor`**
O exemplo a seguir cria um novo `DynamoDbItemEncryptor` usando `config` da **Etapa 4**.
```
var itemEncryptor = new DynamoDbItemEncryptor(config);
```
**Etapa 6: criptografar e assinar diretamente um item da tabela**
O exemplo a seguir criptografa e assina diretamente um item usando o `DynamoDbItemEncryptor`. O `DynamoDbItemEncryptor` não coloca o item na tabela do DynamoDB.
```
var originalItem = new Dictionary
{
["partition_key"] = new AttributeValue("ItemEncryptDecryptExample"),
["sort_key"] = new AttributeValue { N = "0" },
["attribute1"] = new AttributeValue("encrypt and sign me!"),
["attribute2"] = new AttributeValue("sign me!"),
[":attribute3"] = new AttributeValue("ignore me!")
};
var encryptedItem = itemEncryptor.EncryptItem(
new EncryptItemInput { PlaintextItem = originalItem }
).EncryptedItem;
```
# Configurar uma tabela existente do DynamoDB para usar o SDK de criptografia de banco de dados para AWS o DynamoDB
Com a versão 3. *x* da biblioteca de criptografia do lado do cliente.NET para o DynamoDB, você pode configurar suas tabelas existentes do Amazon DynamoDB para criptografia do lado do cliente. Este tópico fornece orientação sobre as três etapas que você deve seguir para adicionar a versão 3.*x* para uma tabela existente e preenchida do DynamoDB.
## Etapa 1: preparar para ler e gravar itens criptografados
Conclua as etapas a seguir para preparar seu cliente SDK AWS de criptografia de banco de dados para ler e gravar itens criptografados. Depois de implantar as alterações a seguir, seu cliente continuará lendo e gravando itens de texto simples. Ele não criptografará nem assinará nenhum novo item gravado na tabela, mas poderá descriptografar itens criptografados assim que eles aparecerem. Essas mudanças preparam o cliente para começar a [criptografar novos itens](#ddb-net-add-step2). As alterações a seguir devem ser implantadas em cada leitor antes de prosseguir para a próxima etapa.
**1. Definir suas [ações de atributos](concepts.md#crypt-actions)**
Crie um modelo de objeto para definir quais valores de atributos serão criptografados e assinados, quais serão somente assinados e quais serão ignorados.
Por padrão, os atributos da chave primária são assinados, mas não criptografados (`SIGN_ONLY`), e todos os outros atributos são criptografados e assinados (`ENCRYPT_AND_SIGN`).
Especifique `ENCRYPT_AND_SIGN` para criptografar e assinar um atributo. Especifique `SIGN_ONLY` para assinar, mas não criptografar um atributo. Especifique `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` para assinar e atribuir e incluí-los no contexto de criptografia. Não é possível criptografar um atributo sem também assiná-lo. Especifique `DO_NOTHING` para ignorar um atributo. Para obter mais informações, consulte [Ações de atributos no SDK AWS de criptografia de banco de dados para DynamoDB](ddb-net-using.md#ddb-net-attribute-actions).
Se você especificar algum `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` atributo, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
var attributeActionsOnEncrypt = new Dictionary
{
["partition_key"] = CryptoAction.SIGN_ONLY, // The partition attribute must be SIGN_ONLY
["sort_key"] = CryptoAction.SIGN_ONLY, // The sort attribute must be SIGN_ONLY
["attribute1"] = CryptoAction.ENCRYPT_AND_SIGN,
["attribute2"] = CryptoAction.SIGN_ONLY,
[":attribute3"] = CryptoAction.DO_NOTHING
};
```
**2. Definir quais atributos são excluídos das assinaturas**
O exemplo a seguir pressupõe que todos os atributos `DO_NOTHING` compartilham o prefixo distinto "`:`" e usam o prefixo para definir os atributos não assinados permitidos. O cliente presumirá que qualquer nome de atributo com o prefixo "`:`" está excluído das assinaturas. Para obter mais informações, consulte [Allowed unsigned attributes](ddb-net-using.md#net-allowed-unauth).
```
const String unsignAttrPrefix = ":";
```
**3. Criar um [token de autenticação](keyrings.md)**
O exemplo a seguir cria um [token de autenticação do AWS KMS](use-kms-keyring.md). O AWS KMS chaveiro usa criptografia simétrica ou RSA assimétrica AWS KMS keys para gerar, criptografar e descriptografar chaves de dados.
Este exemplo usa `CreateMrkMultiKeyring` para criar um token de autenticação do AWS KMS com uma chave do KMS de criptografia simétrica. O método `CreateAwsKmsMrkMultiKeyring` garante que o token de autenticação manipule corretamente chaves de região única e de várias regiões.
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsMrkMultiKeyringInput { Generator = kmsKeyId };
var kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**4. Definir a configuração de criptografia de tabelas do DynamoDB **
O exemplo a seguir define um mapa `tableConfigs` que representa a configuração de criptografia dessa tabela do DynamoDB.
Este exemplo especifica o nome da tabela do DynamoDB como o [nome lógico da tabela.](ddb-net-using.md#net-logical-table-name) É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez.
Você deve especificar `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` como substituição de texto simples. Essa política continua lendo e gravando itens de texto simples, lendo itens criptografados e preparando o cliente para gravar itens criptografados.
Para obter mais informações sobre os valores incluídos na configuração de criptografia da tabela, consulte[Configuração de criptografia no SDK AWS de criptografia de banco de dados para DynamoDB](ddb-java-using.md#ddb-config-encrypt).
```
Dictionary tableConfigs =
new Dictionary();
DynamoDbTableEncryptionConfig config = new DynamoDbTableEncryptionConfig
{
LogicalTableName = ddbTableName,
PartitionKeyName = "partition_key",
SortKeyName = "sort_key",
AttributeActionsOnEncrypt = attributeActionsOnEncrypt,
Keyring = kmsKeyring,
AllowedUnsignedAttributePrefix = unsignAttrPrefix,
PlaintextOverride = FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT
};
tableConfigs.Add(ddbTableName, config);
```
**5. Crie um novo cliente AWS SDK do DynamoDB**
**O exemplo a seguir cria um novo cliente AWS SDK do DynamoDB usando `TableEncryptionConfigs` o da Etapa 4.**
```
var ddb = new Client.DynamoDbClient(
new DynamoDbTablesEncryptionConfig { TableEncryptionConfigs = tableConfigs });
```
## Etapa 2: gravar itens criptografados e assinados
Atualize a política de texto simples em sua configuração de criptografia de tabela para permitir que o cliente grave itens criptografados e assinados. Depois de implantar a seguinte alteração, o cliente criptografará e assinará novos itens com base nas ações de atributos que você configurou na **Etapa 1**. O cliente poderá ler itens de texto simples e itens criptografados e assinados.
Antes de prosseguir para a [Etapa 3](#ddb-net-add-step3), você deve criptografar e assinar todos os itens de texto sem formatação existentes em sua tabela. Não há uma única métrica ou consulta que você possa executar para criptografar rapidamente seus itens de texto sem formatação existentes. Use o processo que faz mais sentido para o seu sistema. Por exemplo, é possível usar um processo assíncrono que varre lentamente a tabela e reescreve os itens usando as ações de atributos e a configuração de criptografia que você definiu. Para identificar os itens de texto simples em sua tabela, recomendamos escanear todos os itens que não contêm os `aws_dbe_foot` atributos `aws_dbe_head` e que o SDK de criptografia de AWS banco de dados adiciona aos itens quando eles são criptografados e assinados.
O exemplo a seguir atualiza a configuração de criptografia de tabela da **Etapa 1**. Você deve atualizar a substituição de texto simples com `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT`. Essa política continua lendo itens de texto simples, mas também lê e grava itens criptografados. Crie um novo cliente AWS SDK do DynamoDB usando o atualizado. `TableEncryptionConfigs`
```
Dictionary tableConfigs =
new Dictionary();
DynamoDbTableEncryptionConfig config = new DynamoDbTableEncryptionConfig
{
LogicalTableName = ddbTableName,
PartitionKeyName = "partition_key",
SortKeyName = "sort_key",
AttributeActionsOnEncrypt = attributeActionsOnEncrypt,
Keyring = kmsKeyring,
AllowedUnsignedAttributePrefix = unsignAttrPrefix,
PlaintextOverride = FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT
};
tableConfigs.Add(ddbTableName, config);
```
## Etapa 3: somente ler itens criptografados e assinados
Depois de criptografar e assinar todos os seus itens, atualize a substituição de texto simples na configuração de criptografia de tabela para permitir que o cliente leia e grave somente itens criptografados e assinados. Depois de implantar a seguinte alteração, o cliente criptografará e assinará novos itens com base nas ações de atributos que você configurou na **Etapa 1**. O cliente só poderá ler itens criptografados e assinados.
O exemplo a seguir atualiza a configuração de criptografia de tabela da **Etapa 2**. É possível atualizar a substituição de texto sem formatação com `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` ou remover a política de texto sem formatação da sua configuração. Por padrão, o cliente só lê e grava itens criptografados e assinados. Crie um novo cliente AWS SDK do DynamoDB usando o atualizado. `TableEncryptionConfigs`
```
Dictionary tableConfigs =
new Dictionary();
DynamoDbTableEncryptionConfig config = new DynamoDbTableEncryptionConfig
{
LogicalTableName = ddbTableName,
PartitionKeyName = "partition_key",
SortKeyName = "sort_key",
AttributeActionsOnEncrypt = attributeActionsOnEncrypt,
Keyring = kmsKeyring,
AllowedUnsignedAttributePrefix = unsignAttrPrefix,
// Optional: you can also remove the plaintext policy from your configuration
PlaintextOverride = FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT
};
tableConfigs.Add(ddbTableName, config);
```
# Rust
Este tópico explica como instalar e usar a versão 1. *x* da biblioteca de criptografia do lado do cliente Rust para DynamoDB. Para obter detalhes sobre a programação com o SDK AWS de criptografia de banco de dados para DynamoDB, consulte os exemplos de [Rust no](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/) repositório -dynamodb em. aws-database-encryption-sdk GitHub
Todas as implementações da linguagem de programação do SDK de criptografia de AWS banco de dados para DynamoDB são interoperáveis.
**Topics**
+ [Pré-requisitos](#ddb-rust-prerequisites)
+ [Instalação](#ddb-rust-install)
+ [Usando o cliente Rust](ddb-rust-using.md)
## Pré-requisitos
Antes de instalar a biblioteca de criptografia do lado do cliente Rust para o DynamoDB, verifique se você tem os seguintes pré-requisitos.
**Instale Rust and Cargo**
Instale a versão estável atual do [Rust](https://www.rust-lang.org/) usando o [rustup](https://rustup.rs/).
Para obter mais informações sobre como baixar e instalar o rustup, consulte os [procedimentos de instalação](https://doc.rust-lang.org/cargo/getting-started/installation.html) no The Cargo Book.
## Instalação
A biblioteca de criptografia do lado do cliente Rust para o DynamoDB está disponível como caixa em Crates.io. [aws-db-esdk](https://crates.io/crates/aws-db-esdk) Para obter detalhes sobre como instalar e criar a biblioteca, consulte o arquivo [README.md](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) no repositório -dynamodb. aws-database-encryption-sdk GitHub
**Manualmente**
[Para instalar a biblioteca de criptografia do lado do cliente Rust para o DynamoDB, clone ou baixe o repositório -dynamodb. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
**Para instalar a versão mais recente**
Execute o seguinte comando Cargo no diretório do seu projeto:
```
cargo add aws-db-esdk
```
Ou adicione a seguinte linha ao seu Cargo.toml:
```
aws-db-esdk = ""
```
# Usando a biblioteca de criptografia do lado do cliente Rust para o DynamoDB
Este tópico explica algumas das funções e classes auxiliares na versão 1. *x* da biblioteca de criptografia do lado do cliente Rust para DynamoDB.
Para obter detalhes sobre a programação com a biblioteca de criptografia do lado do cliente Rust para o DynamoDB, consulte os exemplos do [Rust](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/) no repositório -dynamodb em. aws-database-encryption-sdk GitHub
**Topics**
+ [Criptografadores de itens](#ddb-rust-item-encryptors)
+ [Ações de atributos](#ddb-rust-attribute-actions)
+ [Configuração de criptografia](#ddb-rust-config-encrypt)
+ [Atualização de itens](#ddb-rust-update-items)
## Criptografadores de itens
Basicamente, o SDK AWS de criptografia de banco de dados para DynamoDB é um criptografador de itens. Você pode usar a versão 1. *x* da biblioteca de criptografia do lado do cliente Rust para que o DynamoDB criptografe, assine, verifique e descriptografe os itens da tabela do DynamoDB das seguintes maneiras.
**O SDK de criptografia de AWS banco de dados de baixo nível para a API do DynamoDB**
Você pode usar sua [configuração de criptografia de tabela](#ddb-rust-config-encrypt) para criar um cliente do DynamoDB que criptografe e assine automaticamente itens do lado do cliente com suas solicitações do DynamoDB. `PutItem`
[Você deve usar o SDK de criptografia de AWS banco de dados de baixo nível para a API do DynamoDB para usar a criptografia pesquisável.](searchable-encryption.md)
[Para ver um exemplo de como usar o SDK de criptografia de AWS banco de dados de baixo nível para a API do DynamoDB, consulte basic\$1get\$1put\$1example.rs no repositório -dynamodb em.](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/basic_get_put_example.rs) aws-database-encryption-sdk GitHub
**O `DynamoDbItemEncryptor` de nível inferior**
O `DynamoDbItemEncryptor` de nível inferior criptografa, assina ou descriptografa e verifica diretamente os itens da tabela sem chamar o DynamoDB. Ele não faz solicitações `PutItem` ou `GetItem` para o DynamoDB. Por exemplo, é possível usar o `DynamoDbItemEncryptor` de nível inferior para descriptografar e verificar diretamente um item do DynamoDB que você já recuperou.
O nível inferior do `DynamoDbItemEncryptor` não oferece suporte à [criptografia pesquisável](searchable-encryption.md).
Para ver um exemplo demonstrando como usar o nível inferior, consulte `DynamoDbItemEncryptor` [item\$1encrypt\$1decrypt.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/itemencryptor/item_encrypt_decrypt.rs) no repositório -dynamodb em. aws-database-encryption-sdk GitHub
## Ações de atributos no SDK AWS de criptografia de banco de dados para DynamoDB
[As ações](concepts.md#crypt-actions) de atributo determinam quais valores de atributos são criptografados e assinados, quais são somente assinados, quais são assinados e incluídos no contexto de criptografia e quais são ignorados.
Para especificar ações de atributos com o cliente Rust, defina manualmente as ações de atributos usando um modelo de objeto. Especifique suas ações de atributo criando um `HashMap` objeto no qual os pares nome-valor representam os nomes dos atributos e as ações especificadas.
Especifique `ENCRYPT_AND_SIGN` para criptografar e assinar um atributo. Especifique `SIGN_ONLY` para assinar, mas não criptografar um atributo. Especifique `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` para assinar um atributo e incluí-lo no contexto de criptografia. Não é possível criptografar um atributo sem também assiná-lo. Especifique `DO_NOTHING` para ignorar um atributo.
Os atributos de partição e classificação devem ser `SIGN_ONLY` ou`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se você definir qualquer atributo como`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, os atributos de partição e classificação também deverão ser`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**nota**
Depois de definir suas ações de atributo, você deverá definir quais atributos serão excluídos das assinaturas. Para facilitar a adição de novos atributos não assinados no futuro, recomendamos escolher um prefixo distinto (como "`:`") para identificar os atributos não assinados. Inclua esse prefixo no nome do atributo para todos os atributos marcados como `DO_NOTHING` ao definir o esquema e as ações de atributos do DynamoDB.
O modelo de objeto a seguir demonstra como especificar`ENCRYPT_AND_SIGN`, `SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, e `DO_NOTHING` atribuir ações com o cliente Rust. Este exemplo usa o prefixo "`:`" para identificar `DO_NOTHING` atributos.
```
let attribute_actions_on_encrypt = HashMap::from([
("partition_key".to_string(), CryptoAction::SignOnly),
("sort_key".to_string(), CryptoAction::SignOnly),
("attribute1".to_string(), CryptoAction::EncryptAndSign),
("attribute2".to_string(), CryptoAction::SignOnly),
(":attribute3".to_string(), CryptoAction::DoNothing),
]);
```
## Configuração de criptografia no SDK AWS de criptografia de banco de dados para DynamoDB
Ao usar o AWS Database Encryption SDK, você deve definir explicitamente uma configuração de criptografia para sua tabela do DynamoDB. Os valores necessários em sua configuração de criptografia dependem se você definiu suas ações de atributo manualmente ou com uma classe de dados anotada.
O trecho a seguir define uma configuração de criptografia de tabela do DynamoDB usando o SDK de criptografia de AWS banco de dados de baixo nível para a API do DynamoDB e atributos não assinados permitidos definidos por um prefixo distinto.
```
let table_config = DynamoDbTableEncryptionConfig::builder()
.logical_table_name(ddb_table_name)
.partition_key_name("partition_key")
.sort_key_name("sort_key")
.attribute_actions_on_encrypt(attribute_actions_on_encrypt)
.keyring(kms_keyring)
.allowed_unsigned_attribute_prefix(UNSIGNED_ATTR_PREFIX)
// Specifying an algorithm suite is optional
.algorithm_suite_id(
DbeAlgorithmSuiteId::AlgAes256GcmHkdfSha512CommitKeyEcdsaP384SymsigHmacSha384,
)
.build()?;
let table_configs = DynamoDbTablesEncryptionConfig::builder()
.table_encryption_configs(HashMap::from([(ddb_table_name.to_string(), table_config)]))
.build()?;
```
**Nome da tabela lógica**
Um nome de tabela lógica para sua tabela do DynamoDB.
O nome da tabela lógica é vinculado criptograficamente a todos os dados armazenados na tabela para simplificar as operações de restauração do DynamoDB. É altamente recomendável especificar o nome da tabela do DynamoDB como o nome lógico da tabela ao definir a configuração de criptografia pela primeira vez. Você deve sempre especificar o mesmo nome de tabela lógica. Para que a descriptografia seja bem-sucedida, o nome da tabela lógica deve corresponder ao nome especificado na criptografia. Se o nome da tabela do DynamoDB mudar após a [restauração da tabela do DynamoDB a partir de um backup](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html), o nome da tabela lógica garantirá que a operação de descriptografia ainda reconheça a tabela.
**Atributos não assinados permitidos**
Os atributos marcados `DO_NOTHING` em suas ações de atributos.
Os atributos não assinados permitidos informam ao cliente quais atributos são excluídos das assinaturas. O cliente presume que todos os outros atributos estão incluídos na assinatura. Em seguida, ao descriptografar um registro, o cliente determina quais atributos ele precisa verificar e quais ignorar dos atributos não assinados permitidos que você especificou. Não é possível remover um atributo dos atributos não assinados permitidos.
É possível definir explicitamente os atributos não assinados permitidos criando uma matriz que lista todos os atributos `DO_NOTHING`. Também é possível especificar um prefixo distinto ao nomear os atributos `DO_NOTHING` e usar o prefixo para informar ao cliente quais atributos não estão assinados. É altamente recomendável especificar um prefixo distinto, pois isso simplifica o processo de adicionar um novo atributo `DO_NOTHING` no futuro. Para obter mais informações, consulte [Atualizar seu modelo de dados](ddb-update-data-model.md).
Se você não especificar um prefixo para todos os atributos `DO_NOTHING`, poderá configurar uma matriz `allowedUnsignedAttributes` que liste explicitamente todos os atributos que o cliente deve esperar que não estejam assinados ao encontrá-los na descriptografia. Você só deve definir explicitamente seus atributos não assinados permitidos se for absolutamente necessário.
**Configuração de pesquisa (opcional)**
O `SearchConfig` define a [versão do beacon](using-beacons.md#beacon-version).
O `SearchConfig` deve ser especificado para usar [criptografia pesquisável](searchable-encryption.md) ou [beacons assinados](configure.md#signed-beacons).
**Suíte de algoritmos (opcional)**
O `algorithmSuiteId` define qual conjunto de algoritmos o SDK de criptografia de banco de dados da AWS usará.
A menos que você especifique explicitamente um conjunto alternativo de algoritmos, o SDK do AWS Database Encryption usa o conjunto de [algoritmos padrão](supported-algorithms.md#recommended-algorithms). O conjunto de algoritmos padrão usa o algoritmo AES-GCM com derivação de chaves, [assinaturas digitais](concepts.md#digital-sigs) e [comprometimento de chaves](concepts.md#key-commitment). Embora o conjunto de algoritmos padrão provavelmente seja adequado para a maioria dos aplicativos, é possível escolher um conjunto alternativo de algoritmos. Por exemplo, alguns modelos de confiança seriam satisfeitos com um pacote de algoritmos sem assinaturas digitais. Para obter informações sobre os conjuntos de algoritmos compatíveis com o SDK do AWS Database Encryption, consulte[Suítes de algoritmos compatíveis no SDK AWS de criptografia de banco de dados](supported-algorithms.md).
Para selecionar o [conjunto de algoritmos AES-GCM sem assinaturas digitais ECDSA](supported-algorithms.md#other-algorithms), inclua o seguinte trecho em sua configuração de criptografia de tabela.
```
.algorithm_suite_id(
DbeAlgorithmSuiteId::AlgAes256GcmHkdfSha512CommitKeyEcdsaP384SymsigHmacSha384,
)
```
## Atualização de itens com o SDK AWS de criptografia de banco de dados
O SDK AWS de criptografia de banco de dados não oferece suporte a [ddb: UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) para itens que incluem atributos criptografados ou assinados. Para atualizar um atributo criptografado ou assinado, você deve usar [ddb: PutItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html). Se algum item existir em uma tabela específica com a mesma chave primária de um item existente na consulta `PutItem`, o novo item substituirá completamente o item já existente.