Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# AWS SDK di crittografia del database per DynamoDB
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
[Il AWS Database Encryption SDK per DynamoDB è una libreria software che consente di includere la crittografia lato client nella progettazione di Amazon DynamoDB.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) Il AWS Database Encryption SDK per DynamoDB fornisce la crittografia a livello di attributo e consente di specificare quali elementi crittografare e quali elementi includere nelle firme che garantiscono l'autenticità dei dati. La crittografia dei dati sensibili in transito e in archivio aiuta a garantire che i dati in chiaro non siano disponibili per terze parti, tra cui. AWS
**Nota**
Il AWS Database Encryption SDK non supporta PartiQL.
In DynamoDB, [una tabella è una](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.TablesItemsAttributes) raccolta di elementi. E ogni *item* è una raccolta di *attributi*. Ogni attributo ha un nome e un valore. Il AWS Database Encryption SDK per DynamoDB crittografa i valori degli attributi. Quindi calcola una firma sugli attributi. [È necessario specificare quali valori degli attributi crittografare e quali includere nella firma nelle azioni crittografiche.](concepts.md#crypt-actions)
Gli argomenti di questo capitolo forniscono una panoramica del AWS Database Encryption SDK per DynamoDB, inclusi i campi crittografati, indicazioni sull'installazione e la configurazione dei client ed esempi Java per aiutarti a iniziare.
**Topics**
+ [Crittografia lato client e lato server](client-server-side.md)
+ [Quali campi sono crittografati e firmati?](DDB-encrypted-and-signed.md)
+ [Crittografia ricercabile in DynamoDB](ddb-searchable-encryption.md)
+ [Aggiornamento del modello di dati](ddb-update-data-model.md)
+ [AWS Database Encryption SDK per DynamoDB (linguaggi di programmazione disponibili)](ddb-programming-languages.md)
+ [Client di crittografia DynamoDB legacy](legacy-dynamodb-encryption-client.md)
# Crittografia lato client e lato server
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata AWS Database Encryption SDK. Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Il AWS Database Encryption SDK per DynamoDB *supporta la crittografia lato client*, che consente di crittografare i dati della tabella prima di inviarli al database. Tuttavia, DynamoDB fornisce una funzionalità di *crittografia a riposo lato server che crittografa in* modo trasparente la tabella quando viene mantenuta su disco e la decrittografa quando si accede alla tabella.
La scelta degli strumenti dipende dal livello di riservatezza dei dati e dai requisiti di sicurezza dell'applicazione. È possibile utilizzare sia il AWS Database Encryption SDK per DynamoDB sia la crittografia a riposo. Quando invii elementi crittografati e firmati a DynamoDB, DynamoDB non riconosce gli elementi come protetti. Rileva soltanto gli item tipici della tabella con valori di attributo binari.
**Crittografia dei dati inattivi lato server**
DynamoDB [supporta la crittografia a](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/EncryptionAtRest.html) riposo, *una funzionalità di crittografia lato server* in cui DynamoDB crittografa in modo trasparente le tabelle per te quando la tabella viene mantenuta su disco e le decrittografa quando accedi ai dati della tabella.
Quando si utilizza un AWS SDK per interagire con DynamoDB, per impostazione predefinita, i dati vengono crittografati in transito tramite una connessione HTTPS, decrittografati sull'endpoint DynamoDB e quindi ricrittografati prima di essere archiviati in DynamoDB.
+ **Crittografia per impostazione predefinita.** DynamoDB crittografa e decrittografa in modo trasparente tutte le tabelle quando vengono scritte. Non c'è alcuna opzione per abilitare o disabilitare la crittografia dei dati inattivi.
+ **DynamoDB crea e gestisce le chiavi crittografiche.**La chiave univoca per ogni tabella è protetta da un codice [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)che non lascia mai [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)()AWS KMS non crittografata. Per impostazione predefinita, DynamoDB utilizza [Chiave di proprietà di AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk)un account del servizio DynamoDB, ma puoi scegliere [Chiave gestita da AWS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk)una chiave [o una chiave gestita dal cliente nel tuo account per proteggere alcune o](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) tutte le tabelle.
+ **Tutti i dati delle tabelle sono crittografati su disco.**[Quando una tabella crittografata viene salvata su disco, DynamoDB crittografa tutti i dati della tabella, inclusa [la chiave primaria](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) e gli indici secondari locali e globali.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.SecondaryIndexes) Se la tabella dispone di chiavi di ordinamento, alcune di queste che contrassegnano i limiti dell'intervallo sono archiviate come testo non crittografato nei metadati della tabella.
+ **Anche gli oggetti correlati alle tabelle sono crittografati.** La crittografia a riposo protegge i flussi[, le tabelle globali](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) [e](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html) i backup di [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html) ogni volta che vengono scritti su supporti durevoli.
+ **I tuoi articoli vengono decriptati quando accedi ad essi.**Quando accedi alla tabella, DynamoDB decrittografa la parte della tabella che include l'elemento di destinazione e ti restituisce l'elemento in testo normale.
**AWS SDK di crittografia del database per DynamoDB**
La crittografia lato client fornisce end-to-end protezione per i dati, in transito e a riposo, dalla loro origine allo storage in DynamoDB. I tuoi dati in chiaro non vengono mai esposti a terze parti, inclusi. AWS Puoi utilizzare AWS Database Encryption SDK per DynamoDB con nuove tabelle DynamoDB oppure puoi migrare le tabelle Amazon DynamoDB esistenti alla versione più recente di Database Encryption SDK per DynamoDB. AWS
+ **I dati sono protetti sia quando sono in transito sia quando sono inattivi.** Non è mai esposto a terze parti, inclusi. AWS
+ **Puoi firmare gli item della tabella.** Puoi indirizzare il AWS Database Encryption SDK per DynamoDB a calcolare una firma su tutto o parte di un elemento della tabella, inclusi gli attributi della chiave primaria. Tramite le firme, puoi rilevare modifiche non autorizzate all'item nel suo insieme, tra cui l'aggiunta o l'eliminazione di attributi o lo scambio dei valori di attributo.
+ **Puoi determinare come proteggere i tuoi dati [selezionando](keyrings.md) un** portachiavi. Il portachiavi determina le chiavi di avvolgimento che proteggono le chiavi dati e, in ultima analisi, i dati. Utilizzate le chiavi di avvolgimento più sicure e pratiche per il vostro compito.
+ **Il AWS Database Encryption SDK per DynamoDB non crittografa l'intera tabella.** Sei tu a scegliere quali attributi crittografare nei tuoi articoli. Il AWS Database Encryption SDK per DynamoDB non crittografa un intero elemento. Non crittografa i nomi di attributo o i nomi o i valori degli attributi della chiave primaria (chiave di partizione e chiave di ordinamento).
**AWS Encryption SDK**
Se stai crittografando i dati archiviati in DynamoDB, ti consigliamo AWS il Database Encryption SDK per DynamoDB.
[AWS Encryption SDK](https://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/) è una libreria di crittografia lato client che ti consente di crittografare e decrittografare i dati generici. Anche se è in grado di proteggere qualsiasi tipo di dati, non è stato progettato per funzionare con i dati strutturati, come i record di database. A differenza del AWS Database Encryption SDK per DynamoDB, non può fornire AWS Encryption SDK il controllo dell'integrità a livello di elemento e non ha alcuna logica per riconoscere gli attributi o impedire la crittografia delle chiavi primarie.
Se utilizzi il AWS Encryption SDK per crittografare qualsiasi elemento della tabella, ricorda che non è compatibile con il AWS Database Encryption SDK per DynamoDB. Non puoi utilizzare due librerie diverse per la crittografia e la decrittografia.
# Quali campi sono crittografati e firmati?
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata AWS Database Encryption SDK. Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Il AWS Database Encryption SDK per DynamoDB è una libreria di crittografia lato client progettata appositamente per le applicazioni Amazon DynamoDB. Amazon DynamoDB archivia i dati [in](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.TablesItemsAttributes) tabelle, che sono una raccolta di elementi. E ogni *item* è una raccolta di *attributi*. Ogni attributo ha un nome e un valore. Il AWS Database Encryption SDK per DynamoDB crittografa i valori degli attributi. Quindi calcola una firma sugli attributi. Puoi specificare quali valori degli attributi crittografare e quali includere nelle firma.
La crittografia protegge la riservatezza del valore degli attributi. La firma assicura l'integrità di tutti gli attributi firmati e la loro relazione reciproca e fornisce l'autenticazione. Consente di rilevare modifiche non autorizzate all'item nel suo insieme, come l'aggiunta o l'eliminazione di attributi o la sostituzione di un valore crittografato con un altro.
In un elemento crittografato, alcuni dati rimangono in testo semplice, tra cui il nome della tabella, tutti i nomi degli attributi, i valori degli attributi che non vengono crittografati, i nomi e i valori degli attributi della chiave primaria (chiave di partizione e chiave di ordinamento) e i tipi di attributo. Non archiviare dati sensibili in questi campi.
Per ulteriori informazioni su come funziona AWS Database Encryption SDK per DynamoDB, consulta. [Come funziona il AWS Database Encryption SDK](how-it-works.md)
**Nota**
[Tutte le menzioni delle *azioni degli attributi negli argomenti*AWS Database Encryption SDK per DynamoDB si riferiscono alle azioni crittografiche.](concepts.md#crypt-actions)
**Topics**
+ [Crittografia dei valori degli attributi](#encrypt-attribute-values)
+ [Firma dell'item](#sign-the-item)
## Crittografia dei valori degli attributi
Il AWS Database Encryption SDK per DynamoDB crittografa i valori (ma non il nome o il tipo di attributo) degli attributi specificati. Per determinare quali valori attributo vengono crittografati, utilizza le [operazioni di attributo](concepts.md#crypt-actions).
Ad esempio, questo item include gli attributi `example` e `test`.
```
'example': 'data',
'test': 'test-value',
...
```
Se effettui la crittografia dell'attributo `example`, ma non dell'attributo `test`, i risultati saranno simili a quelli riportati di seguito. Il valore dell'attributo `example` sono dati binari e non una stringa.
```
'example': Binary(b"'b\x933\x9a+s\xf1\xd6a\xc5\xd5\x1aZ\xed\xd6\xce\xe9X\xf0T\xcb\x9fY\x9f\xf3\xc9C\x83\r\xbb\\"),
'test': 'test-value'
...
```
Gli attributi della chiave primaria, chiave di partizione e chiave di ordinamento, di ogni elemento devono rimanere in testo semplice perché DynamoDB li utilizza per trovare l'elemento nella tabella. Devono essere firmati, ma non crittografati.
Il AWS Database Encryption SDK per DynamoDB identifica automaticamente gli attributi della chiave primaria e garantisce che i loro valori siano firmati, ma non crittografati. Se individui la tua chiave primaria e tenti di crittografarla, il client genera un'eccezione.
Il client memorizza la [descrizione del materiale](concepts.md#material-description) in un nuovo attributo (`aws_dbe_head`) che aggiunge all'articolo. La descrizione del materiale descrive come l'articolo è stato crittografato e firmato. Il client utilizza l'informazione per verificare e decrittografare l'item. Il campo che memorizza la descrizione del materiale non è crittografato.
## Firma dell'item
[Dopo aver crittografato i valori degli attributi specificati, AWS Database Encryption SDK per DynamoDB calcola i codici di autenticazione dei messaggi basati su hash (HMACs) e una [firma digitale](concepts.md#digital-sigs) sulla canonicalizzazione della descrizione del materiale, del [contesto di crittografia](concepts.md#encryption-context) e di ogni campo contrassegnato o nelle azioni degli attributi. `ENCRYPT_AND_SIGN``SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`](concepts.md#crypt-actions) Le firme ECDSA sono abilitate per impostazione predefinita, ma non sono obbligatorie. Il client memorizza le firme HMACs and in un nuovo attributo (`aws_dbe_foot`) che aggiunge all'elemento.
# Crittografia ricercabile in DynamoDB
Per configurare le tabelle Amazon DynamoDB per una crittografia ricercabile, devi utilizzare [AWS KMS il portachiavi gerarchico](use-hierarchical-keyring.md) per generare, crittografare e decrittografare le chiavi dati utilizzate per proteggere i tuoi articoli. È inoltre necessario includere la configurazione di crittografia nella tabella. [`SearchConfig`](ddb-net-using.md#ddb-net-search-config)
**Nota**
Se utilizzi la libreria di crittografia lato client Java per DynamoDB, devi utilizzare l'API di basso livello AWS Database Encryption SDK for DynamoDB per DynamoDB per crittografare, firmare, verificare e decrittografare gli elementi della tabella. Il DynamoDB Enhanced Client e il `DynamoDBItemEncryptor` livello inferiore non supportano la crittografia ricercabile.
**Topics**
+ [Configurazione degli indici secondari con beacon](#ddb-beacon-indexes)
+ [Test delle uscite dei beacon](#ddb-beacon-testing)
## Configurazione degli indici secondari con beacon
Dopo aver [configurato i beacon](configure-beacons.md), è necessario configurare un indice secondario che rifletta ogni beacon prima di poter eseguire la ricerca negli attributi crittografati.
Quando configurate un beacon standard o composto, AWS Database Encryption SDK aggiunge il `aws_dbe_b_` prefisso al nome del beacon in modo che il server possa identificare facilmente i beacon. Ad esempio, se si assegna un nome a un beacon composto, in realtà il nome completo del beacon è. `compoundBeacon` `aws_dbe_b_compoundBeacon` Se si desidera configurare [indici secondari](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) che includano un beacon standard o composto, è necessario includere il prefisso quando si identifica il nome del `aws_dbe_b_` beacon.
**Chiavi di partizione e ordinamento**
Non è possibile crittografare i valori della chiave primaria. Le chiavi di partizione e di ordinamento devono essere firmate. I valori della chiave primaria non possono essere un beacon standard o composto.
I valori della chiave primaria devono essere`SIGN_ONLY`, a meno che non si specifichi alcun `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo, anche gli attributi di partizione e ordinamento. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
I valori della chiave primaria possono essere beacon firmati. Se hai configurato beacon firmati distinti per ciascuno dei valori della chiave primaria, devi specificare il nome dell'attributo che identifica il valore della chiave primaria come nome del beacon firmato. Tuttavia, AWS Database Encryption SDK non aggiunge il prefisso ai beacon firmati. `aws_dbe_b_` Anche se hai configurato beacon firmati distinti per i valori della chiave primaria, devi specificare i nomi degli attributi per i valori della chiave primaria solo quando configuri un indice secondario.
**Indici secondari locali**
La chiave di ordinamento per un [indice secondario locale](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSI.html) può essere un beacon.
Se si specifica un beacon per la chiave di ordinamento, il tipo deve essere String. Se specificate un beacon standard o composto per la chiave di ordinamento, dovete includere il `aws_dbe_b_` prefisso quando specificate il nome del beacon. Se specificate un faro firmato, specificate il nome del beacon senza alcun prefisso.
**Indici secondari globali**
Le chiavi di partizione e di ordinamento per un indice [secondario globale](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html) possono essere entrambe beacon.
Se si specifica un beacon per la chiave di partizione o di ordinamento, il tipo deve essere String. Se specificate un beacon standard o composto per la chiave di ordinamento, dovete includere il `aws_dbe_b_` prefisso quando specificate il nome del beacon. Se specificate un faro firmato, specificate il nome del beacon senza alcun prefisso.
**Proiezioni di attributi**
Una [proiezione](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html#GSI.Projections) è l'insieme di attributi copiato da una tabella in un indice secondario. La chiave di partizione e la chiave di ordinamento della tabella vengono sempre proiettati nell'indice; è possibile proiettare altri attributi per supportare i requisiti di query dell'applicazione. DynamoDB offre tre diverse opzioni per le proiezioni `KEYS_ONLY` degli attributi:,, e. `INCLUDE` `ALL`
Se si utilizza la proiezione dell'attributo INCLUDE per cercare su un beacon, è necessario specificare i nomi di tutti gli attributi da cui è costruito il beacon e il nome del beacon con il prefisso. `aws_dbe_b_` Ad esempio, se avete configurato un faro composto, from, and`compoundBeacon`, dovete specificare`field1`, `field2``field3`, e nella proiezione. `aws_dbe_b_compoundBeacon` `field1` `field2` `field3`
Un indice secondario globale può utilizzare solo gli attributi specificati esplicitamente nella proiezione, ma un indice secondario locale può utilizzare qualsiasi attributo.
## Test delle uscite dei beacon
Se hai [configurato beacon composti](configure-beacons.md#config-compound-beacons) o costruito i beacon utilizzando [campi virtuali](configure-beacons.md#create-virtual-field), ti consigliamo di verificare che questi beacon producano l'output previsto prima di popolare la tabella DynamoDB.
Il AWS Database Encryption SDK fornisce il `DynamoDbEncryptionTransforms` servizio per aiutarti a risolvere i problemi relativi agli output dei campi virtuali e dei beacon compositi.
### Test dei campi virtuali
Il seguente frammento crea elementi di test, definisce il `DynamoDbEncryptionTransforms` servizio con la [configurazione di crittografia della tabella DynamoDB](ddb-java-using.md#ddb-config-encrypt) e dimostra come `ResolveAttributes` utilizzarlo per verificare che il campo virtuale produca l'output previsto.
------
#### [ Java ]
**[Guarda l'esempio di codice completo: .java VirtualBeaconSearchableEncryptionExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/searchableencryption/VirtualBeaconSearchableEncryptionExample.java)**
```
// Create test items
final PutItemRequest itemWithHasTestResultPutRequest = PutItemRequest.builder()
.tableName(ddbTableName)
.item(itemWithHasTestResult)
.build();
final PutItemResponse itemWithHasTestResultPutResponse = ddb.putItem(itemWithHasTestResultPutRequest);
final PutItemRequest itemWithNoHasTestResultPutRequest = PutItemRequest.builder()
.tableName(ddbTableName)
.item(itemWithNoHasTestResult)
.build();
final PutItemResponse itemWithNoHasTestResultPutResponse = ddb.putItem(itemWithNoHasTestResultPutRequest);
// Define the DynamoDbEncryptionTransforms service
final DynamoDbEncryptionTransforms trans = DynamoDbEncryptionTransforms.builder()
.DynamoDbTablesEncryptionConfig(encryptionConfig).build();
// Verify configuration
final ResolveAttributesInput resolveInput = ResolveAttributesInput.builder()
.TableName(ddbTableName)
.Item(itemWithHasTestResult)
.Version(1)
.build();
final ResolveAttributesOutput resolveOutput = trans.ResolveAttributes(resolveInput);
// Verify that VirtualFields has the expected value
Map vf = new HashMap<>();
vf.put("stateAndHasTestResult", "CAt");
assert resolveOutput.VirtualFields().equals(vf);
```
------
#### [ C\$1 / .NET ]
**Guarda l'esempio di codice completo**: [VirtualBeaconSearchableEncryptionExample.cs.](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/VirtualBeaconSearchableEncryptionExample.cs)
```
// Create item with hasTestResult=true
var itemWithHasTestResult = new Dictionary
{
["customer_id"] = new AttributeValue("ABC-123"),
["create_time"] = new AttributeValue { N = "1681495205" },
["state"] = new AttributeValue("CA"),
["hasTestResult"] = new AttributeValue { BOOL = true }
};
// Create item with hasTestResult=false
var itemWithNoHasTestResult = new Dictionary
{
["customer_id"] = new AttributeValue("DEF-456"),
["create_time"] = new AttributeValue { N = "1681495205" },
["state"] = new AttributeValue("CA"),
["hasTestResult"] = new AttributeValue { BOOL = false }
};
// Define the DynamoDbEncryptionTransforms service
var trans = new DynamoDbEncryptionTransforms(encryptionConfig);
// Verify configuration
var resolveInput = new ResolveAttributesInput
{
TableName = ddbTableName,
Item = itemWithHasTestResult,
Version = 1
};
var resolveOutput = trans.ResolveAttributes(resolveInput);
// Verify that VirtualFields has the expected value
Debug.Assert(resolveOutput.VirtualFields.Count == 1);
Debug.Assert(resolveOutput.VirtualFields["stateAndHasTestResult"] == "CAt");
```
------
#### [ Rust ]
**Guarda l'esempio di codice completo**: [virtual\$1beacon\$1searchable\$1encryption.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/virtual_beacon_searchable_encryption.rs).
```
// Create item with hasTestResult=true
let item_with_has_test_result = HashMap::from([
(
"customer_id".to_string(),
AttributeValue::S("ABC-123".to_string()),
),
(
"create_time".to_string(),
AttributeValue::N("1681495205".to_string()),
),
("state".to_string(), AttributeValue::S("CA".to_string())),
("hasTestResult".to_string(), AttributeValue::Bool(true)),
]);
// Create item with hasTestResult=false
let item_with_no_has_test_result = HashMap::from([
(
"customer_id".to_string(),
AttributeValue::S("DEF-456".to_string()),
),
(
"create_time".to_string(),
AttributeValue::N("1681495205".to_string()),
),
("state".to_string(), AttributeValue::S("CA".to_string())),
("hasTestResult".to_string(), AttributeValue::Bool(false)),
]);
// Define the transform service
let trans = transform_client::Client::from_conf(encryption_config.clone())?;
// Verify the configuration
let resolve_output = trans
.resolve_attributes()
.table_name(ddb_table_name)
.item(item_with_has_test_result.clone())
.version(1)
.send()
.await?;
// Verify that VirtualFields has the expected value
let virtual_fields = resolve_output.virtual_fields.unwrap();
assert_eq!(virtual_fields.len(), 1);
assert_eq!(virtual_fields["stateAndHasTestResult"], "CAt");
```
------
### Test dei beacon composti
Il seguente frammento crea un elemento di test, definisce il `DynamoDbEncryptionTransforms` servizio con la [configurazione di crittografia della tabella DynamoDB](ddb-java-using.md#ddb-config-encrypt) e dimostra come `ResolveAttributes` utilizzarlo per verificare che il beacon composto produca l'output previsto.
------
#### [ Java ]
**[Guarda l'esempio di codice completo: .java CompoundBeaconSearchableEncryptionExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/searchableencryption/CompoundBeaconSearchableEncryptionExample.java)**
```
// Create an item with both attributes used in the compound beacon.
final HashMap item = new HashMap<>();
item.put("work_id", AttributeValue.builder().s("9ce39272-8068-4efd-a211-cd162ad65d4c").build());
item.put("inspection_date", AttributeValue.builder().s("2023-06-13").build());
item.put("inspector_id_last4", AttributeValue.builder().s("5678").build());
item.put("unit", AttributeValue.builder().s("011899988199").build());
// Define the DynamoDbEncryptionTransforms service
final DynamoDbEncryptionTransforms trans = DynamoDbEncryptionTransforms.builder()
.DynamoDbTablesEncryptionConfig(encryptionConfig).build();
// Verify configuration
final ResolveAttributesInput resolveInput = ResolveAttributesInput.builder()
.TableName(ddbTableName)
.Item(item)
.Version(1)
.build();
final ResolveAttributesOutput resolveOutput = trans.ResolveAttributes(resolveInput);
// Verify that CompoundBeacons has the expected value
Map cbs = new HashMap<>();
cbs.put("last4UnitCompound", "L-5678.U-011899988199");
assert resolveOutput.CompoundBeacons().equals(cbs);
// Note : the compound beacon actually stored in the table is not "L-5678.U-011899988199"
// but rather something like "L-abc.U-123", as both parts are EncryptedParts
// and therefore the text is replaced by the associated beacon
```
------
#### [ C\$1 / .NET ]
**[Guarda l'esempio di codice completo: .cs CompoundBeaconSearchableEncryptionExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/searchableencryption/CompoundBeaconSearchableEncryptionExample.cs)**
```
// Create an item with both attributes used in the compound beacon
var item = new Dictionary
{
["work_id"] = new AttributeValue("9ce39272-8068-4efd-a211-cd162ad65d4c"),
["inspection_date"] = new AttributeValue("2023-06-13"),
["inspector_id_last4"] = new AttributeValue("5678"),
["unit"] = new AttributeValue("011899988199")
};
// Define the DynamoDbEncryptionTransforms service
var trans = new DynamoDbEncryptionTransforms(encryptionConfig);
// Verify configuration
var resolveInput = new ResolveAttributesInput
{
TableName = ddbTableName,
Item = item,
Version = 1
};
var resolveOutput = trans.ResolveAttributes(resolveInput);
// Verify that CompoundBeacons has the expected value
Debug.Assert(resolveOutput.CompoundBeacons.Count == 1);
Debug.Assert(resolveOutput.CompoundBeacons["last4UnitCompound"] == "L-5678.U-011899988199");
// Note : the compound beacon actually stored in the table is not "L-5678.U-011899988199"
// but rather something like "L-abc.U-123", as both parts are EncryptedParts
// and therefore the text is replaced by the associated beacon
```
------
#### [ Rust ]
**Guarda l'esempio di codice completo**[: compound\$1beacon\$1searchable\$1encryption.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/searchableencryption/compound_beacon_searchable_encryption.rs)
```
// Create an item with both attributes used in the compound beacon
let item = HashMap::from([
(
"work_id".to_string(),
AttributeValue::S("9ce39272-8068-4efd-a211-cd162ad65d4c".to_string()),
),
(
"inspection_date".to_string(),
AttributeValue::S("2023-06-13".to_string()),
),
(
"inspector_id_last4".to_string(),
AttributeValue::S("5678".to_string()),
),
(
"unit".to_string(),
AttributeValue::S("011899988199".to_string()),
),
]);
// Define the transforms service
let trans = transform_client::Client::from_conf(encryption_config.clone())?;
// Verify configuration
let resolve_output = trans
.resolve_attributes()
.table_name(ddb_table_name)
.item(item.clone())
.version(1)
.send()
.await?;
// Verify that CompoundBeacons has the expected value
let compound_beacons = resolve_output.compound_beacons.unwrap();
assert_eq!(compound_beacons.len(), 1);
assert_eq!(
compound_beacons["last4UnitCompound"],
"L-5678.U-011899988199"
);
// but rather something like "L-abc.U-123", as both parts are EncryptedParts
// and therefore the text is replaced by the associated beacon
```
------
# Aggiornamento del modello di dati
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
[Quando configuri il AWS Database Encryption SDK per DynamoDB, fornisci azioni relative agli attributi.](concepts.md#crypt-actions) Su encrypt, AWS Database Encryption SDK utilizza le azioni degli attributi per identificare quali attributi crittografare e firmare, quali attributi firmare (ma non crittografare) e quali ignorare. È inoltre possibile definire [gli attributi non firmati consentiti](ddb-java-using.md#allowed-unauth) per indicare in modo esplicito al client quali attributi sono esclusi dalle firme. In fase di decrittografia, AWS Database Encryption SDK utilizza gli attributi non firmati consentiti definiti dall'utente per identificare gli attributi non inclusi nelle firme. Le azioni relative agli attributi non vengono salvate nell'elemento crittografato e AWS Database Encryption SDK non aggiorna automaticamente le azioni relative agli attributi.
Scegli attentamente le operazioni di attributo. In caso di dubbio, usa **Encrypt and sign (Crittografa e firma)**. Dopo aver utilizzato il AWS Database Encryption SDK per proteggere gli elementi, non è possibile modificare un attributo esistente `ENCRYPT_AND_SIGN` o un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo a. `SIGN_ONLY` `DO_NOTHING` Tuttavia, puoi apportare in sicurezza le seguenti modifiche.
+ [Aggiungi nuovi `ENCRYPT_AND_SIGN` `SIGN_ONLY` attributi e `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`](#ddb-add-auth-attribute)
+ [Rimuovi gli attributi esistenti](#ddb-remove-attribute)
+ [Modificate un `ENCRYPT_AND_SIGN` attributo esistente in `SIGN_ONLY` o `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`](#ddb-encrypt-to-sign)
+ [Modificate un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo esistente `SIGN_ONLY` o in `ENCRYPT_AND_SIGN`](#ddb-sign-to-encrypt)
+ [Aggiungere un nuovo `DO_NOTHING` attributo](#ddb-add-unauth-attribute)
+ [Modificare un `SIGN_ONLY` attributo esistente in `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`](#ddb-signOnly-to-signInclude)
+ [Modificate un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo esistente in `SIGN_ONLY`](#ddb-signInclude-to-signOnly)
**Considerazioni sulla crittografia ricercabile**
Prima di aggiornare il modello di dati, valuta attentamente in che modo gli aggiornamenti potrebbero influire sui [beacon](beacons.md) che hai creato a partire dagli attributi. Dopo aver scritto nuovi record con un beacon, non è possibile aggiornare la configurazione del beacon. Non è possibile aggiornare le azioni relative agli attributi associati agli attributi utilizzati per costruire i beacon. Se rimuovi un attributo esistente e il beacon associato, non sarai in grado di interrogare i record esistenti utilizzando quel beacon. È possibile creare nuovi beacon per i nuovi campi che si aggiungono al record, ma non è possibile aggiornare i beacon esistenti per includere il nuovo campo.
**Considerazioni sugli attributi `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`**
Per impostazione predefinita, le chiavi di partizione e ordinamento sono l'unico attributo incluso nel contesto di crittografia. Potresti prendere in considerazione la definizione di campi aggiuntivi `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` in modo che il fornitore dell'ID della chiave di filiale per il tuo [portachiavi AWS KMS gerarchico](use-hierarchical-keyring.md) possa identificare quale chiave di filiale è necessaria per la decrittografia dal contesto di crittografia. [Per ulteriori informazioni, consulta Branch Key ID supplier.](use-hierarchical-keyring.md#branch-key-id-supplier) Se si specificano `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` degli attributi, devono esserlo `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` anche gli attributi di partizione e ordinamento.
**Nota**
Per utilizzare l'azione `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` crittografica, è necessario utilizzare la versione 3.3 o successiva di AWS Database Encryption SDK. Distribuisci la nuova versione a tutti i lettori prima di [aggiornare il modello di dati](#ddb-update-data-model) per includere. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
## Aggiungi nuovi `ENCRYPT_AND_SIGN` `SIGN_ONLY` attributi e `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
Per aggiungere un nuovo `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo `ENCRYPT_AND_SIGN``SIGN_ONLY`, o, definisci il nuovo attributo nelle azioni relative agli attributi.
Non è possibile rimuovere un `DO_NOTHING` attributo esistente e aggiungerlo nuovamente come `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo `ENCRYPT_AND_SIGN``SIGN_ONLY`,, o.
**Utilizzo di una classe di dati annotata**
Se hai definito le azioni degli attributi con a`TableSchema`, aggiungi il nuovo attributo alla tua classe di dati annotata. Se non specificate un'annotazione relativa all'azione degli attributi per il nuovo attributo, il client crittograferà e firmerà il nuovo attributo per impostazione predefinita (a meno che l'attributo non faccia parte della chiave primaria). Se si desidera firmare solo il nuovo attributo, è necessario aggiungere il nuovo attributo con l'annotazione `@DynamoDBEncryptionSignOnly` o`@DynamoDBEncryptionSignAndIncludeInEncryptionContext`.
**Utilizzo di un modello a oggetti**
Se avete definito manualmente le azioni degli attributi, aggiungete il nuovo attributo alle azioni degli attributi nel modello a oggetti e specificate `ENCRYPT_AND_SIGN``SIGN_ONLY`, o `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` come azione di attributo.
## Rimuovi gli attributi esistenti
Se decidi di non aver più bisogno di un attributo, puoi smettere di scrivere dati su quell'attributo oppure puoi rimuoverlo formalmente dalle tue azioni relative agli attributi. Quando smetti di scrivere nuovi dati su un attributo, l'attributo viene ancora visualizzato nelle tue azioni relative agli attributi. Ciò può essere utile se è necessario ricominciare a utilizzare l'attributo in futuro. La rimozione formale dell'attributo dalle azioni relative agli attributi non lo rimuove dal set di dati. Il set di dati conterrà comunque elementi che includono quell'attributo.
Per rimuovere formalmente un `DO_NOTHING` attributo`ENCRYPT_AND_SIGN`,, o esistente `SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, aggiorna le azioni relative agli attributi.
Se rimuovi un `DO_NOTHING` attributo, non devi rimuovere quell'attributo dagli attributi non [firmati consentiti](ddb-java-using.md#allowed-unauth). Anche se non state più scrivendo nuovi valori per quell'attributo, il client deve comunque sapere che l'attributo non è firmato per leggere gli elementi esistenti che lo contengono.
**Utilizzo di una classe di dati annotata**
Se hai definito le azioni degli attributi con a`TableSchema`, rimuovi l'attributo dalla classe di dati annotata.
**Utilizzo di un modello a oggetti**
Se avete definito manualmente le azioni relative agli attributi, rimuovete l'attributo dalle azioni degli attributi nel modello a oggetti.
## Modificate un `ENCRYPT_AND_SIGN` attributo esistente in `SIGN_ONLY` o `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
Per modificare un `ENCRYPT_AND_SIGN` attributo esistente in `SIGN_ONLY` o`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, è necessario aggiornare le azioni relative agli attributi. Dopo aver distribuito l'aggiornamento, il client sarà in grado di verificare e decrittografare i valori esistenti scritti nell'attributo, ma firmerà solo i nuovi valori scritti nell'attributo.
**Nota**
Valuta attentamente i requisiti di sicurezza prima di modificare un `ENCRYPT_AND_SIGN` attributo esistente in o. `SIGN_ONLY` `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Qualsiasi attributo in grado di memorizzare dati sensibili deve essere crittografato.
**Utilizzo di una classe di dati annotata**
Se hai definito le azioni degli attributi con a`TableSchema`, aggiorna l'attributo esistente per includere l'`@DynamoDBEncryptionSignAndIncludeInEncryptionContext`annotazione `@DynamoDBEncryptionSignOnly` o nella classe di dati annotata.
**Utilizzo di un modello a oggetti**
Se avete definito manualmente le azioni relative agli attributi, aggiornate l'azione dell'attributo associata all'attributo esistente da `SIGN_ONLY` o `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` nel modello `ENCRYPT_AND_SIGN` a oggetti.
## Modificate un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo esistente `SIGN_ONLY` o in `ENCRYPT_AND_SIGN`
Per modificare un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo esistente `SIGN_ONLY` o in`ENCRYPT_AND_SIGN`, è necessario aggiornare le azioni relative agli attributi. Dopo aver distribuito l'aggiornamento, il client sarà in grado di verificare i valori esistenti scritti nell'attributo e crittograferà e firmerà i nuovi valori scritti nell'attributo.
**Utilizzo di una classe di dati annotata**
Se hai definito le azioni degli attributi con a`TableSchema`, rimuovi l'`@DynamoDBEncryptionSignAndIncludeInEncryptionContext`annotazione `@DynamoDBEncryptionSignOnly` or dall'attributo esistente.
**Utilizzo di un modello a oggetti**
Se avete definito manualmente le azioni relative agli attributi, aggiornate l'azione dell'attributo associata all'attributo from `SIGN_ONLY` o `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` to `ENCRYPT_AND_SIGN` nel modello a oggetti.
## Aggiungere un nuovo `DO_NOTHING` attributo
[Per ridurre il rischio di errori durante l'aggiunta di un nuovo `DO_NOTHING` attributo, consigliamo di specificare un prefisso distinto quando si assegnano i nomi `DO_NOTHING` agli attributi e quindi di utilizzare tale prefisso per definire gli attributi non firmati consentiti.](ddb-java-using.md#allowed-unauth)
Non è possibile rimuovere un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo o esistente `ENCRYPT_AND_SIGN` dalla classe di dati annotata e quindi aggiungere nuovamente l'attributo come attributo. `SIGN_ONLY` `DO_NOTHING` È possibile aggiungere solo `DO_NOTHING` attributi completamente nuovi.
I passaggi da eseguire per aggiungere un nuovo `DO_NOTHING` attributo dipendono dal fatto che gli attributi non firmati consentiti siano stati definiti esplicitamente in un elenco o con un prefisso.
**Utilizzo di un prefisso consentito per gli attributi non firmati**
Se hai definito le azioni degli attributi con a`TableSchema`, aggiungi il nuovo `DO_NOTHING` attributo alla classe di dati annotata con l'annotazione. `@DynamoDBEncryptionDoNothing` Se hai definito manualmente le azioni relative agli attributi, aggiorna le azioni degli attributi per includere il nuovo attributo. Assicurati di configurare in modo esplicito il nuovo attributo con l'azione dell'`DO_NOTHING`attributo. È necessario includere lo stesso prefisso distinto nel nome del nuovo attributo.
**Utilizzo di un elenco di attributi non firmati consentiti**
1. Aggiungi il nuovo `DO_NOTHING` attributo all'elenco degli attributi non firmati consentiti e distribuisci l'elenco aggiornato.
1. **Implementa la modifica dalla Fase 1.**
Non è possibile passare alla **Fase 3** finché la modifica non si è propagata a tutti gli host che devono leggere questi dati.
1. Aggiungi il nuovo `DO_NOTHING` attributo alle tue azioni relative agli attributi.
1. Se hai definito le azioni degli attributi con a`TableSchema`, aggiungi il nuovo `DO_NOTHING` attributo alla classe di dati annotata con l'`@DynamoDBEncryptionDoNothing`annotazione.
1. Se hai definito manualmente le azioni relative agli attributi, aggiorna le azioni degli attributi per includere il nuovo attributo. Assicurati di configurare in modo esplicito il nuovo attributo con l'azione dell'`DO_NOTHING`attributo.
1. Implementa la modifica dalla **Fase** 3.
## Modificare un `SIGN_ONLY` attributo esistente in `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
Per modificare un `SIGN_ONLY` attributo esistente in`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, è necessario aggiornare le azioni relative agli attributi. Dopo aver distribuito l'aggiornamento, il client sarà in grado di verificare i valori esistenti scritti nell'attributo e continuerà a firmare nuovi valori scritti nell'attributo. I nuovi valori scritti nell'attributo verranno inclusi nel [contesto di crittografia](concepts.md#encryption-context).
Se si specificano `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` degli attributi, devono esserlo `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` anche gli attributi di partizione e ordinamento.
**Utilizzo di una classe di dati annotata**
Se hai definito le azioni degli attributi con a`TableSchema`, aggiorna l'azione dell'attributo associata all'attributo da `@DynamoDBEncryptionSignOnly` a`@DynamoDBEncryptionSignAndIncludeInEncryptionContext`.
**Utilizzo di un modello a oggetti**
Se avete definito manualmente le azioni relative agli attributi, aggiornate l'azione dell'attributo associata all'attributo da `SIGN_ONLY` a `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` nel modello a oggetti.
## Modificate un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo esistente in `SIGN_ONLY`
Per modificare un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo esistente in`SIGN_ONLY`, è necessario aggiornare le azioni relative agli attributi. Dopo aver distribuito l'aggiornamento, il client sarà in grado di verificare i valori esistenti scritti nell'attributo e continuerà a firmare nuovi valori scritti nell'attributo. I nuovi valori scritti nell'attributo non verranno inclusi nel [contesto di crittografia](concepts.md#encryption-context).
Prima di modificare un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo esistente in`SIGN_ONLY`, valuta attentamente in che modo gli aggiornamenti potrebbero influire sulla funzionalità del [fornitore dell'ID della chiave di filiale](use-hierarchical-keyring.md#branch-key-id-supplier).
**Utilizzo di una classe di dati annotata**
Se hai definito le azioni degli attributi con a`TableSchema`, aggiorna l'azione dell'attributo associata all'attributo da `@DynamoDBEncryptionSignAndIncludeInEncryptionContext` a`@DynamoDBEncryptionSignOnly`.
**Utilizzo di un modello a oggetti**
Se avete definito manualmente le azioni relative agli attributi, aggiornate l'azione dell'attributo associata all'attributo da `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` a `SIGN_ONLY` nel modello a oggetti.
# AWS Database Encryption SDK per DynamoDB (linguaggi di programmazione disponibili)
Il AWS Database Encryption SDK per DynamoDB è disponibile per i seguenti linguaggi di programmazione. Anche se ogni linguaggio ha delle librerie specifiche, le implementazioni risultanti sono interoperabili. È possibile crittografare con un'implementazione di una lingua e decrittografare con un'altra. L'interoperabilità potrebbe essere soggetta a vincoli linguistici. In tal caso, questi vincoli sono descritti nell'argomento relativo all'implementazione della lingua.
**Topics**
+ [Java](ddb-java.md)
+ [.NET](ddb-net.md)
+ [Rust](ddb-rust.md)
# Java
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Questo argomento spiega come installare e utilizzare la versione 3. *x* della libreria di crittografia lato client Java per DynamoDB. Per i dettagli sulla programmazione con AWS Database Encryption SDK per DynamoDB, consulta gli esempi [Java nel](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 repository -dynamodb su. GitHub
**Nota**
I seguenti argomenti si concentrano sulla versione 3. *x* della libreria di crittografia lato client Java per DynamoDB.
[La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS](DDBEC-rename.md) Il AWS Database Encryption SDK continua a supportare le [versioni precedenti di DynamoDB](legacy-dynamodb-encryption-client.md) Encryption Client.
**Topics**
+ [Prerequisiti](#ddb-java-prerequisites)
+ [Installazione](#ddb-java-installation)
+ [Utilizzo del client Java](ddb-java-using.md)
+ [Esempi di Java](ddb-java-examples.md)
+ [Aggiungi la versione 3.x a una tabella esistente](ddb-java-config-existing-table.md)
+ [Migrare alla versione 3.x](ddb-java-migrate.md)
## Prerequisiti
Prima di installare la versione 3. *x* della libreria di crittografia lato client Java per DynamoDB, assicurati di avere i seguenti prerequisiti.
**Un ambiente di sviluppo Java**
È necessario Java 8 o versioni successive. Nel sito Web di Oracle, accedi alla pagina [Java SE Download](https://www.oracle.com/java/technologies/downloads/), quindi scarica e installa Java SE Development Kit (JDK).
Se utilizzi Oracle JDK, devi scaricare e installare anche [Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files](http://www.oracle.com/java/technologies/javase-jce8-downloads.html).
**AWS SDK for Java 2.x**
Il AWS Database Encryption SDK per DynamoDB richiede [il modulo DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) di. AWS SDK for Java 2.x Puoi installare l'intero SDK o solo questo modulo.
Per informazioni sull'aggiornamento della versione di AWS SDK per Java, consulta [Migrazione dalla versione](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) 1.x alla 2.x di. AWS SDK per Java
AWS SDK per Java È disponibile tramite Apache Maven. È possibile dichiarare una dipendenza per l'intero modulo o solo per il modulo AWS SDK per Java. `dynamodb-enhanced`
**Installa AWS SDK per Java utilizzando Apache Maven**
+ Per [importare l'intero AWS SDK per Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#build-the-entire-sdk-into-your-project) come dipendenza, dichiaralo nel file `pom.xml`.
+ Per creare una dipendenza solo per il modulo Amazon DynamoDB AWS SDK per Java in, segui le [istruzioni](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#modules-dependencies) per specificare moduli particolari. Imposta il `groupId` to e il to. `software.amazon.awssdk` `artifactID` `dynamodb-enhanced`
**Nota**
Se si utilizza il AWS KMS portachiavi o il portachiavi AWS KMS gerarchico, è inoltre necessario creare una dipendenza per il modulo. AWS KMS Imposta il to e il `groupId` to. `software.amazon.awssdk` `artifactID` `kms`
## Installazione
È possibile installare la versione 3. *x* della libreria di crittografia lato client Java per DynamoDB nei seguenti modi.
**Utilizzo di Apache Maven**
Il client di crittografia Amazon DynamoDB per Java è disponibile [tramite Apache](https://maven.apache.org/) Maven con la seguente definizione di dipendenza.
```
software.amazon.cryptography
aws-database-encryption-sdk-dynamodb
version-number
```
**Usare Gradle Kotlin**
*Puoi usare [Gradle](https://gradle.org/) per dichiarare una dipendenza da Amazon DynamoDB Encryption Client for Java aggiungendo quanto segue alla sezione delle dipendenze del tuo progetto Gradle.*
```
implementation("software.amazon.cryptography:aws-database-encryption-sdk-dynamodb:version-number")
```
**Manualmente**
[Per installare la libreria di crittografia lato client Java per DynamoDB, clona o scarica il repository -dynamodb. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
[Dopo aver installato l'SDK, inizia a guardare il codice di esempio in questa guida e gli esempi Java nel repository -dynamodb su.](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
# Utilizzo della libreria di crittografia lato client Java per DynamoDB
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Questo argomento spiega alcune delle funzioni e delle classi di supporto della versione 3. *x* della libreria di crittografia lato client Java per DynamoDB.
[Per i dettagli sulla programmazione con la libreria di crittografia lato client Java per DynamoDB, consulta gli esempi Java, [gli esempi Java nel repository](java-examples.md) -dynamodb su.](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**
+ [Componenti di crittografia dell'item](#ddb-item-encryptors)
+ [Operazioni di attributo](#ddb-attribute-actions)
+ [Configurazione della crittografia](#ddb-config-encrypt)
+ [Aggiornamento degli elementi](#ddb-update-items)
+ [Decrittografia dei set firmati](#ddb-java-signed-sets)
## Componenti di crittografia dell'item
Fondamentalmente, il AWS Database Encryption SDK per DynamoDB è un cifratore di elementi. È possibile utilizzare la versione 3. *x* della libreria di crittografia lato client Java per DynamoDB per crittografare, firmare, verificare e decrittografare gli elementi della tabella DynamoDB nei seguenti modi.
**Il client avanzato per DynamoDB**
È possibile configurare il [DynamoDB Enhanced Client per crittografare e firmare automaticamente `DynamoDbEncryptionInterceptor` gli elementi lato client con le richieste DynamoDB](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html). `PutItem` Con DynamoDB Enhanced Client, puoi definire le azioni degli attributi utilizzando [una](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) classe di dati annotata. Consigliamo di utilizzare il DynamoDB Enhanced Client ogni volta che è possibile.
[Il DynamoDB Enhanced Client non supporta la crittografia ricercabile.](searchable-encryption.md)
[Il AWS Database Encryption SDK non supporta le annotazioni sugli attributi annidati.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)
**L'API DynamoDB di basso livello**
Puoi configurare l'API [DynamoDB di basso livello per crittografare e firmare](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html) automaticamente gli elementi lato client con `DynamoDbEncryptionInterceptor` le tue richieste DynamoDB. `PutItem`
[È necessario utilizzare l'API DynamoDB di basso livello per utilizzare la crittografia ricercabile.](searchable-encryption.md)
**Il livello inferiore `DynamoDbItemEncryptor`**
Il livello inferiore crittografa e firma o decrittografa e verifica `DynamoDbItemEncryptor` direttamente gli elementi della tabella senza chiamare DynamoDB. Non crea DynamoDB o `PutItem` richieste`GetItem`. Ad esempio, puoi utilizzare il livello inferiore per `DynamoDbItemEncryptor` decrittografare e verificare direttamente un elemento DynamoDB che hai già recuperato.
[Il livello inferiore non supporta la crittografia ricercabile. `DynamoDbItemEncryptor`](searchable-encryption.md)
## Azioni relative agli attributi nel AWS Database Encryption SDK per DynamoDB
[Le azioni relative](concepts.md#crypt-actions) agli attributi determinano quali valori degli attributi sono crittografati e firmati, quali sono solo firmati, quali sono firmati e inclusi nel contesto di crittografia e quali vengono ignorati.
**Nota**
Per utilizzare l'azione `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` crittografica, è necessario utilizzare la versione 3.3 o successiva di AWS Database Encryption SDK. Distribuisci la nuova versione a tutti i lettori prima di [aggiornare il modello di dati](ddb-update-data-model.md) per includere. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
Se utilizzi l'API DynamoDB di basso livello o il `DynamoDbItemEncryptor` livello inferiore, devi definire manualmente le azioni degli attributi. [Se si utilizza il DynamoDB Enhanced Client, è possibile definire manualmente le azioni relative agli attributi oppure utilizzare una classe di dati annotata per generare un. `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) Per semplificare il processo di configurazione, consigliamo di utilizzare una classe di dati annotata. Quando utilizzate una classe di dati annotata, dovete modellare l'oggetto una sola volta.
**Nota**
Dopo aver definito le azioni relative agli attributi, è necessario definire quali attributi sono esclusi dalle firme. Per semplificare l'aggiunta di nuovi attributi non firmati in futuro, consigliamo di scegliere un prefisso distinto (ad esempio "`:`«) per identificare gli attributi non firmati. Includi questo prefisso nel nome dell'attributo per tutti gli attributi contrassegnati durante `DO_NOTHING` la definizione dello schema DynamoDB e delle azioni degli attributi.
### Utilizza una classe di dati annotata
Utilizza una [classe di dati annotata](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) per specificare le azioni degli attributi con DynamoDB Enhanced Client e. `DynamoDbEncryptionInterceptor` Il AWS Database Encryption SDK per DynamoDB utilizza le annotazioni [standard degli attributi DynamoDB che definiscono il tipo di attributo](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.html) per determinare come proteggere un attributo. Per impostazione predefinita, tutti gli attributi sono crittografati e firmati, tranne le chiavi primarie, che sono firmate ma non crittografate.
**Nota**
Per utilizzare l'azione `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` crittografica, è necessario utilizzare la versione 3.3 o successiva del Database Encryption SDK. AWS Distribuisci la nuova versione a tutti i lettori prima di [aggiornare il modello di dati](ddb-update-data-model.md) per includere. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
[SimpleClassConsulta.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) nel repository aws-database-encryption-sdk -dynamodb su GitHub per ulteriori indicazioni sulle annotazioni di DynamoDB Enhanced Client.
Per impostazione predefinita, gli attributi della chiave primaria sono firmati ma non crittografati (`SIGN_ONLY`) e tutti gli altri attributi sono crittografati e firmati (). `ENCRYPT_AND_SIGN` Se si definiscono gli attributi come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, allora anche gli attributi di partizione e ordinamento devono esserlo`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Per specificare le eccezioni, utilizzate le annotazioni di crittografia definite nella libreria di crittografia lato client Java per DynamoDB. Ad esempio, se desideri che un particolare attributo venga firmato, utilizza l'annotazione. `@DynamoDbEncryptionSignOnly` Se desideri che un particolare attributo venga firmato e incluso nel contesto di crittografia, usa il`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`. Se vuoi che un particolare attributo non sia né firmato né crittografato (`DO_NOTHING`), usa l'`@DynamoDbEncryptionDoNothing`annotazione.
**Nota**
[Il AWS Database Encryption SDK non supporta le annotazioni sugli attributi annidati.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)
L'esempio seguente mostra le annotazioni utilizzate per definire e attribuire `ENCRYPT_AND_SIGN` le `SIGN_ONLY` azioni. `DO_NOTHING` [Per un esempio che mostra le annotazioni utilizzate per definire`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, vedete 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;
}
}
```
Usa la tua classe di dati annotata per creare il file `TableSchema` come mostrato nel seguente frammento.
```
final TableSchema tableSchema = TableSchema.fromBean(SimpleClass.class);
```
### Definisci manualmente le azioni degli attributi
Per specificare manualmente le azioni degli attributi, create un `Map` oggetto in cui le coppie nome-valore rappresentino i nomi degli attributi e le azioni specificate.
Specificate `ENCRYPT_AND_SIGN` di crittografare e firmare un attributo. `SIGN_ONLY`Specificare di firmare, ma non crittografare, un attributo. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`Specificare di firmare un attributo e di includerlo nel contesto di crittografia. Non è possibile crittografare un attributo senza firmarlo. `DO_NOTHING`Specificare di ignorare un attributo.
Gli attributi di partizione e ordinamento devono essere `SIGN_ONLY` o`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se si definiscono gli attributi come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, allora anche gli attributi di partizione e ordinamento devono essere uguali. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
**Nota**
Per utilizzare l'azione `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` crittografica, è necessario utilizzare la versione 3.3 o successiva del AWS Database Encryption SDK. Distribuisci la nuova versione a tutti i lettori prima di [aggiornare il modello di dati](ddb-update-data-model.md) per includere. `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);
```
## Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB
Quando si utilizza AWS Database Encryption SDK, è necessario definire in modo esplicito una configurazione di crittografia per la tabella DynamoDB. I valori richiesti nella configurazione di crittografia dipendono dal fatto che le azioni degli attributi siano state definite manualmente o con una classe di dati annotata.
Il seguente frammento definisce una configurazione di crittografia delle tabelle DynamoDB utilizzando il DynamoDB Enhanced Client e gli attributi non firmati consentiti definiti da un prefisso [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)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 della tabella logica**
Un nome di tabella logica per la tabella DynamoDB.
Il nome della tabella logica è associato crittograficamente a tutti i dati memorizzati nella tabella per semplificare le operazioni di ripristino di DynamoDB. Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. È necessario specificare sempre lo stesso nome di tabella logica. Affinché la decrittografia abbia esito positivo, il nome della tabella logica deve corrispondere al nome specificato nella crittografia. Nel caso in cui il nome della tabella DynamoDB cambi dopo il [ripristino della tabella DynamoDB da un backup, il nome della tabella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) logica assicura che l'operazione di decrittografia riconosca ancora la tabella.
**Attributi non firmati consentiti**
Gli attributi contrassegnati `DO_NOTHING` nelle azioni relative agli attributi.
Gli attributi non firmati consentiti indicano al client quali attributi sono esclusi dalle firme. Il client presume che tutti gli altri attributi siano inclusi nella firma. Quindi, durante la decrittografia di un record, il client determina quali attributi deve verificare e quali ignorare tra gli attributi non firmati consentiti specificati. Non è possibile rimuovere un attributo dagli attributi non firmati consentiti.
È possibile definire gli attributi non firmati consentiti in modo esplicito creando un array che elenca tutti gli attributi. `DO_NOTHING` È inoltre possibile specificare un prefisso distinto quando si assegnano nomi `DO_NOTHING` agli attributi e utilizzare il prefisso per indicare al client quali attributi non sono firmati. Consigliamo vivamente di specificare un prefisso distinto perché semplifica il processo di aggiunta di un nuovo `DO_NOTHING` attributo in futuro. Per ulteriori informazioni, consulta [Aggiornamento del modello di dati](ddb-update-data-model.md).
Se non si specifica un prefisso per tutti gli `DO_NOTHING` attributi, è possibile configurare un `allowedUnsignedAttributes` array che elenchi in modo esplicito tutti gli attributi che il client dovrebbe aspettarsi che non siano firmati quando li incontra durante la decrittografia. È necessario definire in modo esplicito gli attributi non firmati consentiti solo se assolutamente necessario.
**Configurazione della ricerca (opzionale)**
`SearchConfig`definisce la versione del [beacon](using-beacons.md#beacon-version).
[È `SearchConfig` necessario specificare il per utilizzare la [crittografia ricercabile](searchable-encryption.md) o i beacon firmati.](configure.md#signed-beacons)
**Algorithm Suite (opzionale)**
`algorithmSuiteId`Definisce la suite di algoritmi utilizzata da AWS Database Encryption SDK.
A meno che non si specifichi esplicitamente una suite di algoritmi alternativa, AWS Database Encryption SDK utilizza la suite di algoritmi [predefinita](supported-algorithms.md#recommended-algorithms). [La suite di algoritmi predefinita utilizza l'algoritmo AES-GCM con derivazione delle chiavi, firme [digitali](concepts.md#digital-sigs) e impegno delle chiavi.](concepts.md#key-commitment) Sebbene la suite di algoritmi predefinita sia probabilmente adatta alla maggior parte delle applicazioni, è possibile scegliere una suite di algoritmi alternativa. Ad esempio, alcuni modelli di fiducia sarebbero soddisfatti da una suite di algoritmi senza firme digitali. Per informazioni sulle suite di algoritmi supportate da AWS Database Encryption SDK, consulta. [Suite di algoritmi supportate nel AWS Database Encryption SDK](supported-algorithms.md)
Per selezionare la [suite di algoritmi AES-GCM senza firme digitali ECDSA](supported-algorithms.md#other-algorithms), includi il seguente frammento nella configurazione di crittografia delle tabelle.
```
.algorithmSuiteId(
DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384)
```
## Aggiornamento degli AWS elementi con Database Encryption SDK
Il AWS Database Encryption SDK non supporta [ddb: UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) per gli elementi che sono stati crittografati o firmati. Per aggiornare un elemento crittografato o firmato, è necessario utilizzare [ddb](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html):. PutItem Quando specifichi la stessa chiave primaria di un elemento esistente nella tua `PutItem` richiesta, il nuovo elemento sostituisce completamente l'elemento esistente. Puoi anche usare [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) per cancellare e sostituire tutti gli attributi al momento del salvataggio dopo aver aggiornato i tuoi articoli.
## Decrittografia dei set firmati
Nelle versioni 3.0.0 e 3.1.0 di AWS Database Encryption SDK, se si definisce un attributo di [tipo set](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes.SetTypes) come`SIGN_ONLY`, i valori del set vengono canonicalizzati nell'ordine in cui vengono forniti. DynamoDB non mantiene l'ordine dei set. Di conseguenza, c'è la possibilità che la convalida della firma dell'elemento che contiene il set abbia esito negativo. La convalida della firma ha esito negativo quando i valori del set vengono restituiti in un ordine diverso da quello fornito al AWS Database Encryption SDK, anche se gli attributi del set contengono gli stessi valori.
**Nota**
Le versioni 3.1.1 e successive del AWS Database Encryption SDK canonicalizzano i valori di tutti gli attributi dei tipi di set, in modo che i valori vengano letti nello stesso ordine in cui sono stati scritti in DynamoDB.
Se la convalida della firma fallisce, l'operazione di decrittografia fallisce e restituisce il seguente messaggio di errore.
| |
| --- |
| software.amazon.cryptography.dbencryptionsdk.structuredencryption.model. StructuredEncryptionException: Nessun tag del destinatario corrispondente. |
Se ricevete il messaggio di errore riportato sopra e ritenete che l'elemento che state cercando di decrittografare includa un set firmato utilizzando la versione 3.0.0 o 3.1.0, consultate la [DecryptWithPermute](https://github.com/aws/aws-database-encryption-sdk-dynamodb-java/tree/v3.1.1/DecryptWithPermute)directory del repository aws-database-encryption-sdk -dynamodb-java su per i dettagli su come convalidare correttamente il set. GitHub
# Esempi di Java
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Gli esempi seguenti mostrano come utilizzare la libreria di crittografia lato client Java per DynamoDB per proteggere gli elementi della tabella nell'applicazione. Puoi trovare altri esempi (e contribuire con i tuoi) negli [esempi Java](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) nel repository -dynamodb su. aws-database-encryption-sdk GitHub
Gli esempi seguenti mostrano come configurare la libreria di crittografia lato client Java per DynamoDB in una nuova tabella Amazon DynamoDB non popolata. Se desideri configurare le tabelle Amazon DynamoDB esistenti per la crittografia lato client, consulta. [Aggiungi la versione 3.x a una tabella esistente](ddb-java-config-existing-table.md)
**Topics**
+ [Utilizzo del client avanzato DynamoDB](#ddb-java-enhanced-client-example)
+ [Utilizzo dell'API DynamoDB di basso livello](#ddb-java-lowlevel-API-example)
+ [Utilizzo del livello inferiore DynamoDbItemEncryptor](#ddb-java-itemencryptor)
## Utilizzo del client avanzato DynamoDB
L'esempio seguente mostra come utilizzare il DynamoDB Enhanced Client `DynamoDbEncryptionInterceptor` e [AWS KMS un](use-kms-keyring.md) portachiavi per crittografare gli elementi della tabella DynamoDB come parte delle chiamate API DynamoDB.
Puoi utilizzare qualsiasi [portachiavi](keyrings.md) supportato con DynamoDB Enhanced Client, ma consigliamo di utilizzare uno dei AWS KMS portachiavi quando possibile.
**Nota**
[Il DynamoDB Enhanced Client non supporta la crittografia ricercabile.](searchable-encryption.md) Utilizza l'`DynamoDbEncryptionInterceptor`API DynamoDB di basso livello per utilizzare la crittografia ricercabile.
**Guarda l'esempio di codice completo**[: .java EnhancedPutGetExample](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)
**Fase 1: Creare il portachiavi AWS KMS **
L'esempio seguente utilizza la creazione `CreateAwsKmsMrkMultiKeyring` di un AWS KMS portachiavi con una chiave KMS di crittografia simmetrica. Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Passaggio 2: creare uno schema tabellare dalla classe di dati annotata**
L'esempio seguente utilizza la classe di dati annotati per creare il. `TableSchema`
[Questo esempio presuppone che la classe di dati annotata e le azioni degli attributi siano state definite utilizzando .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) Per ulteriori informazioni sull'annotazione delle azioni relative agli attributi, consulta. [Utilizza una classe di dati annotata](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
[Il AWS Database Encryption SDK non supporta le annotazioni sugli attributi annidati.](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);
```
**Fase 3: Definire quali attributi sono esclusi dalle firme**
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presuppone che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Fase 4: Creare la configurazione di crittografia**
L'esempio seguente definisce una `tableConfigs` mappa che rappresenta la configurazione di crittografia per la tabella DynamoDB.
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-java-using.md#logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Per utilizzare la [crittografia ricercabile](searchable-encryption.md) o [i beacon firmati](configure.md#signed-beacons), è necessario includerli anche nella configurazione di crittografia. [`SearchConfig`](ddb-java-using.md#ddb-search-config)
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
.build());
```
**Fase 5: Crea il `DynamoDbEncryptionInterceptor`**
L'esempio seguente ne crea uno nuovo `DynamoDbEncryptionInterceptor` con il `tableConfigs` **passo 4**.
```
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
```
**Fase 6: Creare un nuovo client AWS SDK DynamoDB**
**L'esempio seguente crea un nuovo client AWS SDK DynamoDB utilizzando `interceptor` lo Step 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Fase 7: Creare il DynamoDB Enhanced Client e creare una tabella**
L'esempio seguente crea il DynamoDB Enhanced Client utilizzando il client DynamoDB AWS SDK creato **nel passaggio** 6 e crea una tabella utilizzando la classe di dati annotati.
```
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
```
**Fase 8: Crittografare e firmare un elemento della tabella**
L'esempio seguente inserisce un elemento nella tabella DynamoDB utilizzando il DynamoDB Enhanced Client. L'elemento viene crittografato e firmato lato client prima di essere inviato a 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);
```
## Utilizzo dell'API DynamoDB di basso livello
L'esempio seguente mostra come utilizzare l'API DynamoDB di basso livello con [AWS KMS un](use-kms-keyring.md) portachiavi per crittografare e firmare automaticamente gli elementi lato client con le richieste DynamoDB. `PutItem`
Puoi utilizzare qualsiasi [portachiavi supportato, ma ti consigliamo di utilizzare uno dei portachiavi](keyrings.md) quando possibile. AWS KMS
**[Guarda l'esempio di codice completo: .java BasicPutGetExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb//blob/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples/BasicPutGetExample.java)**
**Fase 1: Creare il portachiavi AWS KMS **
L'esempio seguente utilizza la creazione `CreateAwsKmsMrkMultiKeyring` di un AWS KMS portachiavi con una chiave KMS di crittografia simmetrica. Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Passaggio 2: configura le azioni relative agli attributi**
L'esempio seguente definisce una `attributeActionsOnEncrypt` mappa che rappresenta [azioni di esempio relative agli attributi](concepts.md#crypt-actions) per un elemento della tabella.
L'esempio seguente non definisce alcun attributo come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se si specifica un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo, devono esserlo `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` anche gli attributi di partizione e ordinamento.
```
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);
```
**Fase 3: Definire quali attributi sono esclusi dalle firme**
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presuppone che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Fase 4: Definire la configurazione di crittografia delle tabelle DynamoDB**
L'esempio seguente definisce una `tableConfigs` mappa che rappresenta la configurazione di crittografia per questa tabella DynamoDB.
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-java-using.md#logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Per utilizzare la [crittografia ricercabile](searchable-encryption.md) o [i beacon firmati](configure.md#signed-beacons), è necessario includerli anche nella configurazione di crittografia. [`SearchConfig`](ddb-java-using.md#ddb-search-config)
```
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);
```
**Fase 5: Creare il `DynamoDbEncryptionInterceptor`**
L'esempio seguente crea l'`DynamoDbEncryptionInterceptor`utilizzo del `tableConfigs` dal **passaggio 4**.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
**Fase 6: Creare un nuovo client AWS SDK DynamoDB**
**L'esempio seguente crea un nuovo client AWS SDK DynamoDB utilizzando `interceptor` lo Step 5.**
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Fase 7: Crittografare e firmare un elemento della tabella DynamoDB**
L'esempio seguente definisce una `item` mappa che rappresenta un elemento della tabella di esempio e inserisce l'elemento nella tabella DynamoDB. L'elemento viene crittografato e firmato lato client prima di essere inviato a 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);
```
## Utilizzo del livello inferiore DynamoDbItemEncryptor
L'esempio seguente mostra come utilizzare il livello inferiore `DynamoDbItemEncryptor` con un [AWS KMS portachiavi](use-kms-keyring.md) per crittografare e firmare direttamente gli elementi della tabella. Non `DynamoDbItemEncryptor` inserisce l'elemento nella tabella DynamoDB.
Puoi utilizzare qualsiasi [portachiavi](keyrings.md) supportato con DynamoDB Enhanced Client, ma consigliamo di utilizzare uno dei AWS KMS portachiavi quando possibile.
**Nota**
[Il livello inferiore `DynamoDbItemEncryptor` non supporta la crittografia ricercabile.](searchable-encryption.md) Utilizza l'`DynamoDbEncryptionInterceptor`API DynamoDB di basso livello per utilizzare la crittografia ricercabile.
**Guarda l'esempio di codice completo**[: .java ItemEncryptDecryptExample](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)
**Fase 1: Creare il portachiavi AWS KMS **
L'esempio seguente utilizza la creazione `CreateAwsKmsMrkMultiKeyring` di un AWS KMS portachiavi con una chiave KMS di crittografia simmetrica. Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Passaggio 2: configura le azioni relative agli attributi**
L'esempio seguente definisce una `attributeActionsOnEncrypt` mappa che rappresenta [azioni di esempio relative agli attributi](concepts.md#crypt-actions) per un elemento della tabella.
L'esempio seguente non definisce alcun attributo come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se si specifica un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo, devono esserlo `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` anche gli attributi di partizione e ordinamento.
```
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);
```
**Fase 3: Definire quali attributi sono esclusi dalle firme**
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presuppone che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Fase 4: Definire la configurazione `DynamoDbItemEncryptor`**
L'esempio seguente definisce la configurazione per`DynamoDbItemEncryptor`.
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-java-using.md#logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per 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();
```
**Fase 5: Creare il `DynamoDbItemEncryptor`**
L'esempio seguente ne crea uno nuovo `DynamoDbItemEncryptor` utilizzando il `config` tratto dal **passaggio 4**.
```
final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor.builder()
.DynamoDbItemEncryptorConfig(config)
.build();
```
**Fase 6: Crittografare e firmare direttamente un elemento della tabella**
L'esempio seguente crittografa e firma direttamente un elemento utilizzando il. `DynamoDbItemEncryptor` Non `DynamoDbItemEncryptor` inserisce l'elemento nella tabella 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();
```
# Configurare una tabella DynamoDB esistente per utilizzare AWS il Database Encryption SDK per DynamoDB
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Con la versione 3. *x* della libreria di crittografia lato client Java per DynamoDB, puoi configurare le tabelle Amazon DynamoDB esistenti per la crittografia lato client. Questo argomento fornisce indicazioni sui tre passaggi da eseguire per aggiungere la versione 3. *x* su una tabella DynamoDB esistente e popolata.
**Prerequisiti**
Versione 3. *x* [della libreria di crittografia lato client Java per DynamoDB richiede il DynamoDB Enhanced Client fornito in.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) AWS SDK for Java 2.x Se usi ancora [Dynamo DBMapper](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html), devi migrare per utilizzare il DynamoDB AWS SDK for Java 2.x Enhanced Client.
Segui le istruzioni per la [migrazione dalla versione](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) 1.x alla 2.x di. AWS SDK per Java
Quindi, segui le istruzioni per [iniziare a utilizzare l'API DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started.html).
[Prima di configurare la tabella per utilizzare la libreria di crittografia lato client Java per DynamoDB, è necessario generare una classe di dati `TableSchema`[con annotazioni e creare un](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) client avanzato.](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)
## Fase 1: Prepararsi a leggere e scrivere elementi crittografati
Completa i seguenti passaggi per preparare il client AWS Database Encryption SDK per leggere e scrivere elementi crittografati. Dopo aver implementato le seguenti modifiche, il client continuerà a leggere e scrivere elementi in testo non crittografato. Non crittograferà né firmerà i nuovi elementi scritti nella tabella, ma sarà in grado di decrittografare gli elementi crittografati non appena vengono visualizzati. Queste modifiche preparano il client a iniziare a [crittografare](#ddb-java-add-step2) nuovi elementi. Le seguenti modifiche devono essere implementate su ciascun lettore prima di procedere al passaggio successivo.
**1. Definite le azioni relative agli [attributi](concepts.md#crypt-actions)**
Aggiorna la tua classe di dati annotata per includere azioni di attributo che definiscono quali valori degli attributi saranno crittografati e firmati, quali saranno solo firmati e quali verranno ignorati.
Consulta il [SimpleClassfile.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) nel repository aws-database-encryption-sdk -dynamodb GitHub per ulteriori informazioni sulle annotazioni di DynamoDB Enhanced Client.
Per impostazione predefinita, gli attributi della chiave primaria sono firmati ma non crittografati (`SIGN_ONLY`) e tutti gli altri attributi sono crittografati e firmati (). `ENCRYPT_AND_SIGN` Per specificare le eccezioni, utilizzate le annotazioni di crittografia definite nella libreria di crittografia lato client Java per DynamoDB. Ad esempio, se vuoi che un particolare attributo sia solo segno, usa l'annotazione. `@DynamoDbEncryptionSignOnly` Se desideri che un particolare attributo sia firmato e incluso nel contesto di crittografia, usa l'`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`annotazione. Se vuoi che un particolare attributo non sia né firmato né crittografato (`DO_NOTHING`), usa l'`@DynamoDbEncryptionDoNothing`annotazione.
Se specificate degli `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributi, devono esserlo anche gli attributi di partizione e ordinamento. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` [Per un esempio che mostra le annotazioni utilizzate per definire`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, vedete 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)
Per esempio annotazioni, vedere. [Utilizza una classe di dati annotata](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
**2. Definire quali attributi verranno esclusi dalle firme**
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presumerà che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**3. [Crea un portachiavi](keyrings.md)**
L'esempio seguente crea un [AWS KMS portachiavi](use-kms-keyring.md). Il AWS KMS portachiavi utilizza la crittografia simmetrica o RSA asimmetrica per generare, crittografare e AWS KMS keys decrittografare le chiavi di dati.
Questo esempio utilizza per creare un portachiavi con una chiave KMS di crittografia `CreateMrkMultiKeyring` simmetrica. AWS KMS Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.
```
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. Definire la configurazione di crittografia delle tabelle DynamoDB **
L'esempio seguente definisce una `tableConfigs` mappa che rappresenta la configurazione di crittografia per questa tabella DynamoDB.
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-java-using.md#logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB](ddb-java-using.md#ddb-config-encrypt).
È necessario specificare `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` come override in testo semplice. Questa politica continua a leggere e scrivere elementi in testo non crittografato, legge gli elementi crittografati e prepara il client alla scrittura di elementi crittografati.
```
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. Creazione del `DynamoDbEncryptionInterceptor`**
**L'esempio seguente crea l'`DynamoDbEncryptionInterceptor`utilizzo del dal passaggio 3. `tableConfigs`**
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
## Fase 2: Scrivere elementi crittografati e firmati
Aggiorna la politica del testo in chiaro nella tua `DynamoDbEncryptionInterceptor` configurazione per consentire al client di scrivere elementi crittografati e firmati. **Dopo aver implementato la seguente modifica, il client crittograferà e firmerà i nuovi elementi in base alle azioni degli attributi configurate nel passaggio 1.** Il client sarà in grado di leggere elementi in testo semplice e elementi crittografati e firmati.
Prima di procedere alla [Fase 3](#ddb-java-add-step3), è necessario crittografare e firmare tutti gli elementi di testo in chiaro esistenti nella tabella. Non è possibile eseguire alcuna metrica o query per crittografare rapidamente gli elementi di testo in chiaro esistenti. Utilizzate il processo più adatto al vostro sistema. Ad esempio, è possibile utilizzare un processo asincrono che scansiona lentamente la tabella e quindi riscrive gli elementi utilizzando le azioni degli attributi e la configurazione di crittografia definite. Per identificare gli elementi di testo in chiaro nella tabella, consigliamo di cercare tutti gli elementi che non contengono gli `aws_dbe_foot` attributi `aws_dbe_head` e che AWS Database Encryption SDK aggiunge agli elementi quando sono crittografati e firmati.
**L'esempio seguente aggiorna la configurazione di crittografia della tabella dal passaggio 1.** È necessario aggiornare l'override del testo in chiaro con. `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` Questo criterio continua a leggere gli elementi di testo in chiaro, ma legge e scrive anche gli elementi crittografati. Creane uno nuovo `DynamoDbEncryptionInterceptor` utilizzando quello aggiornato. `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);
```
## Passaggio 3: Leggi solo gli elementi crittografati e firmati
Dopo aver crittografato e firmato tutti gli articoli, aggiorna l'override del testo in chiaro nella `DynamoDbEncryptionInterceptor` configurazione per consentire al client di leggere e scrivere solo gli elementi crittografati e firmati. **Dopo aver implementato la seguente modifica, il client crittograferà e firmerà i nuovi elementi in base alle azioni degli attributi configurate nel passaggio 1.** Il client sarà in grado di leggere solo gli elementi crittografati e firmati.
L'esempio seguente aggiorna la configurazione di crittografia delle tabelle dal **passaggio 2**. È possibile aggiornare l'override del testo in chiaro con `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` o rimuovere la politica del testo in chiaro dalla configurazione. Per impostazione predefinita, il client legge e scrive solo elementi crittografati e firmati. Creane uno nuovo `DynamoDbEncryptionInterceptor` utilizzando quello aggiornato`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);
```
# Esegui la migrazione alla versione 3.x della libreria di crittografia lato client Java per DynamoDB
****
| |
| --- |
| La nostra libreria di crittografia lato client è stata rinominata AWS Database Encryption SDK. Questa guida per sviluppatori fornisce ancora informazioni sul [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Versione 3. *x* della libreria di crittografia lato client Java per DynamoDB è una riscrittura importante della 2. *x* codice base. Include molti aggiornamenti, come un nuovo formato di dati strutturati, un supporto multitenancy migliorato, modifiche dello schema senza interruzioni e supporto per la crittografia ricercabile. Questo argomento fornisce indicazioni su come migrare il codice alla versione 3. *x.*
## Migrazione dalla versione 1.x alla 2.x
Migrare alla versione 2. *x* prima di migrare alla versione 3. *x.* Versione 2. *x* ha cambiato il simbolo del provider più recente da `MostRecentProvider` a`CachingMostRecentProvider`. Se attualmente utilizzi la versione 1. *x* della libreria di crittografia lato client Java per DynamoDB con il `MostRecentProvider` simbolo, è necessario aggiornare il nome del simbolo nel codice su. `CachingMostRecentProvider` Per ulteriori informazioni, consulta [Updates to the](most-recent-provider.md#mrp-versions) Most Recent Provider.
## Migrazione dalla versione 2.x alla 3.x
Le seguenti procedure descrivono come migrare il codice dalla versione 2. *x* alla versione 3. *x* della libreria di crittografia lato client Java per DynamoDB.
### Passaggio 1. Preparati a leggere gli articoli nel nuovo formato
Completa i seguenti passaggi per preparare il client AWS Database Encryption SDK alla lettura degli elementi nel nuovo formato. Dopo aver implementato le seguenti modifiche, il client continuerà a comportarsi nello stesso modo in cui si comportava nella versione 2. *x.* Il tuo client continuerà a leggere e scrivere elementi nella versione 2. formato *x*, ma queste modifiche preparano il client a [leggere gli elementi nel nuovo formato](#ddb-java-migrate-step2).
**Aggiorna il tuo AWS SDK per Java alla versione 2.x**
Versione 3. *x* [della libreria di crittografia lato client Java per DynamoDB richiede DynamoDB Enhanced Client.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) Il DynamoDB Enhanced Client sostituisce il DBMapper Dynamo utilizzato [nelle versioni precedenti](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html). Per utilizzare il client avanzato, è necessario utilizzare il. AWS SDK for Java 2.x
Segui le istruzioni per la [migrazione dalla versione 1.x alla 2.x di](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html). AWS SDK per Java
Per ulteriori informazioni sui AWS SDK for Java 2.x moduli richiesti, vedere. [Prerequisiti](ddb-java.md#ddb-java-prerequisites)
**Configura il tuo client per leggere gli elementi crittografati dalle versioni precedenti**
Le seguenti procedure forniscono una panoramica dei passaggi illustrati nell'esempio di codice riportato di seguito.
1. Crea un [portachiavi.](keyrings.md)
I portachiavi e [i gestori di materiali crittografici](concepts.md#crypt-materials-manager) sostituiscono i fornitori di materiali crittografici utilizzati nelle versioni precedenti della libreria di crittografia lato client Java per DynamoDB.
**Importante**
Le chiavi di wrapping specificate durante la creazione di un portachiavi devono essere le stesse chiavi di wrapping utilizzate con il fornitore di materiali crittografici nella versione 2. *x.*
1. Crea uno schema tabellare sulla tua classe annotata.
Questo passaggio definisce le azioni degli attributi che verranno utilizzate quando inizierai a scrivere elementi nel nuovo formato.
*Per indicazioni sull'uso del nuovo DynamoDB Enhanced Client, consulta [Generate a nella AWS SDK per Java Developer `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) Guide.*
L'esempio seguente presuppone che tu abbia aggiornato la tua classe annotata dalla versione 2. *x* utilizzando le nuove annotazioni sulle azioni degli attributi. Per ulteriori indicazioni sull'annotazione delle azioni relative agli attributi, vedere. [Utilizza una classe di dati annotata](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
**Nota**
Se si specificano degli `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributi, devono esserlo anche gli attributi di partizione e ordinamento. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` [Per un esempio che mostra le annotazioni utilizzate per definire`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, vedete 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. Definire quali [attributi sono esclusi dalla firma](ddb-java-using.md#allowed-unauth).
1. Configura una mappa esplicita delle azioni degli attributi configurate nella classe modellata della versione 2.x.
Questo passaggio definisce le azioni degli attributi utilizzate per scrivere gli elementi nel vecchio formato.
1. Configura quello `DynamoDBEncryptor` che hai usato nella versione 2. *x* della libreria di crittografia lato client Java per DynamoDB.
1. Configura il comportamento precedente.
1. Creare un `DynamoDbEncryptionInterceptor`.
1. Crea un nuovo client AWS SDK DynamoDB.
1. Crea `DynamoDBEnhancedClient` e crea una tabella con la tua classe modellata.
Per ulteriori informazioni sul DynamoDB Enhanced Client, [consulta creare un](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) client avanzato.
```
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);
}
}
```
### Passaggio 2. Scrivi gli elementi nel nuovo formato
Dopo aver distribuito le modifiche dal Passaggio 1 a tutti i lettori, completa i passaggi seguenti per configurare il client AWS Database Encryption SDK per scrivere elementi nel nuovo formato. Dopo aver implementato le seguenti modifiche, il client continuerà a leggere gli elementi nel vecchio formato e inizierà a scrivere e leggere gli elementi nel nuovo formato.
Le seguenti procedure forniscono una panoramica dei passaggi illustrati nell'esempio di codice riportato di seguito.
1. Continua a configurare il portachiavi, lo schema della tabella`allowedUnsignedAttributes`, le azioni degli attributi legacy e `DynamoDBEncryptor` come hai fatto nel [**passaggio**](#ddb-java-migrate-step1) 1.
1. Aggiorna il tuo comportamento precedente per scrivere solo nuovi elementi utilizzando il nuovo formato.
1. Creazione di una `DynamoDbEncryptionInterceptor `
1. Crea un nuovo client AWS SDK DynamoDB.
1. Crea `DynamoDBEnhancedClient` e crea una tabella con la tua classe modellata.
Per ulteriori informazioni sul DynamoDB Enhanced Client, [consulta creare un](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) client avanzato.
```
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);
}
}
```
[Dopo aver implementato le modifiche della Fase 2, è necessario crittografare nuovamente tutti i vecchi elementi della tabella con il nuovo formato prima di poter continuare con la Fase 3.](#ddb-java-migrate-step3) Non è possibile eseguire alcuna metrica o query per crittografare rapidamente gli elementi esistenti. Utilizzate il processo più adatto al vostro sistema. Ad esempio, è possibile utilizzare un processo asincrono che scansiona lentamente la tabella e quindi riscrive gli elementi utilizzando le nuove azioni degli attributi e la configurazione di crittografia definite.
### Fase 3. Leggi e scrivi solo elementi nel nuovo formato
Dopo aver ricrittografato tutti gli elementi della tabella con il nuovo formato, puoi rimuovere il comportamento precedente dalla tua configurazione. Completa i seguenti passaggi per configurare il client in modo che legga e scriva solo elementi nel nuovo formato.
Le seguenti procedure forniscono una panoramica dei passaggi illustrati nell'esempio di codice riportato di seguito.
1. Continua a configurare il portachiavi, lo schema della tabella e `allowedUnsignedAttributes` come hai fatto nel [**passaggio**](#ddb-java-migrate-step1) 1. Rimuovi le azioni degli attributi precedenti `DynamoDBEncryptor` dalla tua configurazione.
1. Creare un `DynamoDbEncryptionInterceptor`.
1. Crea un nuovo client AWS SDK DynamoDB.
1. Crea `DynamoDBEnhancedClient` e crea una tabella con la tua classe modellata.
Per ulteriori informazioni sul DynamoDB Enhanced Client, [consulta creare un](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) client avanzato.
```
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
Questo argomento spiega come installare e utilizzare la versione 3. *x* della libreria di crittografia lato client.NET per DynamoDB. Per i dettagli sulla programmazione con AWS Database Encryption SDK per DynamoDB, consulta gli [esempi.NET nel](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/) aws-database-encryption-sdk repository -dynamodb su. GitHub
La libreria di crittografia lato client.NET per DynamoDB è destinata agli sviluppatori che scrivono applicazioni in C\$1 e altri linguaggi di programmazione.NET. ed è supportata su Windows, macOS e Linux.
Tutte le implementazioni del [linguaggio di programmazione](ddb-programming-languages.md) del AWS Database Encryption SDK per DynamoDB sono interoperabili. Tuttavia, non SDK per .NET supporta valori vuoti per i tipi di dati di elenchi o mappe. Ciò significa che se si utilizza la libreria di crittografia lato client Java per DynamoDB per scrivere un elemento che contiene valori vuoti per un tipo di dati di elenco o mappa, non è possibile decrittografare e leggere tale elemento utilizzando la libreria di crittografia lato client.NET per DynamoDB.
**Topics**
+ [Installazione](#ddb-net-install)
+ [Debug](#ddb-net-debugging)
+ [Utilizzo del client.NET](ddb-net-using.md)
+ [esempi.NET](ddb-net-examples.md)
+ [Aggiungi la versione 3.x a una tabella esistente](ddb-net-config-existing-table.md)
## Installazione della libreria di crittografia lato client.NET per DynamoDB
[La libreria di crittografia lato client.NET per DynamoDB è disponibile come AWS.Cryptography. DbEncryptionSDK. DynamoDb](https://www.nuget.org/packages/AWS.Cryptography.DbEncryptionSDK.DynamoDb/)pacchetto in NuGet. Per informazioni dettagliate sull'installazione e la creazione della libreria, consultate il [file.NET README.md](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/DynamoDbEncryption/runtimes/net/README.md) nel repository -dynamodb. aws-database-encryption-sdk La libreria di crittografia lato client.NET per DynamoDB richiede le chiavi SDK per .NET anche se non si utilizzano (). AWS Key Management Service AWS KMS SDK per .NET Viene installato con il pacchetto. NuGet
Versione 3. *x* della libreria di crittografia lato client.NET per DynamoDB supporta .NET 6.0 e.NET Framework net48 e versioni successive.
## Esecuzione del debug con.NET
La libreria di crittografia lato client.NET per DynamoDB non genera alcun registro. Le eccezioni nella libreria di crittografia lato client.NET per DynamoDB generano un messaggio di eccezione, ma nessuna traccia dello stack.
Per aiutarti a eseguire il debug, assicurati di abilitare l'accesso a. SDK per .NET I log e i messaggi di errore di SDK per .NET possono aiutarti a distinguere gli errori derivanti SDK per .NET da quelli presenti nella libreria di crittografia lato client.NET per DynamoDB. *Per informazioni sulla SDK per .NET registrazione, consulta la Guida per gli sviluppatori. [AWSLogging](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-config-other.html#config-setting-awslogging)AWS SDK per .NET * (Per vedere l'argomento, espandi la sezione **Apri per visualizzare il contenuto di.NET Framework**).
# Utilizzo della libreria di crittografia lato client.NET per DynamoDB
Questo argomento spiega alcune delle funzioni e delle classi di supporto della versione 3. *x* della libreria di crittografia lato client.NET per DynamoDB.
Per i dettagli sulla programmazione con la libreria di crittografia lato client.NET per DynamoDB, consulta gli [esempi.NET](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/) nel repository -dynamodb su. aws-database-encryption-sdk GitHub
**Topics**
+ [Componenti di crittografia dell'item](#ddb-net-item-encryptors)
+ [Operazioni di attributo](#ddb-net-attribute-actions)
+ [Configurazione della crittografia](#ddb-net-config-encrypt)
+ [Aggiornamento degli elementi](#ddb-net-update-items)
## Componenti di crittografia dell'item
Fondamentalmente, il AWS Database Encryption SDK per DynamoDB è un cifratore di elementi. È possibile utilizzare la versione 3. *x* della libreria di crittografia lato client.NET per DynamoDB per crittografare, firmare, verificare e decrittografare gli elementi della tabella DynamoDB nei seguenti modi.
**L'SDK di crittografia del AWS database di basso livello per l'API DynamoDB**
È possibile utilizzare la [configurazione di crittografia delle tabelle](#ddb-net-config-encrypt) per creare un client DynamoDB che crittografa e firma automaticamente gli elementi lato client con le richieste DynamoDB. `PutItem` [https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/dynamodb-intro.html#dynamodb-intro-apis-document](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/dynamodb-intro.html#dynamodb-intro-apis-document)
[È necessario utilizzare l'API AWS Database Encryption SDK di basso livello per DynamoDB per utilizzare la crittografia ricercabile.](searchable-encryption.md)
**Il livello inferiore `DynamoDbItemEncryptor`**
Il livello inferiore crittografa e firma o decrittografa e verifica `DynamoDbItemEncryptor` direttamente gli elementi della tabella senza chiamare DynamoDB. Non crea DynamoDB o `PutItem` richieste`GetItem`. Ad esempio, puoi utilizzare il livello inferiore per `DynamoDbItemEncryptor` decrittografare e verificare direttamente un elemento DynamoDB che hai già recuperato. Se si utilizza il livello inferiore`DynamoDbItemEncryptor`, si consiglia di utilizzare il [modello di programmazione di basso livello](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/dynamodb-intro.html#dynamodb-intro-apis-low-level) SDK per .NET fornito per comunicare con DynamoDB.
[Il livello inferiore non supporta la crittografia ricercabile`DynamoDbItemEncryptor`.](searchable-encryption.md)
## Azioni relative agli attributi nel AWS Database Encryption SDK per DynamoDB
[Le azioni relative](concepts.md#crypt-actions) agli attributi determinano quali valori degli attributi sono crittografati e firmati, quali sono solo firmati, quali sono firmati e inclusi nel contesto di crittografia e quali vengono ignorati.
Per specificare le azioni relative agli attributi con il client.NET, definisci manualmente le azioni relative agli attributi utilizzando un modello a oggetti. Specificate le azioni relative agli attributi creando un `Dictionary` oggetto in cui le coppie nome-valore rappresentano i nomi degli attributi e le azioni specificate.
Specificate `ENCRYPT_AND_SIGN` di crittografare e firmare un attributo. `SIGN_ONLY`Specificare di firmare, ma non crittografare, un attributo. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`Specificare di firmare un attributo e di includerlo nel contesto di crittografia. Non è possibile crittografare un attributo senza firmarlo. `DO_NOTHING`Specificare di ignorare un attributo.
Gli attributi di partizione e ordinamento devono essere `SIGN_ONLY` o`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se si definiscono gli attributi come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, allora anche gli attributi di partizione e ordinamento devono essere uguali. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
**Nota**
Dopo aver definito le azioni relative agli attributi, è necessario definire quali attributi sono esclusi dalle firme. Per semplificare l'aggiunta di nuovi attributi non firmati in futuro, consigliamo di scegliere un prefisso distinto (ad esempio "`:`«) per identificare gli attributi non firmati. Includi questo prefisso nel nome dell'attributo per tutti gli attributi contrassegnati durante `DO_NOTHING` la definizione dello schema DynamoDB e delle azioni degli attributi.
Il seguente modello a oggetti mostra come specificare `ENCRYPT_AND_SIGN` `SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, e `DO_NOTHING` attribuire azioni con il client.NET. Questo esempio utilizza il prefisso "`:`" per identificare `DO_NOTHING` gli attributi.
**Nota**
Per utilizzare l'azione `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` crittografica, è necessario utilizzare la versione 3.3 o successiva di AWS Database Encryption SDK. Distribuisci la nuova versione a tutti i lettori prima di [aggiornare il modello di dati](ddb-update-data-model.md) per includere. `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
};
```
## Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB
Quando si utilizza AWS Database Encryption SDK, è necessario definire in modo esplicito una configurazione di crittografia per la tabella DynamoDB. I valori richiesti nella configurazione di crittografia dipendono dal fatto che le azioni degli attributi siano state definite manualmente o con una classe di dati annotata.
Il seguente frammento definisce una configurazione di crittografia delle tabelle DynamoDB utilizzando l'API AWS Database Encryption SDK di basso livello per DynamoDB e gli attributi non firmati consentiti definiti da un prefisso 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 della tabella logica**
Un nome di tabella logica per la tabella DynamoDB.
Il nome della tabella logica è associato crittograficamente a tutti i dati memorizzati nella tabella per semplificare le operazioni di ripristino di DynamoDB. Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. È necessario specificare sempre lo stesso nome di tabella logica. Affinché la decrittografia abbia esito positivo, il nome della tabella logica deve corrispondere al nome specificato nella crittografia. Nel caso in cui il nome della tabella DynamoDB cambi dopo il [ripristino della tabella DynamoDB da un backup, il nome della tabella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) logica assicura che l'operazione di decrittografia riconosca ancora la tabella.
**Attributi non firmati consentiti**
Gli attributi contrassegnati `DO_NOTHING` nelle azioni relative agli attributi.
Gli attributi non firmati consentiti indicano al client quali attributi sono esclusi dalle firme. Il client presume che tutti gli altri attributi siano inclusi nella firma. Quindi, durante la decrittografia di un record, il client determina quali attributi deve verificare e quali ignorare tra gli attributi non firmati consentiti specificati. Non è possibile rimuovere un attributo dagli attributi non firmati consentiti.
È possibile definire gli attributi non firmati consentiti in modo esplicito creando un array che elenca tutti gli attributi. `DO_NOTHING` È inoltre possibile specificare un prefisso distinto quando si assegnano nomi `DO_NOTHING` agli attributi e utilizzare il prefisso per indicare al client quali attributi non sono firmati. Consigliamo vivamente di specificare un prefisso distinto perché semplifica il processo di aggiunta di un nuovo `DO_NOTHING` attributo in futuro. Per ulteriori informazioni, consulta [Aggiornamento del modello di dati](ddb-update-data-model.md).
Se non si specifica un prefisso per tutti gli `DO_NOTHING` attributi, è possibile configurare un `allowedUnsignedAttributes` array che elenchi in modo esplicito tutti gli attributi che il client dovrebbe aspettarsi che non siano firmati quando li incontra durante la decrittografia. È necessario definire in modo esplicito gli attributi non firmati consentiti solo se assolutamente necessario.
**Configurazione della ricerca (opzionale)**
`SearchConfig`definisce la versione del [beacon](using-beacons.md#beacon-version).
[È `SearchConfig` necessario specificare il per utilizzare la [crittografia ricercabile](searchable-encryption.md) o i beacon firmati.](configure.md#signed-beacons)
**Algorithm Suite (opzionale)**
`algorithmSuiteId`Definisce la suite di algoritmi utilizzata da AWS Database Encryption SDK.
A meno che non si specifichi esplicitamente una suite di algoritmi alternativa, AWS Database Encryption SDK utilizza la suite di algoritmi [predefinita](supported-algorithms.md#recommended-algorithms). [La suite di algoritmi predefinita utilizza l'algoritmo AES-GCM con derivazione delle chiavi, firme [digitali](concepts.md#digital-sigs) e impegno delle chiavi.](concepts.md#key-commitment) Sebbene la suite di algoritmi predefinita sia probabilmente adatta alla maggior parte delle applicazioni, è possibile scegliere una suite di algoritmi alternativa. Ad esempio, alcuni modelli di fiducia sarebbero soddisfatti da una suite di algoritmi senza firme digitali. Per informazioni sulle suite di algoritmi supportate da AWS Database Encryption SDK, consulta. [Suite di algoritmi supportate nel AWS Database Encryption SDK](supported-algorithms.md)
Per selezionare la [suite di algoritmi AES-GCM senza firme digitali ECDSA](supported-algorithms.md#other-algorithms), includi il seguente frammento nella configurazione di crittografia delle tabelle.
```
AlgorithmSuiteId = DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384
```
## Aggiornamento degli AWS elementi con Database Encryption SDK
Il AWS Database Encryption SDK non supporta [ddb: UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) per gli elementi che includono attributi crittografati o firmati. Per aggiornare un attributo crittografato o firmato, è necessario utilizzare [ddb](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html):. PutItem Quando specifichi la stessa chiave primaria di un elemento esistente nella tua `PutItem` richiesta, il nuovo elemento sostituisce completamente l'elemento esistente. Puoi anche usare [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) per cancellare e sostituire tutti gli attributi al momento del salvataggio dopo aver aggiornato i tuoi articoli.
# esempi.NET
Gli esempi seguenti mostrano come utilizzare la libreria di crittografia lato client.NET per DynamoDB per proteggere gli elementi della tabella nell'applicazione. Per trovare altri esempi (e contribuire con i tuoi), consulta gli [esempi.NET](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/net/src) nel repository -dynamodb su. aws-database-encryption-sdk GitHub
Gli esempi seguenti mostrano come configurare la libreria di crittografia lato client.NET per DynamoDB in una nuova tabella Amazon DynamoDB non popolata. Se desideri configurare le tabelle Amazon DynamoDB esistenti per la crittografia lato client, consulta. [Aggiungi la versione 3.x a una tabella esistente](ddb-net-config-existing-table.md)
**Topics**
+ [Utilizzo dell'SDK di basso livello AWS Database Encryption per DynamoDB API](#ddb-net-lowlevel-API-example)
+ [Utilizzo del livello inferiore `DynamoDbItemEncryptor`](#ddb-net-itemencryptor)
## Utilizzo dell'SDK di basso livello AWS Database Encryption per DynamoDB API
L'esempio seguente mostra come utilizzare l'API AWS Database Encryption SDK di basso livello per DynamoDB con un [AWS KMS portachiavi](use-kms-keyring.md) per crittografare e firmare automaticamente gli elementi lato client con le richieste DynamoDB. `PutItem`
Puoi utilizzare qualsiasi [portachiavi supportato, ma ti consigliamo di utilizzare uno dei portachiavi](keyrings.md) quando possibile. AWS KMS
**[Guarda l'esempio di codice completo: .cs BasicPutGetExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/BasicPutGetExample.cs)**
**Fase 1: Creare il portachiavi AWS KMS **
L'esempio seguente utilizza la creazione `CreateAwsKmsMrkMultiKeyring` di un AWS KMS portachiavi con una chiave KMS di crittografia simmetrica. Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsMrkMultiKeyringInput { Generator = kmsKeyId };
var kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Passaggio 2: configura le azioni relative agli attributi**
L'esempio seguente definisce un `attributeActionsOnEncrypt` dizionario che rappresenta [azioni di esempio relative agli attributi](concepts.md#crypt-actions) per un elemento della tabella.
L'esempio seguente non definisce alcun attributo come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se si specifica un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo, devono esserlo `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` anche gli attributi di partizione e ordinamento.
```
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
};
```
**Fase 3: Definire quali attributi sono esclusi dalle firme**
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presuppone che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-net-using.md#net-allowed-unauth).
```
const String unsignAttrPrefix = ":";
```
**Fase 4: Definire la configurazione di crittografia delle tabelle DynamoDB**
L'esempio seguente definisce una `tableConfigs` mappa che rappresenta la configurazione di crittografia per questa tabella DynamoDB.
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-net-using.md#net-logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB](ddb-net-using.md#ddb-net-config-encrypt).
Per utilizzare la [crittografia ricercabile](searchable-encryption.md) o [i beacon firmati](configure.md#signed-beacons), è necessario includerli anche nella configurazione di crittografia. [`SearchConfig`](ddb-java-using.md#ddb-search-config)
```
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);
```
**Fase 5: Creare un nuovo client AWS SDK DynamoDB**
**L'esempio seguente crea un nuovo client AWS SDK DynamoDB utilizzando `TableEncryptionConfigs` lo Step 4.**
```
var ddb = new Client.DynamoDbClient(
new DynamoDbTablesEncryptionConfig { TableEncryptionConfigs = tableConfigs });
```
**Fase 6: Crittografare e firmare un elemento della tabella DynamoDB**
L'esempio seguente definisce un `item` dizionario che rappresenta un elemento di tabella di esempio e inserisce l'elemento nella tabella DynamoDB. L'elemento viene crittografato e firmato lato client prima di essere inviato a 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);
```
## Utilizzo del livello inferiore `DynamoDbItemEncryptor`
L'esempio seguente mostra come utilizzare il livello inferiore `DynamoDbItemEncryptor` con un [AWS KMS portachiavi](use-kms-keyring.md) per crittografare e firmare direttamente gli elementi della tabella. Non `DynamoDbItemEncryptor` inserisce l'elemento nella tabella DynamoDB.
Puoi utilizzare qualsiasi [portachiavi](keyrings.md) supportato con DynamoDB Enhanced Client, ma consigliamo di utilizzare uno dei AWS KMS portachiavi quando possibile.
**Nota**
[Il livello inferiore `DynamoDbItemEncryptor` non supporta la crittografia ricercabile.](searchable-encryption.md) Utilizza l'API AWS Database Encryption SDK di basso livello per DynamoDB per utilizzare la crittografia ricercabile.
**[Guarda l'esempio di codice completo: .cs ItemEncryptDecryptExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/itemencryptor/ItemEncryptDecryptExample.cs)**
**Fase 1: Creare il portachiavi AWS KMS **
L'esempio seguente utilizza la creazione `CreateAwsKmsMrkMultiKeyring` di un AWS KMS portachiavi con una chiave KMS di crittografia simmetrica. Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsMrkMultiKeyringInput { Generator = kmsKeyId };
var kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Passaggio 2: configura le azioni relative agli attributi**
L'esempio seguente definisce un `attributeActionsOnEncrypt` dizionario che rappresenta [azioni di esempio relative agli attributi](concepts.md#crypt-actions) per un elemento della tabella.
L'esempio seguente non definisce alcun attributo come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se si specifica un `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributo, devono esserlo `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` anche gli attributi di partizione e ordinamento.
```
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
};
```
**Fase 3: Definire quali attributi sono esclusi dalle firme**
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presuppone che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-net-using.md#net-allowed-unauth).
```
String unsignAttrPrefix = ":";
```
**Fase 4: Definire la configurazione `DynamoDbItemEncryptor`**
L'esempio seguente definisce la configurazione per`DynamoDbItemEncryptor`.
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-net-using.md#net-logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. Per ulteriori informazioni, consulta [Configurazione della crittografia nel AWS Database Encryption SDK per 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
};
```
**Fase 5: Creare il `DynamoDbItemEncryptor`**
L'esempio seguente ne crea uno nuovo `DynamoDbItemEncryptor` utilizzando il `config` tratto dal **passaggio 4**.
```
var itemEncryptor = new DynamoDbItemEncryptor(config);
```
**Fase 6: Crittografare e firmare direttamente un elemento della tabella**
L'esempio seguente crittografa e firma direttamente un elemento utilizzando il. `DynamoDbItemEncryptor` Non `DynamoDbItemEncryptor` inserisce l'elemento nella tabella 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;
```
# Configurare una tabella DynamoDB esistente per utilizzare AWS il Database Encryption SDK per DynamoDB
Con la versione 3. *x* della libreria di crittografia lato client.NET per DynamoDB, puoi configurare le tabelle Amazon DynamoDB esistenti per la crittografia lato client. Questo argomento fornisce indicazioni sui tre passaggi da eseguire per aggiungere la versione 3. *x* su una tabella DynamoDB esistente e popolata.
## Fase 1: Prepararsi a leggere e scrivere elementi crittografati
Completa i seguenti passaggi per preparare il client AWS Database Encryption SDK per leggere e scrivere elementi crittografati. Dopo aver implementato le seguenti modifiche, il client continuerà a leggere e scrivere elementi in testo non crittografato. Non crittograferà né firmerà i nuovi elementi scritti nella tabella, ma sarà in grado di decrittografare gli elementi crittografati non appena vengono visualizzati. Queste modifiche preparano il client a iniziare a [crittografare](#ddb-net-add-step2) nuovi elementi. Le seguenti modifiche devono essere implementate su ciascun lettore prima di procedere al passaggio successivo.
**1. Definite le azioni relative agli [attributi](concepts.md#crypt-actions)**
Create un modello a oggetti per definire quali valori degli attributi verranno crittografati e firmati, quali verranno solo firmati e quali ignorati.
Per impostazione predefinita, gli attributi della chiave primaria sono firmati ma non crittografati (`SIGN_ONLY`) e tutti gli altri attributi sono crittografati e firmati (`ENCRYPT_AND_SIGN`).
`ENCRYPT_AND_SIGN`Specificare di crittografare e firmare un attributo. `SIGN_ONLY`Specificare di firmare, ma non crittografare, un attributo. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`Specificare se firmare e attribuire e includerlo nel contesto di crittografia. Non è possibile crittografare un attributo senza firmarlo. `DO_NOTHING`Specificare di ignorare un attributo. Per ulteriori informazioni, consulta [Azioni relative agli attributi nel AWS Database Encryption SDK per DynamoDB](ddb-net-using.md#ddb-net-attribute-actions).
Se specificate degli `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` attributi, devono esserlo `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` anche gli attributi di partizione e ordinamento.
```
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. Definite quali attributi verranno esclusi dalle firme**
L'esempio seguente presuppone che tutti `DO_NOTHING` gli attributi condividano il prefisso distinto "`:`«e utilizza il prefisso per definire gli attributi non firmati consentiti. Il client presumerà che qualsiasi nome di attributo con il prefisso "`:`" sia escluso dalle firme. Per ulteriori informazioni, consulta [Allowed unsigned attributes](ddb-net-using.md#net-allowed-unauth).
```
const String unsignAttrPrefix = ":";
```
**3. [Crea un portachiavi](keyrings.md)**
L'esempio seguente crea un [AWS KMS portachiavi](use-kms-keyring.md). Il AWS KMS portachiavi utilizza la crittografia simmetrica o RSA asimmetrica per generare, crittografare e AWS KMS keys decrittografare le chiavi di dati.
Questo esempio utilizza per creare un portachiavi con una chiave KMS di crittografia `CreateMrkMultiKeyring` simmetrica. AWS KMS Il `CreateAwsKmsMrkMultiKeyring` metodo garantisce che il portachiavi gestisca correttamente sia le chiavi a regione singola che quelle a più regioni.
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsMrkMultiKeyringInput { Generator = kmsKeyId };
var kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**4. Definire la configurazione di crittografia delle tabelle DynamoDB **
L'esempio seguente definisce una `tableConfigs` mappa che rappresenta la configurazione di crittografia per questa tabella DynamoDB.
[Questo esempio specifica il nome della tabella DynamoDB come nome della tabella logica.](ddb-net-using.md#net-logical-table-name) Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia.
È necessario specificare `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` come override in testo semplice. Questa politica continua a leggere e scrivere elementi in testo non crittografato, legge elementi crittografati e prepara il client a scrivere elementi crittografati.
Per ulteriori informazioni sui valori inclusi nella configurazione di crittografia delle tabelle, vedere. [Configurazione della crittografia nel AWS Database Encryption SDK per 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. Crea un nuovo client AWS SDK DynamoDB**
**L'esempio seguente crea un nuovo client AWS SDK DynamoDB utilizzando `TableEncryptionConfigs` lo Step 4.**
```
var ddb = new Client.DynamoDbClient(
new DynamoDbTablesEncryptionConfig { TableEncryptionConfigs = tableConfigs });
```
## Fase 2: Scrivere elementi crittografati e firmati
Aggiorna la politica di testo in chiaro nella configurazione di crittografia delle tabelle per consentire al client di scrivere elementi crittografati e firmati. **Dopo aver implementato la seguente modifica, il client crittograferà e firmerà i nuovi elementi in base alle azioni degli attributi configurate nel passaggio 1.** Il client sarà in grado di leggere elementi in testo semplice e elementi crittografati e firmati.
Prima di procedere alla [Fase 3](#ddb-net-add-step3), è necessario crittografare e firmare tutti gli elementi di testo in chiaro esistenti nella tabella. Non è possibile eseguire alcuna metrica o query per crittografare rapidamente gli elementi di testo in chiaro esistenti. Utilizzate il processo più adatto al vostro sistema. Ad esempio, è possibile utilizzare un processo asincrono che scansiona lentamente la tabella e quindi riscrive gli elementi utilizzando le azioni degli attributi e la configurazione di crittografia definite. Per identificare gli elementi di testo in chiaro nella tabella, consigliamo di cercare tutti gli elementi che non contengono gli `aws_dbe_foot` attributi `aws_dbe_head` e che AWS Database Encryption SDK aggiunge agli elementi quando sono crittografati e firmati.
**L'esempio seguente aggiorna la configurazione di crittografia della tabella dal passaggio 1.** È necessario aggiornare l'override del testo in chiaro con. `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` Questo criterio continua a leggere gli elementi di testo in chiaro, ma legge e scrive anche gli elementi crittografati. Crea un nuovo client AWS SDK DynamoDB utilizzando l'aggiornamento. `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);
```
## Passaggio 3: Leggi solo gli elementi crittografati e firmati
Dopo aver crittografato e firmato tutti gli elementi, aggiorna l'override del testo in chiaro nella configurazione di crittografia delle tabelle per consentire al client solo di leggere e scrivere elementi crittografati e firmati. **Dopo aver implementato la seguente modifica, il client crittograferà e firmerà i nuovi elementi in base alle azioni degli attributi configurate nel passaggio 1.** Il client sarà in grado di leggere solo gli elementi crittografati e firmati.
L'esempio seguente aggiorna la configurazione di crittografia delle tabelle dal **passaggio 2**. È possibile aggiornare l'override del testo in chiaro con `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` o rimuovere la politica del testo in chiaro dalla configurazione. Per impostazione predefinita, il client legge e scrive solo elementi crittografati e firmati. Crea un nuovo client AWS SDK DynamoDB utilizzando l'aggiornamento. `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
Questo argomento spiega come installare e utilizzare la versione 1. *x* della libreria di crittografia lato client Rust per DynamoDB. Per i dettagli sulla programmazione con AWS Database Encryption SDK per DynamoDB, consulta gli esempi di [Rust nel](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/) aws-database-encryption-sdk repository -dynamodb su. GitHub
Tutte le implementazioni del linguaggio di programmazione del AWS Database Encryption SDK per DynamoDB sono interoperabili.
**Topics**
+ [Prerequisiti](#ddb-rust-prerequisites)
+ [Installazione](#ddb-rust-install)
+ [Utilizzo del client Rust](ddb-rust-using.md)
## Prerequisiti
Prima di installare la libreria di crittografia lato client Rust per DynamoDB, assicurati di avere i seguenti prerequisiti.
**Installa Rust and Cargo**
Installa l'attuale versione stabile di [Rust](https://www.rust-lang.org/) usando [rustup](https://rustup.rs/).
Per ulteriori informazioni sul download e l'installazione di rustup, consulta [le procedure di installazione](https://doc.rust-lang.org/cargo/getting-started/installation.html) in The Cargo Book.
## Installazione
La libreria di crittografia lato client Rust per DynamoDB è disponibile come cassa su Crates.io. [aws-db-esdk](https://crates.io/crates/aws-db-esdk) [Per i dettagli sull'installazione e la creazione della libreria, consultate il file README.md nel repository -dynamodb.](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) aws-database-encryption-sdk GitHub
**Manualmente**
[Per installare la libreria di crittografia lato client Rust per DynamoDB, clona o scarica il repository -dynamodb. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
**Per installare la versione più recente**
Esegui il seguente comando Cargo nella directory del tuo progetto:
```
cargo add aws-db-esdk
```
Oppure aggiungi la seguente riga al tuo Cargo.toml:
```
aws-db-esdk = ""
```
# Utilizzo della libreria di crittografia lato client Rust per DynamoDB
Questo argomento spiega alcune delle funzioni e delle classi di supporto della versione 1. *x* della libreria di crittografia lato client Rust per DynamoDB.
Per i dettagli sulla programmazione con la libreria di crittografia lato client Rust per DynamoDB, consulta gli [esempi di Rust](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/) nel repository -dynamodb su. aws-database-encryption-sdk GitHub
**Topics**
+ [Componenti di crittografia dell'item](#ddb-rust-item-encryptors)
+ [Operazioni di attributo](#ddb-rust-attribute-actions)
+ [Configurazione della crittografia](#ddb-rust-config-encrypt)
+ [Aggiornamento degli elementi](#ddb-rust-update-items)
## Componenti di crittografia dell'item
Fondamentalmente, il AWS Database Encryption SDK per DynamoDB è un cifratore di elementi. È possibile utilizzare la versione 1. *x* della libreria di crittografia lato client Rust per DynamoDB per crittografare, firmare, verificare e decrittografare gli elementi della tabella DynamoDB nei seguenti modi.
**L'SDK di crittografia del AWS database di basso livello per l'API DynamoDB**
È possibile utilizzare la [configurazione di crittografia delle tabelle](#ddb-rust-config-encrypt) per creare un client DynamoDB che crittografa e firma automaticamente gli elementi lato client con le richieste DynamoDB. `PutItem`
[È necessario utilizzare l'API AWS Database Encryption SDK di basso livello per DynamoDB per utilizzare la crittografia ricercabile.](searchable-encryption.md)
[Per un esempio che dimostra come utilizzare l'SDK di basso livello di AWS Database Encryption SDK per DynamoDB, consulta basic\$1get\$1put\$1example.rs nel repository -dynamodb su.](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
**Il livello inferiore `DynamoDbItemEncryptor`**
Il livello inferiore crittografa e firma o decrittografa e verifica `DynamoDbItemEncryptor` direttamente gli elementi della tabella senza chiamare DynamoDB. Non crea DynamoDB o `PutItem` richieste`GetItem`. Ad esempio, puoi utilizzare il livello inferiore per `DynamoDbItemEncryptor` decrittografare e verificare direttamente un elemento DynamoDB che hai già recuperato.
[Il livello inferiore non supporta la crittografia ricercabile. `DynamoDbItemEncryptor`](searchable-encryption.md)
Per un esempio che dimostra come utilizzare il livello inferiore, consulta [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) nel repository `DynamoDbItemEncryptor` -dynamodb su. aws-database-encryption-sdk GitHub
## Azioni relative agli attributi nel AWS Database Encryption SDK per DynamoDB
[Le azioni relative](concepts.md#crypt-actions) agli attributi determinano quali valori degli attributi sono crittografati e firmati, quali sono solo firmati, quali sono firmati e inclusi nel contesto di crittografia e quali vengono ignorati.
Per specificare le azioni relative agli attributi con il client Rust, definisci manualmente le azioni relative agli attributi utilizzando un modello a oggetti. Specificate le azioni degli attributi creando un `HashMap` oggetto in cui le coppie nome-valore rappresentano i nomi degli attributi e le azioni specificate.
Specificate `ENCRYPT_AND_SIGN` di crittografare e firmare un attributo. `SIGN_ONLY`Specificare di firmare, ma non crittografare, un attributo. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`Specificare di firmare un attributo e di includerlo nel contesto di crittografia. Non è possibile crittografare un attributo senza firmarlo. `DO_NOTHING`Specificare di ignorare un attributo.
Gli attributi di partizione e ordinamento devono essere `SIGN_ONLY` o`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Se si definiscono gli attributi come`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, allora anche gli attributi di partizione e ordinamento devono essere uguali. `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
**Nota**
Dopo aver definito le azioni relative agli attributi, è necessario definire quali attributi sono esclusi dalle firme. Per semplificare l'aggiunta di nuovi attributi non firmati in futuro, consigliamo di scegliere un prefisso distinto (ad esempio "`:`«) per identificare gli attributi non firmati. Includi questo prefisso nel nome dell'attributo per tutti gli attributi contrassegnati durante `DO_NOTHING` la definizione dello schema DynamoDB e delle azioni degli attributi.
Il seguente modello a oggetti mostra come specificare`ENCRYPT_AND_SIGN`, `SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, e `DO_NOTHING` attribuire azioni con il client Rust. Questo esempio utilizza il prefisso "`:`" per identificare `DO_NOTHING` gli attributi.
```
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),
]);
```
## Configurazione della crittografia nel AWS Database Encryption SDK per DynamoDB
Quando si utilizza AWS Database Encryption SDK, è necessario definire in modo esplicito una configurazione di crittografia per la tabella DynamoDB. I valori richiesti nella configurazione di crittografia dipendono dal fatto che le azioni degli attributi siano state definite manualmente o con una classe di dati annotata.
Il seguente frammento definisce una configurazione di crittografia delle tabelle DynamoDB utilizzando l'API AWS Database Encryption SDK di basso livello per DynamoDB e gli attributi non firmati consentiti definiti da un prefisso 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 della tabella logica**
Un nome di tabella logica per la tabella DynamoDB.
Il nome della tabella logica è associato crittograficamente a tutti i dati memorizzati nella tabella per semplificare le operazioni di ripristino di DynamoDB. Consigliamo vivamente di specificare il nome della tabella DynamoDB come nome della tabella logica quando si definisce per la prima volta la configurazione di crittografia. È necessario specificare sempre lo stesso nome di tabella logica. Affinché la decrittografia abbia esito positivo, il nome della tabella logica deve corrispondere al nome specificato nella crittografia. Nel caso in cui il nome della tabella DynamoDB cambi dopo il [ripristino della tabella DynamoDB da un backup, il nome della tabella](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) logica assicura che l'operazione di decrittografia riconosca ancora la tabella.
**Attributi non firmati consentiti**
Gli attributi contrassegnati `DO_NOTHING` nelle azioni relative agli attributi.
Gli attributi non firmati consentiti indicano al client quali attributi sono esclusi dalle firme. Il client presume che tutti gli altri attributi siano inclusi nella firma. Quindi, durante la decrittografia di un record, il client determina quali attributi deve verificare e quali ignorare tra gli attributi non firmati consentiti specificati. Non è possibile rimuovere un attributo dagli attributi non firmati consentiti.
È possibile definire gli attributi non firmati consentiti in modo esplicito creando un array che elenca tutti gli attributi. `DO_NOTHING` È inoltre possibile specificare un prefisso distinto quando si assegnano nomi `DO_NOTHING` agli attributi e utilizzare il prefisso per indicare al client quali attributi non sono firmati. Consigliamo vivamente di specificare un prefisso distinto perché semplifica il processo di aggiunta di un nuovo `DO_NOTHING` attributo in futuro. Per ulteriori informazioni, consulta [Aggiornamento del modello di dati](ddb-update-data-model.md).
Se non si specifica un prefisso per tutti gli `DO_NOTHING` attributi, è possibile configurare un `allowedUnsignedAttributes` array che elenchi in modo esplicito tutti gli attributi che il client dovrebbe aspettarsi che non siano firmati quando li incontra durante la decrittografia. È necessario definire in modo esplicito gli attributi non firmati consentiti solo se assolutamente necessario.
**Configurazione della ricerca (opzionale)**
`SearchConfig`definisce la versione del [beacon](using-beacons.md#beacon-version).
[È `SearchConfig` necessario specificare il per utilizzare la [crittografia ricercabile](searchable-encryption.md) o i beacon firmati.](configure.md#signed-beacons)
**Algorithm Suite (opzionale)**
`algorithmSuiteId`Definisce la suite di algoritmi utilizzata da AWS Database Encryption SDK.
A meno che non si specifichi esplicitamente una suite di algoritmi alternativa, AWS Database Encryption SDK utilizza la suite di algoritmi [predefinita](supported-algorithms.md#recommended-algorithms). [La suite di algoritmi predefinita utilizza l'algoritmo AES-GCM con derivazione delle chiavi, firme [digitali](concepts.md#digital-sigs) e impegno delle chiavi.](concepts.md#key-commitment) Sebbene la suite di algoritmi predefinita sia probabilmente adatta alla maggior parte delle applicazioni, è possibile scegliere una suite di algoritmi alternativa. Ad esempio, alcuni modelli di fiducia sarebbero soddisfatti da una suite di algoritmi senza firme digitali. Per informazioni sulle suite di algoritmi supportate da AWS Database Encryption SDK, consulta. [Suite di algoritmi supportate nel AWS Database Encryption SDK](supported-algorithms.md)
Per selezionare la [suite di algoritmi AES-GCM senza firme digitali ECDSA](supported-algorithms.md#other-algorithms), includi il seguente frammento nella configurazione di crittografia delle tabelle.
```
.algorithm_suite_id(
DbeAlgorithmSuiteId::AlgAes256GcmHkdfSha512CommitKeyEcdsaP384SymsigHmacSha384,
)
```
## Aggiornamento degli AWS elementi con Database Encryption SDK
Il AWS Database Encryption SDK non supporta [ddb: UpdateItem](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) per gli elementi che includono attributi crittografati o firmati. Per aggiornare un attributo crittografato o firmato, è necessario utilizzare [ddb](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html):. PutItem Quando specifichi la stessa chiave primaria di un elemento esistente nella tua `PutItem` richiesta, il nuovo elemento sostituisce completamente l'elemento esistente.
# Client di crittografia DynamoDB legacy
Il 9 giugno 2023, la nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS Il AWS Database Encryption SDK continua a supportare le versioni precedenti di DynamoDB Encryption Client. Per ulteriori informazioni sulle diverse parti della libreria di crittografia lato client che sono state modificate con la ridenominazione, consulta. [Rinomina del client di crittografia Amazon DynamoDB](DDBEC-rename.md)
Per migrare alla versione più recente della libreria di crittografia lato client Java per DynamoDB, vedere. [Migrare alla versione 3.x](ddb-java-migrate.md)
**Topics**
+ [AWS Supporto della versione di Database Encryption SDK per DynamoDB](#legacy-support)
+ [Come funziona il client di crittografia DynamoDB](DDBEC-legacy-how-it-works.md)
+ [Concetti del client di crittografia Amazon DynamoDB](DDBEC-legacy-concepts.md)
+ [Fornitore di materiali crittografici](crypto-materials-providers.md)
+ [Linguaggi di programmazione disponibili per Amazon DynamoDB Encryption Client](programming-languages.md)
+ [Modifica del modello di dati](data-model.md)
+ [Risoluzione dei problemi nell'applicazione DynamoDB Encryption Client](troubleshooting.md)
## AWS Supporto della versione di Database Encryption SDK per DynamoDB
Gli argomenti del capitolo Legacy forniscono informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python.
La tabella seguente elenca le lingue e le versioni che supportano la crittografia lato client in Amazon DynamoDB.
| Linguaggio di programmazione | Versione | Fase del ciclo di vita della versione principale dell'SDK |
| --- | --- | --- |
| Java | Versioni 1. *x* | [End-of-Support fase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle), in vigore da luglio 2022 |
| Java | Versioni 2. *x* | [Disponibilità generale](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle) (GA) |
| Java | Versione 3. *x* | [Disponibilità generale](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle) (GA) |
| Python | Versioni 1. *x* | [End-of-Support fase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle), in vigore da luglio 2022 |
| Python | Versioni 2. *x* | [End-of-Support fase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle), in vigore da luglio 2022 |
| Python | Versioni 3. *x* | [Disponibilità generale](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle) (GA) |
# Come funziona il client di crittografia DynamoDB
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Il DynamoDB Encryption Client è progettato specificamente per proteggere i dati archiviati in DynamoDB. Le librerie includono implementazioni sicure che puoi estendere o utilizzare senza modificarle. Inoltre, la maggior parte degli elementi sono rappresentati da elementi astratti per consentirti di creare e utilizzare componenti personalizzati compatibili.
**Crittografia e firma degli item della tabella**
Alla base del DynamoDB Encryption Client c'è *uno strumento di crittografia degli elementi* che crittografa, firma, verifica e decrittografa gli elementi della tabella. Carica informazioni sugli elementi della tabella e istruzioni su quali item criptare e firmare. Ottiene i materiali di crittografia e le istruzioni su come utilizzarli da un [provider di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) da te selezionato e configurato.
Il seguente diagramma mostra una vista generale di questo processo:
![\[Crittografia e firma degli elementi nel client di crittografia DynamoDB\]](http://docs.aws.amazon.com/it_it/database-encryption-sdk/latest/devguide/images/arch-encrypt.png)
Per crittografare e firmare un elemento della tabella, il client di crittografia DynamoDB necessita di:
+ **Informazioni sulla tabella.** Ottiene informazioni sulla tabella da un contesto di [crittografia DynamoDB](concepts.md#encryption-context) fornito dall'utente. Alcuni helper ottengono le informazioni richieste da DynamoDB e creano automaticamente il contesto di crittografia DynamoDB.
**Nota**
*Il contesto di *crittografia DynamoDB* nel DynamoDB Encryption Client non è correlato al contesto di crittografia in () e in.* AWS Key Management Service AWS KMS AWS Encryption SDK
+ **Informazioni su quali attributi crittografare e firmare.** Ottiene queste informazioni dalle [operazioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) da te fornite.
+ **Materiali di crittografia, incluse le chiavi di crittografia e di firma.** Li ottiene da un [provider di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) da te selezionato e configurato.
+ **Istruzioni per la crittografia e la firma dell'item**. Il CMP aggiunge istruzioni per l'utilizzo dei materiali di crittografia, inclusi gli algoritmi di crittografia e firma, alla [descrizione dei materiali effettivi](DDBEC-legacy-concepts.md#legacy-material-description).
Il [componente di crittografia dell'item](DDBEC-legacy-concepts.md#item-encryptor) utilizza tutti questi elementi per crittografare e firmare l'item. Il componente di crittografia dell'item, inoltre, aggiunge due attributi all'item: un [attributo di descrizione del materiale](DDBEC-legacy-concepts.md#legacy-material-description), contenente le istruzioni per la crittografia e la firma (la descrizione dei materiali effettivi), e un attributo che contiene la firma. Puoi interagire direttamente con il componente di crittografia dell'item o utilizzare le funzionalità helper che interagiscono con il componente di crittografia dell'item per implementare un comportamento predefinito sicuro.
Il risultato è un item DynamoDB contenente dati crittografati e firmati.
**Verifica e decrittografia degli item della tabella**
Anche questi componenti operano insieme per verificare e decrittografare l'item, come mostrato nel diagramma riportato di seguito.
![\[Verifica e decrittografia degli elementi nel client di crittografia DynamoDB\]](http://docs.aws.amazon.com/it_it/database-encryption-sdk/latest/devguide/images/arch-decrypt.png)
Per verificare e decrittografare un elemento, il client di crittografia DynamoDB necessita degli stessi componenti, componenti con la stessa configurazione o componenti progettati appositamente per decrittografare gli elementi, come segue:
+ **Informazioni sulla tabella dal contesto** di crittografia [DynamoDB](concepts.md#encryption-context).
+ **Quali attributi verificare e decrittografare.** ottenute dalle [operazioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions).
+ **Materiali di decrittografia, incluse le chiavi di verifica e decrittografia**, ottenute dal [CMP](DDBEC-legacy-concepts.md#concept-material-provider) da te selezionato e configurato.
L'item crittografato non include alcun record del CMP che è stato utilizzato per crittografarlo. Devi fornire lo stesso CMP, un CMP con la stessa configurazione o un CMP che è stato designato per decrittografare gli item.
+ **Informazioni sui modi in cui l'item è stato crittografato e firmato**, inclusi gli algoritmi di crittografia e firma. Il client le ottiene dall'[attributo di descrizione del materiale](DDBEC-legacy-concepts.md#legacy-material-description) nell'item.
Il [componente di crittografia dell'item](DDBEC-legacy-concepts.md#item-encryptor) utilizza tutti questi elementi per verificare e decrittografare l'item. Inoltre, rimuove gli attributi di descrizione del materiale e di firma. Il risultato è un elemento DynamoDB in testo semplice.
# Concetti del client di crittografia Amazon DynamoDB
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Questo argomento spiega i concetti e la terminologia utilizzati in Amazon DynamoDB Encryption Client.
Per scoprire come interagiscono i componenti del DynamoDB Encryption Client, consulta. [Come funziona il client di crittografia DynamoDB](DDBEC-legacy-how-it-works.md)
**Topics**
+ [Provider di materiali crittografici](#concept-material-provider)
+ [Componenti di crittografia dell'item](#item-encryptor)
+ [Operazioni di attributo](#legacy-attribute-actions)
+ [Descrizione dei materiali](#legacy-material-description)
+ [Contesto di crittografia DynamoDB](#legacy-encryption-context)
+ [Archivio provider](#provider-store)
## Provider di materiali crittografici
*Quando si implementa il DynamoDB Encryption Client, una delle prime attività è [selezionare un fornitore di materiali crittografici](crypto-materials-providers.md) (CMP) (noto anche come fornitore di materiali di crittografia).* La scelta determina gran parte del processo di implementazione rimanente.
Un *CMP* raccoglie, assembla e restituisce i materiali crittografici che il [componente di crittografia dell'item](#item-encryptor) utilizza per crittografare e firmare gli item della tabella. Il CMP determina gli algoritmi di crittografia da utilizzare e come generare e proteggere le chiavi di crittografia e firma.
Il CMP interagisce con il componente di crittografia dell'item. Il componente di crittografia dell'item richiede i materiali di crittografia e decrittografia al CMP e il CMP li restituisce al componente di crittografia dell'item. Quindi, il componente di crittografia dell'item utilizza i materiali crittografici per crittografare e firmare l'item o per verificarlo e decrittografarlo.
Il CMP viene specificato quando si configura il client. È possibile creare una CMP personalizzata compatibile o utilizzare una delle tante presenti nella libreria. CMPs La maggior parte CMPs sono disponibili per più linguaggi di programmazione.
## Componenti di crittografia dell'item
L'*item encryptor* è un componente di livello inferiore che esegue operazioni crittografiche per il DynamoDB Encryptor Client. Richiede materiali crittografici a un [CMP](#concept-material-provider), quindi utilizza i materiali che il CMP restituisce per crittografare e firmare l'item della tabella o per verificarlo e decrittografarlo.
Puoi interagire direttamente con il componente di crittografia dell'item o utilizzare gli helper forniti dalla libreria. Ad esempio, il client di crittografia DynamoDB per Java include `AttributeEncryptor` una classe di supporto che è possibile utilizzare con, anziché interagire direttamente con `DynamoDBMapper` l'crittografo degli elementi. `DynamoDBEncryptor` La libreria Python include le classi helper `EncryptedTable`, `EncryptedClient` ed `EncryptedResource` che interagiscono con il componente di crittografia dell'item per te.
## Operazioni di attributo
Le *operazioni di attributo* comunicano al componente di crittografia dell'item quali operazioni effettuare su ciascun attributo dell'item.
È possibile utilizzare i seguenti valori per le operazioni di attributo:
+ Crittografa **e firma: crittografa il valore** dell'attributo. Includi l'attributo (nome e valore) nella firma dell'item.
+ **Solo firma**: include l'attributo nella firma dell'articolo.
+ **Non fare nulla**: non crittografare o firmare l'attributo.
Utilizza **Encrypt and sign (Crittografa e firma)** per tutti gli attributi in grado di memorizzare dati sensibili. Per gli attributi delle chiavi primarie (chiave di partizione e chiave di ordinamento), utilizza **Sign only (Firma soltanto)**. L'[attributo di descrizione del materiale](#legacy-material-description) e l'attributo di firma non sono firmati o crittografati. Non è necessario specificare operazioni di attributo per questi attributi.
Scegli attentamente le operazioni di attributo. In caso di dubbio, usa **Encrypt and sign (Crittografa e firma)**. Dopo aver utilizzato il DynamoDB Encryption Client per proteggere gli elementi della tabella, non è possibile modificare l'azione per un attributo senza rischiare un errore di convalida della firma. Per informazioni dettagliate, vedi [Modifica del modello di dati](data-model.md).
**avvertimento**
Non crittografare gli attributi che vengono usati per la chiave primaria. Devono rimanere in testo semplice in modo che DynamoDB possa trovare l'elemento senza eseguire una scansione completa della tabella.
Se il contesto di [crittografia DynamoDB](concepts.md#encryption-context) identifica gli attributi della chiave primaria, il client genererà un errore se si tenta di crittografarli.
La tecnica da utilizzare per specificare le operazioni di attributo è diversa per ogni linguaggio di programmazione. Potrebbe anche essere specifica per le classi helper che utilizzi.
Per ulteriori informazioni, consulta la documentazione relativa al tuo linguaggio di programmazione.
+ [Python](python-using.md#python-attribute-actions)
+ [Java](java-using.md#attribute-actions-java)
## Descrizione dei materiali
La *descrizione dei materiali* per un item della tabella crittografato comprende informazioni, come gli algoritmi di crittografia, sui modi in cui l'item della tabella viene crittografato e firmato. Il [CMP](#concept-material-provider) registra la descrizione dei materiali poiché assembla i materiali crittografici per la crittografia e la firma. Successivamente, quando deve assemblare i materiali crittografici per verificare e decrittografare l'item, utilizza la descrizione dei materiali come guida.
Nel DynamoDB Encryption Client, la descrizione del materiale si riferisce a tre elementi correlati:
**Descrizione dei materiali richiesti**
Alcuni [fornitori di materiali crittografici](#concept-material-provider) (CMPs) consentono di specificare opzioni avanzate, come un algoritmo di crittografia. Per indicare le tue scelte, aggiungi coppie nome-valore alla proprietà di descrizione del materiale del [contesto di crittografia DynamoDB nella tua richiesta di crittografia](concepts.md#encryption-context) di un elemento della tabella. Questo elemento è noto come *descrizione dei materiali richiesti*. I valori validi nella descrizione dei materiali richiesti sono definiti dal CMP scelto.
Poiché la descrizione dei materiali può sovrascrivere i valori predefiniti, ti consigliamo di omettere la descrizione dei materiali richiesti se non hai un valido motivo per utilizzarla.
**Descrizione dei materiali effettivi**
*La descrizione del materiale restituita [dai provider di materiali crittografici](#concept-material-provider) (CMPs) è nota come descrizione effettiva del materiale.* Descrive i valori effettivi che il CMP ha utilizzato quando ha assemblato i materiali crittografici. In genere comprende l'eventuale descrizione dei materiali richiesti, con aggiunte e modifiche.
**Attributo di descrizione del materiale**
Il client salva la descrizione dei materiali effettivi nell'*attributo di descrizione del materiale* dell'item crittografato. Il nome dell'attributo di descrizione del materiale è `amzn-ddb-map-desc` e il suo valore è la descrizione dei materiali effettivi. Il client utilizza i valori dell'attributo di descrizione del materiale per verificare e decrittografare l'item.
## Contesto di crittografia DynamoDB
Il contesto di *crittografia DynamoDB* fornisce informazioni sulla tabella e sull'elemento al fornitore di [materiali crittografici](#concept-material-provider) (CMP). [Nelle implementazioni avanzate, il contesto di crittografia DynamoDB può includere una descrizione del materiale richiesta.](#legacy-material-description)
Quando si crittografano gli elementi della tabella, il contesto di crittografia DynamoDB è associato crittograficamente ai valori degli attributi crittografati. Quando si decrittografa, se il contesto di crittografia DynamoDB non corrisponde esattamente, con distinzione tra maiuscole e minuscole, al contesto di crittografia DynamoDB utilizzato per crittografare, l'operazione di decrittografia fallisce. Se interagisci direttamente con l'[item encryptor](#item-encryptor), devi fornire un contesto di crittografia DynamoDB quando chiami un metodo di crittografia o decrittografia. La maggior parte degli helper crea automaticamente il contesto di crittografia DynamoDB.
**Nota**
*Il contesto di *crittografia DynamoDB* nel DynamoDB Encryption Client non è correlato al contesto di crittografia in () e in.* AWS Key Management Service AWS KMS AWS Encryption SDK
Il contesto di crittografia DynamoDB può includere i seguenti campi. Tutti i campi e i valori sono facoltativi.
+ Nome tabella
+ Nome della chiave di partizione
+ Nome della chiave di ordinamento
+ Coppie nome/valore degli attributi
+ [Descrizione dei materiali richiesti](#legacy-material-description)
## Archivio provider
Un *provider store* è un componente che restituisce [materiali crittografici providers](#concept-material-provider) (). CMPs Il provider store può creare CMPs o ottenere i file da un'altra fonte, ad esempio un altro provider store. Il provider store salva le versioni di CMPs ciò che crea in una memoria persistente in cui ogni CMP archiviato è identificato dal nome del materiale del richiedente e dal numero di versione.
Il [provider più recente](most-recent-provider.md) del client di crittografia DynamoDB lo ottiene CMPs da un archivio provider, ma è possibile utilizzare l'archivio provider per CMPs rifornire qualsiasi componente. Ogni provider più recente è associato a un provider store, ma un provider store può CMPs rifornire più richiedenti su più host.
Il provider store crea nuove versioni di CMPs on demand e restituisce versioni nuove ed esistenti. Restituisce inoltre l'ultimo numero di versione per un dato nome di materiale. Questo consente al richiedente di sapere quando l'archivio provider dispone di una nuova versione del suo CMP che è possibile richiedere.
Il client di crittografia DynamoDB include [ MetaStore](most-recent-provider.md#about-metastore)un, ovvero un provider store che crea CMPs Wrapped con chiavi archiviate in DynamoDB e crittografate utilizzando un client di crittografia DynamoDB interno.
**Ulteriori informazioni:**
+ Archivio provider: [Java](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/providers/store/ProviderStore.html), [Python](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/src/dynamodb_encryption_sdk/material_providers/store/__init__.py)
+ MetaStore: [Java](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/providers/store/MetaStore.html), [Python](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/materials_providers/metastore.html#module-dynamodb_encryption_sdk.material_providers.store.meta)
# Fornitore di materiali crittografici
**Nota**
[La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS](DDBEC-rename.md) Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Una delle decisioni più importanti da prendere quando si utilizza il DynamoDB Encryption Client è la selezione di [un fornitore di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMP). Il CMP raccoglie e restituisce i materiali crittografici al componente di crittografia dell'item. Determina inoltre la modalità di generazione delle chiavi di crittografia e di firma, gli algoritmi di crittografia e firma utilizzati e se i nuovi materiali di chiave devono essere creati o riutilizzati per ciascun item.
Puoi scegliere una CMP tra le implementazioni fornite nelle librerie DynamoDB Encryption Client o creare una CMP personalizzata compatibile. La scelta del CMP potrebbe inoltre dipendere dal [linguaggio di programmazione](programming-languages.md) utilizzato.
Questo argomento descrive le più comuni CMPs e offre alcuni consigli per aiutarvi a scegliere quella migliore per la vostra applicazione.
**Provider di materiali KMS diretto**
Direct KMS Materials Provider protegge gli elementi della tabella in [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)modo che non rimangano mai [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS) non crittografati. Non è necessario che l'applicazione generi o gestisca i materiali crittografici. Poiché utilizza il AWS KMS key per generare chiavi di crittografia e firma uniche per ogni elemento, questo provider chiama AWS KMS ogni volta che crittografa o decrittografa un elemento.
Se utilizzate AWS KMS e una sola AWS KMS chiamata per transazione è pratica per la vostra applicazione, questo provider è una buona scelta.
Per informazioni dettagliate, vedi [Provider di materiali KMS diretto](direct-kms-provider.md).
**Provider di materiali di sottoposti a wrapping (CMP di sottoposti a wrapping)**
Il Wrapped Materials Provider (Wrapped CMP) consente di generare e gestire le chiavi di wrapping e firma al di fuori del DynamoDB Encryption Client.
Il CMP di sottoposti a wrapping genera una chiave di crittografia univoca per ciascun item. Utilizza quindi le chiavi di firma e di crittografia (o di annullamento della crittografia) da te fornite. In questo modo, puoi determinare la modalità di generazione delle chiavi di crittografia e di firma e se sono univoche o se vengono riutilizzate per ciascun item. Wrapped CMP è un'alternativa sicura al [Direct KMS Provider](direct-kms-provider.md) per applicazioni che non utilizzano e possono gestire in sicurezza materiali crittografici. AWS KMS
Per informazioni dettagliate, vedi [Provider di materiali sottoposti a wrapping](wrapped-provider.md).
**Provider più recente**
Il *provider più recente* è un [provider di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) progettato per funzionare con gli [archivi del provider](DDBEC-legacy-concepts.md#provider-store). Proviene CMPs dall'archivio del provider e ottiene i materiali crittografici che restituisce da. CMPs Il Provider più recente in genere utilizza ciascun CMP per soddisfare più richieste di materiali crittografici, ma puoi utilizzare le funzioni dell'archivio del provider per controllare in quale misura vengono riutilizzati i materiali, determinare la frequenza di rotazione del CMP e persino modificare il tipo di CMP utilizzato senza cambiare il Provider più recente.
Puoi utilizzare il Provider più recente con qualsiasi archivio del provider compatibile. Il client di crittografia DynamoDB include MetaStore un, che è un provider store che restituisce Wrapped. CMPs
Il Provider più recente rappresenta una scelta adeguata per le applicazioni che devono ridurre al minimo le chiamate alla relativa origine crittografica e per le applicazioni che possono riutilizzare alcuni materiali crittografici senza violare i requisiti di sicurezza. Ad esempio, consente di proteggere i materiali crittografici utilizzando un comando [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS) senza chiamare AWS KMS ogni volta che si crittografa o decrittografa un elemento.
Per informazioni dettagliate, vedi [Provider più recente](most-recent-provider.md).
**Provider di materiali statici**
Lo Static Materials Provider è progettato per test, proof-of-concept dimostrazioni e compatibilità con le versioni precedenti. Non genera nessun materiale crittografico univoco per gli item. Restituisce le stesse chiavi di crittografia e di firma da te fornite che vengono utilizzate direttamente per crittografare, decrittografare e firmare gli item della tabella.
Il [Provider di statici asimmetrico](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/providers/AsymmetricStaticProvider.html) nella libreria Java non è un provider di statici. Fornisce soltanto costruttori alternativi per il [CMP di sottoposti a wrapping](wrapped-provider.md). Puoi utilizzarlo nell'ambiente di produzione, ma ti consigliamo di utilizzare direttamente il CMP di sottoposti a wrapping ogni qualvolta sia possibile.
**Topics**
+ [Provider di materiali KMS diretto](direct-kms-provider.md)
+ [Provider di materiali sottoposti a wrapping](wrapped-provider.md)
+ [Provider più recente](most-recent-provider.md)
+ [Provider di materiali statici](static-provider.md)
# Provider di materiali KMS diretto
**Nota**
[La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS](DDBEC-rename.md) Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
*Direct KMS Materials Provider* (Direct KMS Provider) protegge gli elementi della tabella in modo [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)che non rimangano mai () non crittografati. [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)AWS KMS Questo [provider di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) restituisce una chiave di crittografia e una chiave di firma univoche per ogni item della tabella. A tal fine, chiama AWS KMS ogni volta che si crittografa o decrittografa un elemento.
Se stai elaborando elementi DynamoDB ad alta frequenza e su larga scala, potresti superare i limiti, causando ritardi AWS KMS [requests-per-secondnell'](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second)elaborazione. [Se devi superare un limite, crea un caso nel Centro.Supporto AWS](https://console.aws.amazon.com/support/home) Potresti anche prendere in considerazione l'utilizzo di un fornitore di materiali crittografici con un riutilizzo limitato delle chiavi, come il [Most Recent](most-recent-provider.md) Provider.
[Per utilizzare Direct KMS Provider, il chiamante deve disporre di almeno uno AWS KMS key e del permesso di chiamare [GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)e [decriptare](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) le operazioni su. Account AWS](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) AWS KMS key AWS KMS key Deve essere una chiave di crittografia simmetrica; il DynamoDB Encryption Client non supporta la crittografia asimmetrica. [Se utilizzi una tabella [globale DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html), potresti voler specificare AWS KMS una chiave multiregione.](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) Per informazioni dettagliate, vedi [Come utilizzarlo](#provider-kms-how-to-use).
**Nota**
Quando si utilizza Direct KMS Provider, i nomi e i valori degli attributi della chiave primaria vengono visualizzati in testo semplice nel [contesto di AWS KMS crittografia e nei registri delle operazioni correlate](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context). AWS CloudTrail AWS KMS Tuttavia, il DynamoDB Encryption Client non espone mai il testo in chiaro di alcun valore di attributo crittografato.
Il Direct KMS Provider è uno dei numerosi [fornitori di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMPs) supportati dal DynamoDB Encryption Client. Per informazioni sull'altro, consulta. CMPs [Fornitore di materiali crittografici](crypto-materials-providers.md)
**Per il codice di esempio, consulta:**
+ Java: [AwsKmsEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedItem.java)
+ Python:, [aws-kms-encrypted-table[aws-kms-encrypted-item](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_item.py)](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_table.py)
**Topics**
+ [Come utilizzarlo](#provider-kms-how-to-use)
+ [Come funziona](#provider-kms-how-it-works)
## Come utilizzarlo
Per creare un Direct KMS Provider, utilizza il parametro key ID per specificare una chiave [KMS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) di crittografia simmetrica nel tuo account. Il valore del parametro key ID può essere l'ID chiave, l'ARN della chiave, il nome dell'alias o l'alias ARN di. AWS KMS key*Per i dettagli sugli identificatori chiave, consulta Identificatori [chiave](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) nella Guida per gli sviluppatori.AWS Key Management Service *
Il provider Direct KMS richiede una chiave KMS di crittografia simmetrica. Non è possibile utilizzare una chiave KMS asimmetrica. Tuttavia, puoi utilizzare una chiave KMS multiregionale, una chiave KMS con materiale chiave importato o una chiave KMS in un archivio di chiavi personalizzato. È necessario disporre dell'autorizzazione [kms: GenerateDataKey e KMS:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) [sulla chiave KMS](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html). Pertanto, è necessario utilizzare una chiave gestita dal cliente, non una chiave KMS gestita o di proprietà. AWS AWS
Il client di crittografia DynamoDB per Python determina la regione per la AWS KMS chiamata dalla regione nel valore del parametro ID chiave, se ne include una. Altrimenti, utilizza la Regione nel AWS KMS client, se ne specifichi una, o la Regione che configuri in. AWS SDK per Python (Boto3) Per informazioni sulla selezione della regione in Python, consulta [Configuration](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html) in the AWS SDK for Python (Boto3) API Reference.
Il client di crittografia DynamoDB per Java determina la regione per la AWS KMS chiamata dalla regione del client, se AWS KMS il client specificato include una regione. Altrimenti, utilizza la regione configurata in. AWS SDK per Java Per informazioni sulla selezione della regione in AWS SDK per Java, consulta la [Regione AWS selezione](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/java-dg-region-selection.html) nella Guida per gli AWS SDK per Java sviluppatori.
------
#### [ Java ]
```
// Replace the example key ARN and Region with valid values for your application
final String keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
final String region = 'us-west-2'
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
```
------
#### [ Python ]
L'esempio seguente utilizza la chiave ARN per specificare. AWS KMS key Se l'identificatore della chiave non include un Regione AWS, il client di crittografia DynamoDB ottiene la regione dalla sessione Botocore configurata, se presente, o dalle impostazioni predefinite di Boto.
```
# Replace the example key ID with a valid value
kms_key = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key)
```
------
Se utilizzi tabelle [globali di Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html), ti consigliamo di crittografare i dati con una chiave multiregionale. AWS KMS Le chiavi multiregionali sono disponibili AWS KMS keys in diversi formati e possono essere utilizzate in Regioni AWS modo intercambiabile perché hanno lo stesso ID di chiave e lo stesso materiale chiave. *Per i dettagli, consulta [Uso delle chiavi multiregionali nella Guida](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) per gli sviluppatori.AWS Key Management Service *
**Nota**
Se si utilizza la [versione 2017.11.29](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html) delle tabelle globali, è necessario impostare le azioni degli attributi in modo che i campi di replica riservati non siano crittografati o firmati. Per informazioni dettagliate, vedi [Problemi con le tabelle globali delle versioni precedenti](troubleshooting.md#fix-global-tables).
Per utilizzare una chiave multiregione con il DynamoDB Encryption Client, crea una chiave multiregione e replicala nelle regioni in cui viene eseguita l'applicazione. Quindi configura il provider Direct KMS per utilizzare la chiave multiregione nella regione in cui il DynamoDB Encryption Client chiama. AWS KMS
L'esempio seguente configura il DynamoDB Encryption Client per crittografare i dati nella regione Stati Uniti orientali (Virginia settentrionale) (us-east-1) e decrittografarli nella regione Stati Uniti occidentali (Oregon) (us-west-2) utilizzando una chiave multiregionale.
------
#### [ Java ]
In questo esempio, il client di crittografia DynamoDB ottiene la regione per la AWS KMS chiamata dalla regione del client. AWS KMS Il `keyArn` valore identifica una chiave multiregionale nella stessa regione.
```
// Encrypt in us-east-1
// Replace the example key ARN and Region with valid values for your application
final String usEastKey = 'arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
final String region = 'us-east-1'
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, usEastKey);
```
```
// Decrypt in us-west-2
// Replace the example key ARN and Region with valid values for your application
final String usWestKey = 'arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
final String region = 'us-west-2'
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, usWestKey);
```
------
#### [ Python ]
In questo esempio, il client di crittografia DynamoDB ottiene la regione per la AWS KMS chiamata dalla regione nella chiave ARN.
```
# Encrypt in us-east-1
# Replace the example key ID with a valid value
us_east_key = 'arn:aws:kms:us-east-1:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=us_east_key)
```
```
# Decrypt in us-west-2
# Replace the example key ID with a valid value
us_west_key = 'arn:aws:kms:us-west-2:111122223333:key/mrk-1234abcd12ab34cd56ef1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=us_west_key)
```
------
## Come funziona
Il provider Direct KMS restituisce chiavi di crittografia e firma protette da una AWS KMS key password specificata dall'utente, come illustrato nel diagramma seguente.
![\[L'input, l'elaborazione e l'output del provider Direct KMS nel client di crittografia DynamoDB\]](http://docs.aws.amazon.com/it_it/database-encryption-sdk/latest/devguide/images/directKMS.png)
+ Per generare materiali di crittografia, il provider Direct KMS richiede di AWS KMS [generare una chiave dati univoca per ogni elemento utilizzando una AWS KMS key chiave](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) specificata dall'utente. Deriva le chiavi di crittografia e di firma dell'item dalla copia di testo non crittografato della [chiave di dati](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys) e le restituisce, insieme alla chiave di dati crittografata, archiviata nell'[attributo di descrizione del materiale](DDBEC-legacy-concepts.md#legacy-material-description) dell'item.
Il componente di crittografia dell'item utilizza le chiavi di crittografia e di firma e le rimuove dalla memoria il prima possibile. Nell'item crittografato viene salvata soltanto la copia crittografata della chiave di dati da cui queste chiavi sono state derivate.
+ Per generare materiali di decrittografia, il provider Direct KMS chiede di AWS KMS decrittografare la chiave dati crittografata. Quindi, deriva le chiavi di verifica e di firma dalla chiave di dati con testo non crittografato e le restituisce al componente di crittografia dell'item.
Il componente di crittografia dell'item effettua la verifica dell'item e, in assenza di errori, decrittografa i valori crittografati. Quindi, rimuove le chiavi dalla memoria il prima possibile.
### Ottenere materiali di crittografia
Questa sezione descrive nei dettagli gli input, gli output e l'elaborazione del provider KMS diretto al momento della ricezione di una richiesta di materiali di crittografia dal [componente di crittografia dell'item](DDBEC-legacy-concepts.md#item-encryptor).
**Input ** (dall'applicazione)
+ L'ID della chiave di un. AWS KMS key
**Input** (dal componente di crittografia dell'item)
+ [Contesto di crittografia DynamoDB](concepts.md#encryption-context)
**Output** (sul componente di crittografia dell'item)
+ Chiave di crittografia (testo non crittografato)
+ Chiave di firma
+ Nella [descrizione dei materiali effettivi](DDBEC-legacy-concepts.md#legacy-material-description): questi valori vengono salvati nell'attributo di descrizione del materiale aggiunto all'item dal client.
+ amzn-ddb-env-key: chiave dati con codifica Base64 crittografata da AWS KMS key
+ amzn-ddb-env-alg[: algoritmo di crittografia, per impostazione predefinita AES/256](https://csrc.nist.gov/projects/cryptographic-standards-and-guidelines/archived-crypto-projects/aes-development)
+ amzn-ddb-sig-alg[: algoritmo di firma, per impostazione predefinita, Hmac/256 SHA256](https://en.wikipedia.org/wiki/HMAC)
+ amzn-ddb-wrap-alg: km
**Processing**
1. Il provider Direct KMS invia AWS KMS una richiesta per utilizzare quanto specificato AWS KMS key per [generare una chiave dati univoca](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) per l'articolo. L'operazione restituisce una chiave di testo non crittografato e una copia che viene crittografata con la AWS KMS key. Quest'ultima è nota come *materiale di chiave iniziale*.
La richiesta include i valori seguenti sotto forma di testo non crittografato nel [contesto di crittografia di AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context). Questi valori non segreti sono crittograficamente legati all'oggetto crittografato; pertanto, per effettuare la decrittografia è necessario lo stesso contesto di crittografia. È possibile utilizzare questi valori per identificare la chiamata AWS KMS ai [AWS CloudTrail log](https://docs.aws.amazon.com/kms/latest/developerguide/monitoring-overview.html).
+ amzn-ddb-env-alg — Algoritmo di crittografia, di default AES/256
+ amzn-ddb-sig-alg — Algoritmo di firma, di default Hmac/256 SHA256
+ (Opzionale) — aws-kms-table *table name*
+ (Facoltativo) *partition key name* — *partition key value* (i valori binari sono codificati in Base64)
+ (Facoltativo) *sort key name* — (i valori binari sono codificati in *sort key value* Base64)
Il provider Direct KMS ottiene i valori per il contesto di AWS KMS crittografia dal contesto di [crittografia DynamoDB per l'elemento](concepts.md#encryption-context). Se il contesto di crittografia DynamoDB non include un valore, ad esempio il nome della tabella, quella coppia nome-valore viene omessa dal contesto di crittografia. AWS KMS
1. Il Provider KMS diretto deriva la chiave di crittografia e la chiave di firma simmetriche dalla chiave di dati. Per impostazione predefinita, utilizza [Secure Hash Algorithm (SHA) 256 e la [Key Derivation Function RFC5869 basata su HMAC per derivare una chiave di crittografia simmetrica AES a 256 bit e una chiave di firma HMAC-SHA-256](https://tools.ietf.org/html/rfc5869)](https://en.wikipedia.org/wiki/SHA-2) a 256 bit.
1. Il Provider KMS diretto restituisce l'output al componente di crittografia dell'item.
1. Il componente di crittografia dell'item utilizza la chiave di crittografia per crittografare gli attributi specificati e la chiave di firma per firmarli, tramite gli algoritmi specificati nella descrizione dei materiali effettivi. Rimuove le chiavi di testo non crittografato dalla memoria il prima possibile.
### Ottenere materiali di decrittografia
Questa sezione descrive nei dettagli gli input, gli output e l'elaborazione del provider KMS diretto al momento della ricezione di una richiesta di materiali di decrittografia dal [componente di crittografia dell'item](DDBEC-legacy-concepts.md#item-encryptor).
**Input ** (dall'applicazione)
+ L'ID della chiave di un. AWS KMS key
Il valore dell'ID chiave può essere l'ID della chiave, l'ARN della chiave, il nome dell'alias o l'alias ARN di. AWS KMS key[Tutti i valori che non sono inclusi nell'ID della chiave, come la regione, devono essere disponibili nel profilo denominato.AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-using-profiles) L'ARN chiave fornisce tutti i valori necessari. AWS KMS
**Input** (dal componente di crittografia dell'item)
+ Una copia del contesto di [crittografia DynamoDB](concepts.md#encryption-context) che contiene il contenuto dell'attributo di descrizione del materiale.
**Output** (sul componente di crittografia dell'item)
+ Chiave di crittografia (testo non crittografato)
+ Chiave di firma
**Processing**
1. Il provider Direct KMS ottiene la chiave dei dati crittografati dall'attributo di descrizione del materiale nell'elemento crittografato.
1. Chiede AWS KMS di utilizzare quanto specificato AWS KMS key per [decrittografare la chiave dati crittografata](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html). L'operazione restituisce una chiave di testo non crittografato.
Questa richiesta deve utilizzare lo stesso [contesto di crittografia di AWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) utilizzato per generare e crittografare la chiave di dati.
+ aws-kms-table – *table name*
+ *partition key name*— *partition key value* (i valori binari sono codificati in Base64)
+ (Facoltativo) *sort key name* — (i valori binari sono codificati in *sort key value* Base64)
+ amzn-ddb-env-alg — Algoritmo di crittografia, di default AES/256
+ amzn-ddb-sig-alg — Algoritmo di firma, di default Hmac/256 SHA256
1. Il provider Direct KMS utilizza [Secure Hash Algorithm (SHA) 256 e la funzione di derivazione delle chiavi RFC5869 basata su HMAC per derivare una](https://en.wikipedia.org/wiki/SHA-2) [chiave di crittografia simmetrica AES a 256 bit e una chiave di firma HMAC-SHA-256](https://tools.ietf.org/html/rfc5869) a 256 bit dalla chiave dati.
1. Il Provider KMS diretto restituisce l'output al componente di crittografia dell'item.
1. Il componente di crittografia dell'item utilizza la chiave di firma per verificare l'item. Se l'operazione riesce, utilizza la chiave di crittografia simmetrica per decrittografare i valori di attributo crittografati. Queste operazioni utilizzano gli algoritmi di crittografia e di firma specificati nella descrizione dei materiali effettivi. Il componente di crittografia dell'item rimuove le chiavi di testo non crittografato dalla memoria il prima possibile.
# Provider di materiali sottoposti a wrapping
**Nota**
[La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS](DDBEC-rename.md) Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Il *Wrapped Materials Provider* (Wrapped CMP) consente di utilizzare chiavi di wrapping e firma da qualsiasi fonte con il DynamoDB Encryption Client. La Wrapped CMP non dipende da alcun servizio. AWS Tuttavia, devi generare e gestire le chiavi di wrapping e firma all'esterno del client, nonché fornire le chiavi corrette per verificare e decrittografare l'item.
Il CMP di sottoposti a wrapping genera una chiave di crittografia item univoca per ciascun item. Esegue il wrapping della chiave di crittografia dell'item con la chiave di wrapping che hai fornito e salva la chiave di crittografia dell'item sottoposta a wrapping nell'[attributo di descrizione del materiale](DDBEC-legacy-concepts.md#legacy-material-description) dell'item. Poiché sei tu a fornire le chiavi di wrapping e di firma, puoi capire come sono generate le chiavi di wrapping e firma e se sono univoche per ciascun item o riutilizzate.
Il CMP di sottoposti a wrapping è un'implementazione sicura e un'ottima scelta per le applicazioni in grado di gestire i materiali crittografici.
Wrapped CMP è uno dei numerosi [fornitori di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMPs) supportati dal DynamoDB Encryption Client. Per informazioni sull'altro, vedere. CMPs [Fornitore di materiali crittografici](crypto-materials-providers.md)
**Per il codice di esempio, consulta:**
+ Java: [AsymmetricEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AsymmetricEncryptedItem.java)
+ Python:, [wrapped-rsa-encrypted-table[wrapped-symmetric-encrypted-table](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/wrapped_symmetric_encrypted_table.py)](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/wrapped_rsa_encrypted_table.py)
**Topics**
+ [Come utilizzarlo](#wrapped-cmp-how-to-use)
+ [Come funziona](#wrapped-cmp-how-it-works)
## Come utilizzarlo
Per creare un CMP di sottoposti a wrapping, specifica una chiave di wrapping (necessaria per la crittografia), una chiave di annullamento del wrapping (necessaria per la decrittografia) e una chiave di firma. Le chiavi devono essere fornite al momento di crittografare e decrittografare gli item.
Le chiavi di wrapping, annullamento del wrapping e firma possono essere chiavi simmetriche o coppie di chiavi asimmetriche.
------
#### [ Java ]
```
// This example uses asymmetric wrapping and signing key pairs
final KeyPair wrappingKeys = ...
final KeyPair signingKeys = ...
final WrappedMaterialsProvider cmp =
new WrappedMaterialsProvider(wrappingKeys.getPublic(),
wrappingKeys.getPrivate(),
signingKeys);
```
------
#### [ Python ]
```
# This example uses symmetric wrapping and signing keys
wrapping_key = ...
signing_key = ...
wrapped_cmp = WrappedCryptographicMaterialsProvider(
wrapping_key=wrapping_key,
unwrapping_key=wrapping_key,
signing_key=signing_key
)
```
------
## Come funziona
Il CMP di sottoposti a wrapping genera una nuova chiave di crittografia item per ciascun item. Utilizza le chiavi di wrapping, annullamento del wrapping e firma da te fornite, come mostrato nel diagramma mostrato di seguito.
![\[L'input, l'elaborazione e l'output del Wrapped Materials Provider nel DynamoDB Encryption Client\]](http://docs.aws.amazon.com/it_it/database-encryption-sdk/latest/devguide/images/wrappedCMP.png)
### Ottenere materiali di crittografia
In questa sezione vengono descritti nei dettagli gli input, gli output e l'elaborazione eseguita dal provider di materiali sottoposti a wrapping (CMP di sottoposti a wrapping) al momento della ricezione di una richiesta di materiali di crittografia.
**Input** (dall'applicazione)
+ Chiave di wrapping: una chiave [AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) simmetrica o una chiave pubblica [RSA](https://en.wikipedia.org/wiki/RSA_(cryptosystem)). Necessaria se alcuni valori degli attributi sono crittografati. In caso contrario, è facoltativa e viene ignorata.
+ Chiave di annullamento del wrapping: facoltativa e ignorata.
+ Chiave di firma
**Input** (dal componente di crittografia dell'item)
+ [Contesto di crittografia DynamoDB](concepts.md#encryption-context)
**Output** (sul componente di crittografia dell'item)
+ Chiave di crittografia dell'item di testo normale
+ Chiave di firma (invariata)
+ [Descrizione dei materiali effettivi](DDBEC-legacy-concepts.md#legacy-material-description): questi valori vengono salvati nell'[attributo di descrizione del materiale](DDBEC-legacy-concepts.md#legacy-material-description) che il client aggiunge all'item.
+ `amzn-ddb-env-key`: chiave di crittografia item sottoposta a wrapping Base64-encoded
+ `amzn-ddb-env-alg`: algoritmo di crittografia utilizzato per crittografare l'item. Il valore predefinito è AES-256-CBC.
+ `amzn-ddb-wrap-alg`: l'algoritmo di wrapping che il CMP di sottoposti a wrapping ha utilizzato per eseguire il wrapping della chiave di crittografia item. Se la chiave di wrapping è una chiave AES, viene sottoposta a wrapping utilizzando `AES-Keywrap` senza riempimenti come indicato in [RFC 3394](https://tools.ietf.org/html/rfc3394.html). Se la chiave di wrapping è una chiave RSA, la chiave viene crittografata utilizzando RSA OAEP con padding. MGF1
**Processing**
La crittografia di un item richiede una chiave di wrapping e una chiave di firma. La chiave di annullamento del wrapping è facoltativa e viene ignorata.
1. Il CMP di sottoposti a wrapping genera una chiave di crittografia item simmetrica univoca per l'item della tabella.
1. Utilizza la chiave di wrapping da te specificata per eseguire il wrapping della chiave di crittografia item. Quindi, la rimuove dalla memoria il prima possibile.
1. Restituisce la chiave di crittografia dell'item in testo normale, la chiave di firma da te fornita e una [descrizione dei materiali effettivi](DDBEC-legacy-concepts.md#legacy-material-description) che include la chiave di crittografia dell'item sottoposta a wrapping e gli algoritmi di crittografia e wrapping.
1. Il componente di crittografia dell'item utilizza la chiave di crittografia testo normale per crittografare l'item. Utilizza la chiave di firma da te fornita per firmare l'item. Quindi, rimuove le chiavi di testo normale dalla memoria il prima possibile. Copia i campi della descrizione dei materiali effettivi, inclusa la chiave di crittografia sottoposta a wrapping (`amzn-ddb-env-key`) nell'attributo di descrizione del materiale dell'item.
### Ottenere materiali di decrittografia
In questa sezione vengono descritti nei dettagli gli input, gli output e l'elaborazione eseguita dal provider di materiali sottoposti a wrapping (CMP di sottoposti a wrapping) al momento della ricezione di una richiesta di materiali di decrittografia.
**Input** (dall'applicazione)
+ Chiave wrapping: facoltativa e ignorata.
+ Chiave di annullamento del wrapping: la stessa chiave [AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) simmetrica o la chiave privata [RSA](https://en.wikipedia.org/wiki/RSA_(cryptosystem)) corrispondente alla chiave pubblica RSA utilizzata per la crittografia. Necessaria se alcuni valori degli attributi sono crittografati. In caso contrario, è facoltativa e viene ignorata.
+ Chiave di firma
**Input** (dal componente di crittografia dell'item)
+ Una copia del contesto di [crittografia DynamoDB](concepts.md#encryption-context) che contiene il contenuto dell'attributo di descrizione del materiale.
**Output** (sul componente di crittografia dell'item)
+ Chiave di crittografia dell'item di testo normale
+ Chiave di firma (invariata)
**Processing**
La decrittografia di un item richiede una chiave di annullamento del wrapping e una chiave di firma. La chiave di wrapping è facoltativa e viene ignorata.
1. Il CMP di sottoposti a wrapping ottiene la chiave di crittografia item sottoposta a wrapping dall'attributo di descrizione del materiale dell'item.
1. Utilizza la chiave e l'algoritmo di annullamento del wrapping per annullare il wrapping della chiave di crittografia item.
1. Restituisce la chiave di crittografia item di testo normale, la chiave di firma e gli algoritmi di crittografia e firma al componente di crittografia dell'item.
1. Il componente di crittografia dell'item utilizza la chiave di firma per verificare l'item. Se la verifica riesce, utilizza la chiave di crittografia item per decrittografare l'item. Quindi, rimuove le chiavi di testo normale dalla memoria il prima possibile.
# Provider più recente
**Nota**
[La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS](DDBEC-rename.md) Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Il *provider più recente* è un [provider di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) progettato per funzionare con gli [archivi del provider](DDBEC-legacy-concepts.md#provider-store). Viene CMPs dall'archivio del provider e ottiene i materiali crittografici restituiti da. CMPs In genere utilizza ciascun CMP per soddisfare più richieste di materiali crittografici. Ma puoi utilizzare le funzioni del suo archivio provider per controllare in quale misura i materiali vengono riutilizzati, stabilire la frequenza di rotazione del CMP e persino cambiare il tipo di CMP utilizzato senza cambiare il provider più recente.
**Nota**
Il codice associato al `MostRecentProvider` simbolo del provider più recente potrebbe archiviare materiali crittografici in memoria per tutta la durata del processo. Potrebbe consentire a un chiamante di utilizzare chiavi che non è più autorizzato a utilizzare.
Il `MostRecentProvider` simbolo è obsoleto nelle versioni precedenti supportate del DynamoDB Encryption Client e rimosso dalla versione 2.0.0. Viene sostituito dal simbolo. `CachingMostRecentProvider` Per informazioni dettagliate, vedi [Aggiornamenti al provider più recente](#mrp-versions).
Il provider più recente è una buona scelta per le applicazioni che devono ridurre al minimo le chiamate all'archivio provider e all'origine crittografica e per le applicazioni che possono riutilizzare alcuni materiali crittografici senza violare i requisiti di sicurezza. Ad esempio, ti consente di proteggere i tuoi materiali crittografici con un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS) senza chiamare AWS KMS ogni volta che crittografi o decrittografi un elemento.
Il provider store scelto determina il tipo di provider utilizzato dal provider più recente e la frequenza con CMPs cui riceve una nuova CMP. Puoi utilizzare qualsiasi archivio provider compatibile con il provider più recente, inclusi quelli personalizzati che hai progettato.
Il client di crittografia DynamoDB include *MetaStore*un client che crea e [restituisce Wrapped Materials Providers (Wrapped](wrapped-provider.md)). CMPs MetaStore Salva più versioni di Wrapped CMPs che genera in una tabella DynamoDB interna e le protegge con la crittografia lato client tramite un'istanza interna del DynamoDB Encryption Client.
Puoi configurarlo MetaStore per utilizzare qualsiasi tipo di CMP interno per proteggere i materiali nella tabella, incluso un [Direct KMS Provider](direct-kms-provider.md) che genera materiali crittografici protetti dall'utente AWS KMS key, un CMP Wrapped che utilizza le chiavi di wrapping e firma fornite dall'utente o un CMP personalizzato compatibile progettato da te.
**Per il codice di esempio, consulta:**
+ Java: [MostRecentEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/MostRecentEncryptedItem.java)
+ Python: [most\$1recent\$1provider\$1encrypted\$1table](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/most_recent_provider_encrypted_table.py)
**Topics**
+ [Come utilizzarlo](#mrp-how-to-use-it)
+ [Come funziona](#mrp-how-it-works)
+ [Aggiornamenti al provider più recente](#mrp-versions)
## Come utilizzarlo
Per creare un provider più recente devi creare e configurare un archivio provider e quindi creare un provider più recente che lo utilizzi.
[Gli esempi seguenti mostrano come creare un provider più recente che utilizza a MetaStore e protegge le versioni nella sua tabella DynamoDB interna con materiali crittografici provenienti da un provider Direct KMS.](direct-kms-provider.md) Questi esempi utilizzano il simbolo. [`CachingMostRecentProvider`](#mrp-versions)
Ogni provider più recente ha un nome che lo identifica CMPs nella MetaStore tabella, un'impostazione [time-to-live](#most-recent-provider-ttl)(TTL) e un'impostazione della dimensione della cache che determina il numero di voci che la cache può contenere. Questi esempi impostano la dimensione della cache su 1000 voci e un TTL di 60 secondi.
------
#### [ Java ]
```
// Set the name for MetaStore's internal table
final String keyTableName = 'metaStoreTable'
// Set the Region and AWS KMS key
final String region = 'us-west-2'
final String keyArn = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
// Set the TTL and cache size
final long ttlInMillis = 60000;
final long cacheSize = 1000;
// Name that identifies the MetaStore's CMPs in the provider store
final String materialName = 'testMRP'
// Create an internal DynamoDB client for the MetaStore
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
// Create an internal Direct KMS Provider for the MetaStore
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider kmsProv = new DirectKmsMaterialProvider(kms, keyArn);
// Create an item encryptor for the MetaStore,
// including the Direct KMS Provider
final DynamoDBEncryptor keyEncryptor = DynamoDBEncryptor.getInstance(kmsProv);
// Create the MetaStore
final MetaStore metaStore = new MetaStore(ddb, keyTableName, keyEncryptor);
//Create the Most Recent Provider
final CachingMostRecentProvider cmp = new CachingMostRecentProvider(metaStore, materialName, ttlInMillis, cacheSize);
```
------
#### [ Python ]
```
# Designate an AWS KMS key
kms_key_id = 'arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
# Set the name for MetaStore's internal table
meta_table_name = 'metaStoreTable'
# Name that identifies the MetaStore's CMPs in the provider store
material_name = 'testMRP'
# Create an internal DynamoDB table resource for the MetaStore
meta_table = boto3.resource('dynamodb').Table(meta_table_name)
# Create an internal Direct KMS Provider for the MetaStore
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
# Create the MetaStore with the Direct KMS Provider
meta_store = MetaStore(
table=meta_table,
materials_provider=kms_cmp
)
# Create a Most Recent Provider using the MetaStore
# Sets the TTL (in seconds) and cache size (# entries)
most_recent_cmp = MostRecentProvider(
provider_store=meta_store,
material_name=material_name,
version_ttl=60.0,
cache_size=1000
)
```
------
## Come funziona
Il provider più recente riceve CMPs da un provider store. Quindi utilizza il CMP per generare i materiali crittografici che restituisce al componente di crittografia dell'item.
### Informazioni sul provider più recente
Il provider più recente ottiene un [provider di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) da un [archivio provider](DDBEC-legacy-concepts.md#provider-store). Utilizza quindi il CMP per generare i materiali crittografici che restituisce. Ogni provider più recente è associato a un provider store, ma un provider store può CMPs rifornire più provider su più host.
Il provider più recente può utilizzare qualsiasi CMP compatibile di qualsiasi archivio provider. Richiede materiali di crittografia o decrittografia dal CMP e restituisce l'output all'item encryptor. Non esegue alcuna operazione crittografica.
Per richiedere un CMP al suo archivio provider, il provider più recente fornisce il nome del materiale e la versione di un CMP esistente che desidera utilizzare. Per i materiali di crittografia, il provider più recente richiede sempre la versione massima ("più recente"). Per i materiali di decrittografia, richiede la versione del CMP che è stata utilizzata per creare i materiali di crittografia, come mostrato nel diagramma seguente.
![\[Un provider più recente\]](http://docs.aws.amazon.com/it_it/database-encryption-sdk/latest/devguide/images/most-recent-provider-1.png)
Il provider più recente salva le versioni restituite dall'archivio del CMPs provider in una cache locale LRU (Least Recently Used) in memoria. La cache consente al provider più recente di ottenere ciò di CMPs cui ha bisogno senza chiamare l'archivio del provider per ogni articolo. Puoi cancellare la cache on-demand.
Il provider più recente utilizza un [time-to-livevalore](#most-recent-provider-ttl) configurabile che è possibile regolare in base alle caratteristiche dell'applicazione.
### Informazioni su MetaStore
Puoi utilizzare un provider più recente con qualsiasi archivio provider, anche un archivio provider personalizzato compatibile. Il DynamoDB Encryption Client include MetaStore un'implementazione sicura che è possibile configurare e personalizzare.
A *MetaStore*è un [provider store](DDBEC-legacy-concepts.md#provider-store) che crea e restituisce [Wrapped configurati con la chiave di CMPs wrapping](wrapped-provider.md), la chiave di unwrapping e la chiave di firma richieste da Wrapped. CMPs A MetaStore è un'opzione sicura per un provider più recente perché Wrapped genera CMPs sempre chiavi di crittografia degli elementi uniche per ogni articolo. Vengono riutilizzate solo la chiave di wrapping che protegge la chiave di crittografia degli item e le chiavi di firma.
Il diagramma seguente mostra i componenti di MetaStore e come interagisce con il provider più recente.
![\[A MetaStore\]](http://docs.aws.amazon.com/it_it/database-encryption-sdk/latest/devguide/images/most-recent-provider-2.png)
MetaStore genera i Wrapped CMPs e poi li archivia (in forma crittografata) in una tabella DynamoDB interna. La chiave di partizione è il nome del materiale del provider più recente; la chiave di ordinamento è il numero di versione. I materiali nella tabella sono protetti da un client di crittografia DynamoDB interno, che include un item encryptor e un provider [interno di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMP).
Puoi utilizzare qualsiasi tipo di CMP interno al tuo sito MetaStore, incluso un [Direct KMS Provider](wrapped-provider.md), un CMP Wrapped con materiali crittografici da te fornito o un CMP personalizzato compatibile. Se il tuo CMP interno MetaStore è un Direct KMS Provider, le tue chiavi di wrapping e firma riutilizzabili sono protette da un in (). [AWS KMS key[AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)AWS KMS Le MetaStore chiamate AWS KMS ogni volta che aggiunge una nuova versione CMP alla sua tabella interna o ottiene una versione CMP dalla sua tabella interna.
### Impostazione di un valore time-to-live
È possibile impostare un valore time-to-live (TTL) per ogni provider più recente creato. In generale, utilizzate il valore TTL più basso che sia pratico per la vostra applicazione.
L'uso del valore TTL viene modificato nel `CachingMostRecentProvider` simbolo del provider più recente.
**Nota**
Il `MostRecentProvider` simbolo del provider più recente è obsoleto nelle versioni precedenti supportate del DynamoDB Encryption Client e rimosso dalla versione 2.0.0. Viene sostituito dal simbolo. `CachingMostRecentProvider` Ti consigliamo di aggiornare il codice il prima possibile. Per informazioni dettagliate, vedi [Aggiornamenti al provider più recente](#mrp-versions).
**`CachingMostRecentProvider`**
`CachingMostRecentProvider`Utilizza il valore TTL in due modi diversi.
+ Il TTL determina la frequenza con cui il provider più recente verifica la presenza di una nuova versione del CMP nell'archivio del provider. Se è disponibile una nuova versione, il provider più recente sostituisce la propria CMP e aggiorna i materiali crittografici. Altrimenti, continua a utilizzare i suoi attuali materiali CMP e crittografici.
+ Il TTL determina per quanto tempo CMPs è possibile utilizzare la cache. Prima di utilizzare una CMP memorizzata nella cache per la crittografia, il Most Recent Provider valuta il tempo trascorso nella cache. Se il tempo della cache CMP supera il TTL, la CMP viene rimossa dalla cache e il provider più recente riceve una nuova versione CMP dall'archivio del provider.
**`MostRecentProvider`**
Nel`MostRecentProvider`, il TTL determina la frequenza con cui il provider più recente verifica la presenza di una nuova versione del CMP nell'archivio del provider. Se è disponibile una nuova versione, il provider più recente sostituisce la propria CMP e aggiorna i materiali crittografici. Altrimenti, continua a utilizzare i suoi attuali materiali CMP e crittografici.
Il TTL non determina la frequenza con cui viene creata una nuova versione CMP. È possibile creare nuove versioni CMP [ruotando](#most-recent-provider-rotate) i materiali crittografici.
Un valore TTL ideale varia a seconda dell'applicazione e dei suoi obiettivi di latenza e disponibilità. Un TTL inferiore migliora il profilo di sicurezza riducendo il tempo di archiviazione dei materiali crittografici in memoria. Inoltre, un TTL inferiore aggiorna le informazioni critiche con maggiore frequenza. Ad esempio, se il CMP interno è un [Direct KMS Provider](direct-kms-provider.md), verifica più frequentemente che il chiamante sia ancora autorizzato a utilizzare un. AWS KMS key
Tuttavia, se il TTL è troppo breve, le chiamate frequenti all'archivio del provider possono aumentare i costi e far sì che l'archivio del provider limiti le richieste provenienti dall'applicazione e da altre applicazioni che condividono l'account di servizio. Potresti anche trarre vantaggio dal coordinamento del TTL con la velocità di rotazione dei materiali crittografici.
Durante i test, variate il TTL e le dimensioni della cache in base ai diversi carichi di lavoro fino a trovare una configurazione adatta alla vostra applicazione e ai vostri standard di sicurezza e prestazioni.
### Rotazione dei materiali crittografici
Quando un Most Recent Provider necessita di materiali di crittografia, utilizza sempre la versione più recente della sua CMP di cui è a conoscenza. La frequenza con cui verifica la presenza di una versione più recente è determinata dal valore [time-to-live](#most-recent-provider-ttl)(TTL) impostato quando si configura il provider più recente.
Quando il TTL scade, il provider più recente verifica la presenza di una versione più recente del CMP nell'archivio del provider. Se disponibile, il provider più recente la ottiene e sostituisce la CMP nella sua cache. Utilizza questo CMP e il relativo materiale crittografico finché non scopre che Provider Store ha una versione più recente.
Per indicare all'archivio provider di creare una nuova versione di un CMP per un provider più recente, richiama l'operazione Create New Provider (Crea nuovo provider) dell'archivio provider con il nome del materiale del provider più recente. L'archivio provider crea un nuovo CMP e salva una copia crittografata nel suo storage interno con un numero di versione superiore: Restituisce anche un CMP, ma puoi ignorarlo. Di conseguenza, la volta successiva che il provider più recente richiede al provider store il numero massimo di versione CMPs, ottiene il nuovo numero di versione più recente e lo utilizza nelle richieste successive allo store per verificare se è stata creata una nuova versione del CMP.
Puoi programmare le chiamate Create New Provider (Crea nuovo provider) sulla base del tempo, del numero di item o di attributi elaborati o su qualsiasi altro parametro rilevante per la tua applicazione.
### Ottenere materiali di crittografia
Il provider più recente utilizza il seguente processo, mostrato in questo diagramma, per ottenere i materiali di crittografia che restituisce al componente di crittografia dell'item. L'output dipende dal tipo di CMP restituito dall'archivio provider. Il provider più recente può utilizzare qualsiasi archivio provider compatibile, incluso MetaStore quello incluso nel DynamoDB Encryption Client.
![\[Input, elaborazione e output del provider più recente nel client di crittografia DynamoDB\]](http://docs.aws.amazon.com/it_it/database-encryption-sdk/latest/devguide/images/most-recent-provider-provider-store.png)
Quando si crea un provider più recente utilizzando il [`CachingMostRecentProvider`simbolo](#mrp-versions), si specifica un archivio provider, un nome per il provider più recente e un valore [time-to-live](#most-recent-provider-ttl)(TTL). È inoltre possibile specificare facoltativamente una dimensione della cache, che determina il numero massimo di materiali crittografici che possono esistere nella cache.
Quando il componente di crittografia dell'item chiede al provider più recente i materiali di crittografia, il provider più recente inizia a cercare nella sua cache la versione più recente del suo CMP.
+ Se trova la versione CMP più recente nella cache e la CMP non ha superato il valore TTL, il provider più recente utilizza la CMP per generare materiali di crittografia. Quindi restituisce i materiali di crittografia al componente di crittografia dell'item. Questa operazione non richiede una chiamata dell'archivio provider.
+ Se la versione più recente della CMP non è presente nella cache o se è presente nella cache ma ha superato il valore TTL, il provider più recente richiede una CMP dall'archivio del provider. La richiesta include il nome del materiale del provider più recente e il numero della versione massima che conosce.
1. L'archivio provider restituisce un CMP dal suo storage persistente. Se il provider store è un MetaStore, ottiene un Wrapped CMP crittografato dalla tabella DynamoDB interna utilizzando il nome del materiale del provider più recente come chiave di partizione e il numero di versione come chiave di ordinamento. MetaStore Utilizza il criptatore interno degli elementi e la CMP interna per decrittografare la Wrapped CMP. Quindi restituisce il CMP come testo normale al provider più recente. Se il CMP interno è un [provider KMS diretto](direct-kms-provider.md), questa fase prevede una chiamata a [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/) (AWS KMS).
1. Il CMP aggiunge il campo `amzn-ddb-meta-id` alla [descrizione dei materiali effettivi](DDBEC-legacy-concepts.md#legacy-material-description). Il suo valore è il nome del materiale e la versione del CMP nella sua tabella interna. L'archivio provider restituisce al provider più recente il CMP come testo normale.
1. Il provider più recente archivia il CMP nella cache.
1. Il provider più recente utilizza il CMP per generare i materiali di crittografia. Quindi restituisce i materiali di crittografia al componente di crittografia dell'item.
### Ottenere materiali di decrittografia
Quando il componente di crittografia dell'item chiede al provider più recente i materiali di decrittografia, il provider più recente utilizza il seguente processo per ottenerli e restituirli.
1. Il provider più recente chiede all'archivio provider il numero di versione dei materiali crittografici utilizzati per crittografare l'item. Passa la descrizione dei materiali effettivi dall'[attributo di descrizione del materiale](DDBEC-legacy-concepts.md#legacy-material-description) dell'item.
1. L'archivio provider riceve il numero di versione del CMP di crittografia dal campo `amzn-ddb-meta-id` nella descrizione dei materiali effettivi e lo restituisce al provider più recente.
1. Il provider più recente ricerca nella sua cache la versione del CMP utilizzata per crittografare e firmare l'item.
+ Se rileva che la versione corrispondente della CMP è nella sua cache e la CMP non ha superato il [valore time-to-live (TTL)](#most-recent-provider-ttl), il provider più recente utilizza la CMP per generare materiali di decrittografia. Quindi restituisce i materiali di decrittografia al componente di crittografia dell'item. Questa operazione non richiede una chiamata dell'archivio provider o a qualsiasi altro CMP.
+ Se la versione corrispondente della CMP non è presente nella cache o se la cache AWS KMS key ha superato il valore TTL, il provider più recente richiede una CMP dal proprio provider store. Nella richiesta invia il nome del materiale e il numero di versione del suo CMP di crittografia.
1. L'archivio provider ricerca nello storage persistente il CMP utilizzando il nome del provider più recente come chiave di partizione e il numero di versione come chiave di ordinamento.
+ Se il nome e il numero di versione non sono nello storage persistente, l'archivio provider rileva un'eccezione. Se l'archivio provider è stato utilizzato per generare il CMP, il CMP dovrebbe essere archiviato nel suo storage persistente, a meno che non sia stato volutamente eliminato.
+ Se il CMP con il numero di versione e il nome corrispondenti sono disponibili nello storage persistente dell'archivio provider, quest'ultimo restituisce il CMP specificato al provider più recente.
Se il provider store è un MetaStore, ottiene il CMP crittografato dalla tabella DynamoDB. Quindi utilizza i materiali crittografici dal suo CMP interno per decrittografare il CMP crittografato prima di restituire il CMP al provider più recente. Se il CMP interno è un [provider KMS diretto](direct-kms-provider.md), questa fase prevede una chiamata a [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/) (AWS KMS).
1. Il provider più recente archivia il CMP nella cache.
1. Il provider più recente utilizza il CMP per generare i materiali di decrittografia. Quindi restituisce i materiali di decrittografia al componente di crittografia dell'item.
## Aggiornamenti al provider più recente
Il simbolo del provider più recente viene modificato da `MostRecentProvider` a`CachingMostRecentProvider`.
**Nota**
Il `MostRecentProvider` simbolo, che rappresenta il provider più recente, è obsoleto nella versione 1.15 del DynamoDB Encryption Client for Java e nella versione 1.3 del DynamoDB Encryption Client for Python e rimosso dalle versioni 2.0.0 del DynamoDB Encryption Client in entrambe le implementazioni linguistiche. Utilizzate invece il. `CachingMostRecentProvider`
`CachingMostRecentProvider`Implementa le seguenti modifiche:
+ Rimuove `CachingMostRecentProvider` periodicamente i materiali crittografici dalla memoria quando la loro permanenza in memoria supera il valore configurato [time-to-live (TTL)](#most-recent-provider-ttl).
`MostRecentProvider`Potrebbero archiviare materiali crittografici in memoria per tutta la durata del processo. Di conseguenza, il provider più recente potrebbe non essere a conoscenza delle modifiche alle autorizzazioni. Potrebbe utilizzare le chiavi di crittografia dopo la revoca delle autorizzazioni del chiamante per utilizzarle.
Se non riesci ad eseguire l'aggiornamento a questa nuova versione, puoi ottenere un effetto simile chiamando periodicamente il `clear()` metodo nella cache. Questo metodo svuota manualmente il contenuto della cache e richiede al Most Recent Provider di richiedere una nuova CMP e nuovi materiali crittografici.
+ Include `CachingMostRecentProvider` anche un'impostazione della dimensione della cache che consente un maggiore controllo sulla cache.
Per eseguire l'aggiornamento a`CachingMostRecentProvider`, è necessario modificare il nome del simbolo nel codice. Sotto tutti gli altri aspetti, `CachingMostRecentProvider` è completamente retrocompatibile con. `MostRecentProvider` Non è necessario crittografare nuovamente gli elementi della tabella.
Tuttavia, `CachingMostRecentProvider` genera più chiamate all'infrastruttura chiave sottostante. Chiama l'archivio del provider almeno una volta in ogni intervallo time-to-live (TTL). Le applicazioni con numerose applicazioni attive CMPs (a causa della frequente rotazione) o le applicazioni con flotte di grandi dimensioni sono più suscettibili a questo cambiamento.
Prima di rilasciare il codice aggiornato, testalo accuratamente per assicurarti che le chiamate più frequenti non danneggino l'applicazione o causino limitazioni da parte dei servizi da cui dipende il tuo provider, come AWS Key Management Service () o AWS KMS Amazon DynamoDB. Per mitigare eventuali problemi di prestazioni, regola la dimensione e la dimensione della cache in `CachingMostRecentProvider` base alle time-to-live caratteristiche prestazionali osservate. Per le linee guida, consulta [Impostazione di un valore time-to-live](#most-recent-provider-ttl).
# Provider di materiali statici
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Lo *Static Materials Provider* (Static CMP) è un [fornitore di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) molto semplice destinato a test, proof-of-concept dimostrazioni e compatibilità con le versioni precedenti.
Per utilizzare il CMP di statici per crittografare un item della tabella, è necessario fornire una chiave di crittografia simmetrica [AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) e una chiave di firma o una coppia di chiavi. Devi fornire le stesse chiavi per decrittografare l'item crittografato. Il CMP di statici non esegue alcuna operazione di crittografia. Passa invece al componente di crittografia dell'item le chiavi di crittografia da te fornite senza modificarle. Il componente di crittografia dell'item crittografa direttamente gli item con la chiave di crittografia. Quindi, utilizza direttamente la chiave di firma per firmarli.
Poiché il CMP di statici non genera alcun materiale crittografico univoco, tutti gli item della tabella che hai elaborato sono crittografati con la stessa chiave di crittografia e firmati con la stessa chiave di firma. Quando utilizzi la stessa chiave per crittografare i valori degli attributi in numerosi item o utilizzi la stessa chiave o coppia di chiavi per firmare tutti gli item, rischi di superare i limiti crittografici delle chiavi.
**Nota**
Il [Provider di statici asimmetrico](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/providers/AsymmetricStaticProvider.html) nella libreria Java non è un provider di statici. Fornisce soltanto costruttori alternativi per il [CMP di sottoposti a wrapping](wrapped-provider.md). Può essere utilizzato per la produzione senza alcun rischio per la sicurezza, tuttavia dovresti utilizzare direttamente il CMP di sottoposti a wrapping ogni qualvolta sia possibile.
Static CMP è uno dei numerosi [fornitori di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMPs) supportati dal DynamoDB Encryption Client. Per informazioni sull'altro, vedere. CMPs [Fornitore di materiali crittografici](crypto-materials-providers.md)
**Per il codice di esempio, consulta:**
+ Java: [SymmetricEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/SymmetricEncryptedItem.java)
**Topics**
+ [Come utilizzarlo](#static-cmp-how-to-use)
+ [Come funziona](#static-cmp-how-it-works)
## Come utilizzarlo
Per creare un provider di statici, fornisci una chiave di crittografia o una coppia di chiavi e una chiave di firma o una coppia di chiavi. Devi fornire materiali chiave per crittografare e decrittografare gli item della tabella.
------
#### [ Java ]
```
// To encrypt
SecretKey cek = ...; // Encryption key
SecretKey macKey = ...; // Signing key
EncryptionMaterialsProvider provider = new SymmetricStaticProvider(cek, macKey);
// To decrypt
SecretKey cek = ...; // Encryption key
SecretKey macKey = ...; // Verification key
EncryptionMaterialsProvider provider = new SymmetricStaticProvider(cek, macKey);
```
------
#### [ Python ]
```
# You can provide encryption materials, decryption materials, or both
encrypt_keys = EncryptionMaterials(
encryption_key = ...,
signing_key = ...
)
decrypt_keys = DecryptionMaterials(
decryption_key = ...,
verification_key = ...
)
static_cmp = StaticCryptographicMaterialsProvider(
encryption_materials=encrypt_keys
decryption_materials=decrypt_keys
)
```
------
## Come funziona
Il provider di statici passa le chiavi di crittografia e firma che hai fornito al componente di crittografia dell'item, dove vengono direttamente utilizzate per crittografare e firmare gli item della tabella. Vengono utilizzate le stesse chiavi per tutti gli item, a meno che tu non fornisca chiavi diverse per ciascun item.
![\[L'input, l'elaborazione e l'output dello Static Materials Provider nel DynamoDB Encryption Client\]](http://docs.aws.amazon.com/it_it/database-encryption-sdk/latest/devguide/images/staticCMP.png)
### Ottenere materiali di crittografia
In questa sezione vengono descritti nei dettagli gli input, gli output e l'elaborazione eseguita dal provider di materiali statici (CMP di statici) al momento della ricezione di una richiesta di materiali di crittografia.
**Input ** (dall'applicazione)
+ Una chiave di crittografia: deve essere una chiave simmetrica, ad esempio una chiave [Advanced Encryption Standard](https://tools.ietf.org/html/rfc3394.html) (AES).
+ Una chiave di firma: può essere una chiave simmetrica o una coppia di chiavi asimmetrica.
**Input** (dal componente di crittografia dell'item)
+ [Contesto di crittografia DynamoDB](concepts.md#encryption-context)
**Output** (sul componente di crittografia dell'item)
+ La chiave di crittografia passata come input.
+ La chiave di firma passata come input.
+ Descrizione dei materiali effettivi: l'eventuale [descrizione dei materiali richiesti](DDBEC-legacy-concepts.md#legacy-material-description) invariata.
### Ottenere materiali di decrittografia
In questa sezione vengono descritti nei dettagli gli input, gli output e l'elaborazione eseguita dal provider di materiali statici (CMP di statici) al momento della ricezione di una richiesta di materiali di decrittografia.
Sebbene i metodi per ottenere i materiali di crittografia e ottenere i materiali di decrittografia siano separati, il comportamento è lo stesso.
**Input ** (dall'applicazione)
+ Una chiave di crittografia: deve essere una chiave simmetrica, ad esempio una chiave [Advanced Encryption Standard](https://tools.ietf.org/html/rfc3394.html) (AES).
+ Una chiave di firma: può essere una chiave simmetrica o una coppia di chiavi asimmetrica.
**Input** (dal componente di crittografia dell'item)
+ Contesto di [crittografia DynamoDB (](concepts.md#encryption-context)non utilizzato)
**Output** (sul componente di crittografia dell'item)
+ La chiave di crittografia passata come input.
+ La chiave di firma passata come input.
# Linguaggi di programmazione disponibili per Amazon DynamoDB Encryption Client
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Il client di crittografia Amazon DynamoDB è disponibile per i seguenti linguaggi di programmazione. Anche se ogni linguaggio ha delle librerie specifiche, le implementazioni risultanti sono interoperabili. Ad esempio, puoi crittografare (e firmare) un item con il client Java e decrittografarlo con il client Python.
Per maggiori informazioni, consulta l'argomento corrispondente.
**Topics**
+ [Java](java.md)
+ [Python](python.md)
# Client di crittografia Amazon DynamoDB per Java
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Questo argomento spiega come installare e utilizzare il client di crittografia Amazon DynamoDB per Java. [Per i dettagli sulla programmazione con il DynamoDB Encryption Client, consulta gli esempi [Java](java-examples.md), gli esempi nel repository GitHub su e [Javadoc](https://aws.github.io/aws-dynamodb-encryption-java/) per aws-dynamodb-encryption-java il DynamoDB Encryption Client.](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples)
**Nota**
Versioni 1. *x*. *x* del DynamoDB Encryption Client for Java entreranno in vigore gradualmente [end-of-support a luglio 2022](what-is-database-encryption-sdk.md#support). Effettua l'upgrade a una versione più recente il prima possibile.
**Topics**
+ [Prerequisiti](#java-prerequisites)
+ [Installazione](#java-installation)
+ [Utilizzo del client di crittografia DynamoDB per Java](java-using.md)
+ [Esempi di Java](java-examples.md)
## Prerequisiti
Prima di installare Amazon DynamoDB Encryption Client for Java, assicurati di avere i seguenti prerequisiti.
**Un ambiente di sviluppo Java**
È necessario Java 8 o versioni successive. Nel sito Web di Oracle, accedi alla pagina [Java SE Download](https://www.oracle.com/java/technologies/downloads/), quindi scarica e installa Java SE Development Kit (JDK).
Se utilizzi Oracle JDK, devi scaricare e installare anche [Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files](http://www.oracle.com/java/technologies/javase-jce8-downloads.html).
**AWS SDK per Java**
Il DynamoDB Encryption Client richiede il modulo DynamoDB di DynamoDB anche se AWS SDK per Java l'applicazione non interagisce con DynamoDB. Puoi installare l'intero SDK o solo questo modulo. Se utilizzi Maven, aggiungi `aws-java-sdk-dynamodb` al file `pom.xml`.
Per ulteriori informazioni sull'installazione e la configurazione di, vedere. AWS SDK per Java[AWS SDK per Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/getting-started.html)
## Installazione
Puoi installare Amazon DynamoDB Encryption Client for Java nei seguenti modi.
**Manualmente**
Per installare Amazon DynamoDB Encryption Client for Java, clona o scarica il repository. [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/) GitHub
**Utilizzo di Apache Maven**
Il client di crittografia Amazon DynamoDB per Java è disponibile [tramite Apache](https://maven.apache.org/) Maven con la seguente definizione di dipendenza.
```
com.amazonaws
aws-dynamodb-encryption-java
version-number
```
Dopo aver installato l'SDK, inizia esaminando il codice di esempio in questa guida e il client di crittografia [DynamoDB Javadoc](https://aws.github.io/aws-dynamodb-encryption-java/) attivo. GitHub
# Utilizzo del client di crittografia DynamoDB per Java
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Questo argomento spiega alcune funzionalità del DynamoDB Encryption Client in Java che potrebbero non essere presenti in altre implementazioni del linguaggio di programmazione.
[Per i dettagli sulla programmazione con il DynamoDB Encryption Client, consulta gli esempi [Java](java-examples.md), gli esempi in [the](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) GitHub on e Javadoc per `aws-dynamodb-encryption-java repository` il DynamoDB Encryption Client.](https://aws.github.io/aws-dynamodb-encryption-java/)
**Topics**
+ [Componenti di crittografia dell'item](#attribute-encryptor)
+ [Configurazione del comportamento di salvataggio](#save-behavior)
+ [Operazioni di attributo in Java](#attribute-actions-java)
+ [Sovrascrivere i nomi delle tabelle](#override-table-name)
## Item encryptors: e Dynamo AttributeEncryptor DBEncryptor
[Il DynamoDB Encryption Client in Java dispone di [due crittografi di elementi](DDBEC-legacy-concepts.md#item-encryptor): Dynamo di livello inferiore e. DBEncryptor [AttributeEncryptor](#attribute-encryptor)](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
`AttributeEncryptor`È una classe di supporto che consente di utilizzare [Dynamo](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) AWS SDK per Java con il `DynamoDB Encryptor` client DBMapper di crittografia DynamoDB. Quando utilizzi `AttributeEncryptor` con `DynamoDBMapper`, crittografa e firma in modo trasparente gli item quando li salvi. Inoltre, verifica e decrittografa in modo trasparente gli item quando li carichi.
## Configurazione del comportamento di salvataggio
È possibile utilizzare `AttributeEncryptor` and `DynamoDBMapper` per aggiungere o sostituire gli elementi della tabella con attributi solo firmati o crittografati e firmati. Per queste attività, ti consigliamo di configurare il servizio per utilizzare il comportamento di salvataggio `PUT`, come illustrato nell'esempio seguente. In caso contrario, potresti non riuscire a decrittografare i dati.
```
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Se si utilizza il comportamento di salvataggio predefinito, che aggiorna solo gli attributi modellati nell'elemento della tabella, gli attributi non modellati non vengono inclusi nella firma e non vengono modificati dalle scritture della tabella. Di conseguenza, nelle letture successive di tutti gli attributi, la firma non verrà convalidata, poiché non include attributi non modellati.
Puoi inoltre utilizzare il comportamento di salvataggio `CLOBBER`. Questo comportamento di salvataggio è identico al comportamento di salvataggio `PUT`, ma disabilita il blocco ottimistico e sovrascrive l'item nella tabella.
Per evitare errori di firma, il client di crittografia DynamoDB genera un'eccezione di runtime se una viene utilizzata con `AttributeEncryptor` un file che non è configurato con `DynamoDBMapper` un comportamento di salvataggio di o. `CLOBBER` `PUT`
Per vedere questo codice usato in un esempio, vedi [Usare Dynamo DBMapper](java-examples.md#java-example-dynamodb-mapper) e l'[AwsKmsEncryptedObjectesempio.java](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java) nel repository in. `aws-dynamodb-encryption-java` GitHub
## Operazioni di attributo in Java
Le [operazioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) determinano quali valori attributo sono crittografati e firmati, quali solo firmati e quali ignorati. [Il metodo utilizzato per specificare le azioni degli attributi dipende dal fatto che si utilizzi il comando `DynamoDBMapper` and o il `AttributeEncryptor` Dynamo di livello inferiore. DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
**Importante**
Dopo aver utilizzato le azioni degli attributi per crittografare gli elementi della tabella, l'aggiunta o la rimozione di attributi dal modello di dati potrebbe causare un errore di convalida della firma che impedisce di decrittografare i dati. Per una spiegazione dettagliata, consulta [Modifica del modello di dati](data-model.md).
### Azioni relative agli attributi per la Dynamo DBMapper
Quando utilizzi `DynamoDBMapper` e `AttributeEncryptor`, devi utilizzare le annotazioni per specificare le operazioni di attributo. Il DynamoDB Encryption Client utilizza le annotazioni [standard degli attributi DynamoDB che definiscono il tipo di attributo](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Annotations.html) per determinare come proteggere un attributo. Per impostazione predefinita, tutti gli attributi sono crittografati e firmati, tranne le chiavi primarie, che sono firmate ma non crittografate.
**Nota**
Non crittografate il valore degli attributi con l'[annotazione @Dynamo DBVersion Attribute](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptimisticLocking.html), anche se potete (e dovreste) firmarli. In caso contrario, le condizioni che utilizzano questo valore potrebbero avere effetti imprevisti.
```
// Attributes are encrypted and signed
@DynamoDBAttribute(attributeName="Description")
// Partition keys are signed but not encrypted
@DynamoDBHashKey(attributeName="Title")
// Sort keys are signed but not encrypted
@DynamoDBRangeKey(attributeName="Author")
```
Per specificare le eccezioni, utilizzate le annotazioni di crittografia definite nel DynamoDB Encryption Client for Java. Se le specifichi a livello di classe, diventano il valore predefinito per la classe.
```
// Sign only
@DoNotEncrypt
// Do nothing; not encrypted or signed
@DoNotTouch
```
Ad esempio, queste annotazioni firmano ma non crittografano l'attributo `PublicationYear` e non crittografano né firmano il valore attributo `ISBN`.
```
// Sign only (override the default)
@DoNotEncrypt
@DynamoDBAttribute(attributeName="PublicationYear")
// Do nothing (override the default)
@DoNotTouch
@DynamoDBAttribute(attributeName="ISBN")
```
### Azioni relative agli attributi per Dynamo DBEncryptor
Per specificare le azioni degli attributi quando utilizzate DBEncryptor direttamente [Dynamo](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html), create un `HashMap` oggetto in cui le coppie nome-valore rappresentino i nomi degli attributi e le azioni specificate.
I valori sono validi per le operazioni di attributo definite nel tipo enumerato `EncryptionFlags`. Puoi utilizzare `ENCRYPT` e `SIGN` insieme o solo `SIGN` o ometterle entrambe. Tuttavia, se si utilizza `ENCRYPT` da solo, il client di crittografia DynamoDB genera un errore. Non puoi crittografare un attributo non firmato.
```
ENCRYPT
SIGN
```
**avvertimento**
Non crittografare gli attributi che vengono usati per la chiave primaria. Devono rimanere in testo semplice in modo che DynamoDB possa trovare l'elemento senza eseguire una scansione completa della tabella.
Se si specifica una chiave primaria nel contesto di crittografia e quindi si specifica `ENCRYPT` nell'azione di attributo per uno degli attributi della chiave primaria, il client di crittografia DynamoDB genera un'eccezione.
Ad esempio, il seguente codice Java crea un codice `actions` HashMap che crittografa e firma tutti gli attributi dell'elemento. `record` Le eccezioni sono la chiave di partizione e gli attributi della chiave di ordinamento, che sono firmati ma non crittografati, e l'attributo `test`, che non è firmato o crittografato.
```
final EnumSet signOnly = EnumSet.of(EncryptionFlags.SIGN);
final EnumSet encryptAndSign = EnumSet.of(EncryptionFlags.ENCRYPT, EncryptionFlags.SIGN);
final Map> actions = new HashMap<>();
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName: // no break; falls through to next case
case sortKeyName:
// Partition and sort keys must not be encrypted, but should be signed
actions.put(attributeName, signOnly);
break;
case "test":
// Don't encrypt or sign
break;
default:
// Encrypt and sign everything else
actions.put(attributeName, encryptAndSign);
break;
}
}
```
Successivamente, quando chiami il metodo [encryptRecord](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html#encryptRecord-java.util.Map-java.util.Map-com.amazonaws.services.dynamodbv2.datamodeling.encryption.EncryptionContext-) del componente `DynamoDBEncryptor`, devi specificare la mappa come valore del parametro `attributeFlags`. Ad esempio, questa chiamata a `encryptRecord` utilizza la mappa `actions`.
```
// Encrypt the plaintext record
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
## Sovrascrivere i nomi delle tabelle
Nel DynamoDB Encryption Client, il nome della tabella DynamoDB è un elemento del contesto di crittografia [DynamoDB che viene passato ai metodi di crittografia e decrittografia](concepts.md#encryption-context). Quando si crittografano o si firmano gli elementi della tabella, il contesto di crittografia DynamoDB, incluso il nome della tabella, è associato crittograficamente al testo cifrato. Se il contesto di crittografia DynamoDB passato al metodo decrypt non corrisponde al contesto di crittografia DynamoDB passato al metodo encrypt, l'operazione di decrittografia ha esito negativo.
[Occasionalmente, il nome di una tabella cambia, ad esempio quando si esegue il backup di una tabella o si esegue un ripristino. point-in-time ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) Quando si decrittografa o si verifica la firma di questi elementi, è necessario passare nello stesso contesto di crittografia DynamoDB utilizzato per crittografare e firmare gli elementi, incluso il nome della tabella originale. Il nome della tabella corrente non è necessario.
Quando si utilizza`DynamoDBEncryptor`, si assembla manualmente il contesto di crittografia DynamoDB. Tuttavia, se si utilizza il`DynamoDBMapper`, `AttributeEncryptor` crea automaticamente il contesto di crittografia DynamoDB, incluso il nome della tabella corrente. Per comunicare a `AttributeEncryptor` di creare un contesto di crittografia con un nome di tabella diverso, utilizza `EncryptionContextOverrideOperator`.
Ad esempio, il codice seguente crea istanze del provider di materiali crittografici (CMP) e di `DynamoDBEncryptor`. Quindi chiama il metodo `setEncryptionContextOverrideOperator` di `DynamoDBEncryptor`. Utilizza l'operatore `overrideEncryptionContextTableName`, che sovrascrive il nome di una tabella. Quando è configurato in questo modo, `AttributeEncryptor` crea un contesto di crittografia DynamoDB che `newTableName` include al posto di. `oldTableName` [Per un esempio completo, consulta EncryptionContextOverridesWithDynamo DBMapper .java.](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/EncryptionContextOverridesWithDynamoDBMapper.java)
```
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
encryptor.setEncryptionContextOverrideOperator(EncryptionContextOperators.overrideEncryptionContextTableName(
oldTableName, newTableName));
```
Quando chiami il metodo di caricamento di `DynamoDBMapper`, che esegue la decrittografia e la verifica dell'item, devi specificare il nome della tabella originale.
```
mapper.load(itemClass, DynamoDBMapperConfig.builder()
.withTableNameOverride(DynamoDBMapperConfig.TableNameOverride.withTableNameReplacement(oldTableName))
.build());
```
Puoi anche utilizzare l'operatore `overrideEncryptionContextTableNameUsingMap`, che sovrascrive più nomi di tabella.
Gli operatori che sovrascrivono i nomi di tabella vengono in genere utilizzati per la decrittografia dei dati e la verifica delle firme. Tuttavia, è possibile utilizzarli per impostare il nome della tabella nel contesto di crittografia DynamoDB su un valore diverso durante la crittografia e la firma.
Non utilizzare operatori che sovrascrivono i nomi di tabella se utilizzi `DynamoDBEncryptor`. Crea invece un contesto di crittografia con il nome della tabella originale e invialo al metodo di decrittografia.
# Codice di esempio per il client di crittografia DynamoDB per Java
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Gli esempi seguenti mostrano come utilizzare il DynamoDB Encryption Client for Java per proteggere gli elementi della tabella DynamoDB nell'applicazione. Puoi trovare altri esempi (e contribuire con i tuoi) nella directory [examples](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) del repository su. [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/) GitHub
**Topics**
+ [Usare la Dynamo DBEncryptor](#java-example-ddb-encryptor)
+ [Usare Dynamo DBMapper](#java-example-dynamodb-mapper)
## Usare la Dynamo DBEncryptor
[Questo esempio mostra come utilizzare [Dynamo di livello inferiore con Direct KMS DBEncryptor Provider](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html).](direct-kms-provider.md) Il provider Direct KMS genera e protegge i suoi materiali crittografici con un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in () specificato dall'utente. AWS Key Management Service AWS KMS
Puoi utilizzare qualsiasi [fornitore di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) compatibile con`DynamoDBEncryptor`, e puoi utilizzare Direct KMS Provider con and. `DynamoDBMapper` [AttributeEncryptor](java-using.md#attribute-encryptor)
**[Guarda l'esempio di codice completo: .java AwsKmsEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedItem.java)**
Fase 1: creazione del provider KMS diretto
Crea un'istanza del AWS KMS client con la regione specificata. Quindi, usa l'istanza del client per creare un'istanza del Direct KMS Provider con la tua preferita AWS KMS key.
Questo esempio utilizza Amazon Resource Name (ARN) per identificare AWS KMS key, ma puoi utilizzare [qualsiasi identificatore di chiave valido](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html#find-cmk-id-arn).
```
final String keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
final String region = "us-west-2";
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
```
Fase 2: creazione di un item
Questo esempio definisce un elemento `record` HashMap che rappresenta un elemento di tabella di esempio.
```
final String partitionKeyName = "partition_attribute";
final String sortKeyName = "sort_attribute";
final Map record = new HashMap<>();
record.put(partitionKeyName, new AttributeValue().withS("value1"));
record.put(sortKeyName, new AttributeValue().withN("55"));
record.put("example", new AttributeValue().withS("data"));
record.put("numbers", new AttributeValue().withN("99"));
record.put("binary", new AttributeValue().withB(ByteBuffer.wrap(new byte[]{0x00, 0x01, 0x02})));
record.put("test", new AttributeValue().withS("test-value"));
```
Fase 3: Creare una dinamo DBEncryptor
Crea un'istanza del componente `DynamoDBEncryptor` con il provider KMS diretto.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
```
Fase 4: Creare un contesto di crittografia DynamoDB
Il contesto di [crittografia DynamoDB](concepts.md#encryption-context) contiene informazioni sulla struttura della tabella e su come viene crittografata e firmata. Se utilizzi il componente `DynamoDBMapper`, il componente `AttributeEncryptor` crea il contesto di crittografia per tuo conto.
```
final String tableName = "testTable";
final EncryptionContext encryptionContext = new EncryptionContext.Builder()
.withTableName(tableName)
.withHashKeyName(partitionKeyName)
.withRangeKeyName(sortKeyName)
.build();
```
Fase 5: creazione dell'oggetto delle operazioni di attributo.
Le [operazioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) determinano quali attributi dell'item sono crittografati e firmati, quali solo firmati e quali non sono né crittografati né firmati.
In Java, per specificare le azioni relative agli attributi, si crea una serie HashMap di coppie di nomi e `EncryptionFlags` valori degli attributi.
Ad esempio, il codice Java seguente crea un codice `actions` HashMap che crittografa e firma tutti gli attributi dell'`record`elemento, ad eccezione della chiave di partizione e degli attributi della chiave di ordinamento, che sono firmati ma non crittografati, e dell'`test`attributo, che non è firmato o crittografato.
```
final EnumSet signOnly = EnumSet.of(EncryptionFlags.SIGN);
final EnumSet encryptAndSign = EnumSet.of(EncryptionFlags.ENCRYPT, EncryptionFlags.SIGN);
final Map> actions = new HashMap<>();
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName: // fall through to the next case
case sortKeyName:
// Partition and sort keys must not be encrypted, but should be signed
actions.put(attributeName, signOnly);
break;
case "test":
// Neither encrypted nor signed
break;
default:
// Encrypt and sign all other attributes
actions.put(attributeName, encryptAndSign);
break;
}
}
```
Fase 6: crittografia e firma dell'item
Per crittografare e firmare l'item della tabella, chiama il metodo `encryptRecord` nell'istanza del componente `DynamoDBEncryptor`. Specifica l'item della tabella (`record`), le operazioni di attributo (`actions`) e il contesto di crittografia (`encryptionContext`).
```
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
Fase 7: Inserire l'elemento nella tabella DynamoDB
Infine, inserisci l'elemento crittografato e firmato nella tabella DynamoDB.
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.putItem(tableName, encrypted_record);
```
## Usare Dynamo DBMapper
[L'esempio seguente mostra come utilizzare la classe helper DynamoDB mapper con il provider Direct KMS.](direct-kms-provider.md) Il provider Direct KMS genera e protegge i suoi materiali crittografici con un [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in () specificato dall'utente. AWS Key Management Service AWS KMS
Puoi usare qualunque [provider di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) compatibile insieme al mappatore `DynamoDBMapper` e puoi utilizzare il provider KMS diretto con il componente `DynamoDBEncryptor` di livello inferiore.
**[Guarda l'esempio di codice completo: .java AwsKmsEncryptedObject](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java)**
Fase 1: creazione del provider KMS diretto
Crea un'istanza del AWS KMS client con la regione specificata. Quindi, usa l'istanza del client per creare un'istanza del Direct KMS Provider con la tua preferita AWS KMS key.
Questo esempio utilizza Amazon Resource Name (ARN) per identificare AWS KMS key, ma puoi utilizzare [qualsiasi identificatore di chiave valido](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id).
```
final String keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
final String region = "us-west-2";
final AWSKMS kms = AWSKMSClientBuilder.standard().withRegion(region).build();
final DirectKmsMaterialProvider cmp = new DirectKmsMaterialProvider(kms, keyArn);
```
Fase 2: Creare DynamoDB Encryptor e Dynamo DBMapper
Utilizza il provider Direct KMS creato nel passaggio precedente per creare un'istanza di [DynamoDB](java-using.md#attribute-encryptor) Encryptor. È necessario creare un'istanza del DynamoDB Encryptor di livello inferiore per utilizzare DynamoDB Mapper.
Successivamente, crea un'istanza del database DynamoDB e una configurazione mapper e usale per creare un'istanza del DynamoDB Mapper.
Quando utilizzi `DynamoDBMapper` per aggiungere o modificare item firmati (oppure crittografati e firmati), configuralo per [utilizzare un comportamento di salvataggio](java-using.md#save-behavior), ad esempio `PUT`, che includa tutti gli attributi, come mostrato nel seguente esempio. In caso contrario, potresti non riuscire a decrittografare i dati.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp)
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.standard().withRegion(region).build();
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Fase 3: Definizione della tabella DynamoDB
Successivamente, definisci la tua tabella DynamoDB. Per specificare le [operazioni di attributo](java-using.md#attribute-actions-java), utilizza le annotazioni. Questo esempio crea una tabella DynamoDB e `DataPoJo` una classe che rappresenta gli elementi della tabella`ExampleTable`.
In questo esempio, gli attributi della chiave primaria saranno firmati ma non crittografati. Ciò vale per l'attributo `partition_attribute`, che viene annotato con `@DynamoDBHashKey`, e per l'attributo `sort_attribute`, che viene annotato con `@DynamoDBRangeKey`.
Gli attributi annotati con `@DynamoDBAttribute`, ad esempio `some numbers`, saranno crittografati e firmati. Le eccezioni sono gli attributi che utilizzano le annotazioni di crittografia `@DoNotEncrypt` (solo firma) o `@DoNotTouch` (non crittografare o firmare) definite dal DynamoDB Encryption Client. Ad esempio, poiché l'attributo `leave me` ha un'annotazione `@DoNotTouch`, non sarà crittografato né firmato.
```
@DynamoDBTable(tableName = "ExampleTable")
public static final class DataPoJo {
private String partitionAttribute;
private int sortAttribute;
private String example;
private long someNumbers;
private byte[] someBinary;
private String leaveMe;
@DynamoDBHashKey(attributeName = "partition_attribute")
public String getPartitionAttribute() {
return partitionAttribute;
}
public void setPartitionAttribute(String partitionAttribute) {
this.partitionAttribute = partitionAttribute;
}
@DynamoDBRangeKey(attributeName = "sort_attribute")
public int getSortAttribute() {
return sortAttribute;
}
public void setSortAttribute(int sortAttribute) {
this.sortAttribute = sortAttribute;
}
@DynamoDBAttribute(attributeName = "example")
public String getExample() {
return example;
}
public void setExample(String example) {
this.example = example;
}
@DynamoDBAttribute(attributeName = "some numbers")
public long getSomeNumbers() {
return someNumbers;
}
public void setSomeNumbers(long someNumbers) {
this.someNumbers = someNumbers;
}
@DynamoDBAttribute(attributeName = "and some binary")
public byte[] getSomeBinary() {
return someBinary;
}
public void setSomeBinary(byte[] someBinary) {
this.someBinary = someBinary;
}
@DynamoDBAttribute(attributeName = "leave me")
@DoNotTouch
public String getLeaveMe() {
return leaveMe;
}
public void setLeaveMe(String leaveMe) {
this.leaveMe = leaveMe;
}
@Override
public String toString() {
return "DataPoJo [partitionAttribute=" + partitionAttribute + ", sortAttribute="
+ sortAttribute + ", example=" + example + ", someNumbers=" + someNumbers
+ ", someBinary=" + Arrays.toString(someBinary) + ", leaveMe=" + leaveMe + "]";
}
}
```
Fase 4: crittografia e salvataggio di un item della tabella
Ora, quando si crea un elemento della tabella e si utilizza DynamoDB Mapper per salvarlo, l'elemento viene automaticamente crittografato e firmato prima di essere aggiunto alla tabella.
In questo esempio viene definito un item della tabella denominato `record`. Prima che venga salvato nella tabella, i suoi attributi vengono crittografati e firmati in base alle annotazioni nella classe `DataPoJo`. In questo caso, tutti gli attributi eccetto `PartitionAttribute`, `SortAttribute` e `LeaveMe` sono crittografati e firmati. `PartitionAttribute` e `SortAttributes` sono solo firmati. L'attributo `LeaveMe` non è crittografato né firmato.
Per crittografare e firmare l'item `record` e aggiungerlo alla tabella `ExampleTable`, chiama il metodo `save` della classe `DynamoDBMapper`. Poiché DynamoDB Mapper è configurato per utilizzare `PUT` il comportamento di salvataggio, l'elemento sostituisce qualsiasi elemento con le stesse chiavi primarie, anziché aggiornarlo. In questo modo le firme corrispondono ed è possibile decrittografare l'item quando si ottiene dalla tabella.
```
DataPoJo record = new DataPoJo();
record.setPartitionAttribute("is this");
record.setSortAttribute(55);
record.setExample("data");
record.setSomeNumbers(99);
record.setSomeBinary(new byte[]{0x00, 0x01, 0x02});
record.setLeaveMe("alone");
mapper.save(record);
```
# Client di crittografia DynamoDB per Python
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Questo argomento spiega come installare e utilizzare il client di crittografia DynamoDB per Python. Puoi trovare il codice nel [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)repository su GitHub, incluso [codice di esempio](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) completo e testato per aiutarti a iniziare.
**Nota**
Versioni 1. *x*. *x* e 2. *x*. *x* [del DynamoDB Encryption Client for Python entreranno in vigore a luglio 2022. end-of-support ](what-is-database-encryption-sdk.md#support) Effettua l'upgrade a una versione più recente il prima possibile.
**Topics**
+ [Prerequisiti](#python-prerequisites)
+ [Installazione](#python-installation)
+ [Utilizzo del client di crittografia DynamoDB per Python](python-using.md)
+ [Esempi di Python](python-examples.md)
## Prerequisiti
Prima di installare il client di crittografia Amazon DynamoDB per Python, assicurati di avere i seguenti prerequisiti.
**Una versione supportata di Python**
Python 3.8 o versioni successive è richiesto dalle versioni 3.3.0 e successive di Amazon DynamoDB Encryption Client for Python. Per scaricare Python, consulta la pagina relativa ai [download di Python](https://www.python.org/downloads/).
Le versioni precedenti di Amazon DynamoDB Encryption Client for Python supportano Python 2.7 e Python 3.4 e versioni successive, ma consigliamo di utilizzare la versione più recente di DynamoDB Encryption Client.
**Lo strumento di installazione pip per Python**
Python 3.6 e versioni successive includono **pip**, anche se potresti volerlo aggiornare. Per ulteriori informazioni sull'aggiornamento o sull'installazione di pip, consulta la sezione relativa all'[installazione](https://pip.pypa.io/en/latest/installation/) nella documentazione su **pip**.
## Installazione
Usa **pip** per installare il client di crittografia Amazon DynamoDB per Python, come mostrato negli esempi seguenti.
**Per installare la versione più recente**
```
pip install dynamodb-encryption-sdk
```
Per ulteriori dettagli sull'utilizzo di **pip** per installare e aggiornare pacchetti, consulta la sezione relativa all'[installazione dei pacchetti](https://packaging.python.org/tutorials/installing-packages/).
Il DynamoDB Encryption Client richiede la libreria di crittografia su [tutte le piattaforme](https://cryptography.io/en/latest/). Tutte le versioni di **pip** installano e creano la libreria di **crittografia** su Windows. **pip** 8.1 e le versioni successive installano e creano la libreria di **crittografia** su Linux. Se utilizzi una versione precedente di **pip** e il tuo ambiente Linux non possiede gli strumenti necessari per creare la libreria di **crittografia**, devi installarli. Per ulteriori informazioni, consulta la sezione relativa alla [creazione di una crittografia in Linux](https://cryptography.io/en/latest/installation/#building-cryptography-on-linux).
È possibile scaricare l'ultima versione di sviluppo del DynamoDB Encryption Client dal [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)repository in poi. GitHub
Dopo aver installato il DynamoDB Encryption Client, inizia a guardare l'esempio di codice Python in questa guida.
# Utilizzo del client di crittografia DynamoDB per Python
**Nota**
[La nostra libreria di crittografia lato client è stata rinominata Database Encryption SDK. AWS](DDBEC-rename.md) Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Questo argomento spiega alcune funzionalità del DynamoDB Encryption Client for Python che potrebbero non essere presenti in altre implementazioni del linguaggio di programmazione. Queste funzionalità sono progettate per semplificare l'utilizzo del DynamoDB Encryption Client nel modo più sicuro. Ti consigliamo di utilizzarle a meno che il tuo caso d'uso non sia insolito.
Per i dettagli sulla programmazione con il DynamoDB Encryption Client, consulta gli esempi in [Python](python-examples.md) in questa guida, gli esempi nel repository GitHub su e [la documentazione](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) [Python](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/) per aws-dynamodb-encryption-python il DynamoDB Encryption Client.
**Topics**
+ [Classi helper del client](#python-helpers)
+ [TableInfo classe](#table-info)
+ [Operazioni di attributo in Python](#python-attribute-actions)
## Classi helper del client
Il client di crittografia DynamoDB per Python include diverse classi di supporto client che rispecchiano le classi Boto 3 per DynamoDB. Queste classi di supporto sono progettate per semplificare l'aggiunta di crittografia e firma all'applicazione DynamoDB esistente ed evitare i problemi più comuni, come segue:
+ Impedite di crittografare la chiave primaria del vostro elemento, aggiungendo un'azione di override per la chiave primaria all'oggetto o generando un'eccezione se l'[AttributeActions](#python-attribute-actions)oggetto dice esplicitamente al client di crittografare `AttributeActions` la chiave primaria. Se l'azione predefinita nell'oggetto `AttributeActions` è `DO_NOTHING`, le classi helper del client utilizzano tale azione per la chiave primaria. Altrimenti, utilizzano `SIGN_ONLY`.
+ Crea un [TableInfo oggetto](#python-helpers) e popola il contesto di [crittografia DynamoDB in base a una chiamata a DynamoDB](concepts.md#encryption-context). Questo aiuta a garantire che il contesto di crittografia DynamoDB sia accurato e che il client possa identificare la chiave primaria.
+ Supporta metodi, come `put_item` and`get_item`, che crittografano e decrittografano in modo trasparente gli elementi della tabella quando scrivi o leggi da una tabella DynamoDB. L'unico metodo non supportato è `update_item`.
Puoi utilizzare le classi helper del client al posto dell'interazione diretta con il [componente di crittografia dell'item](DDBEC-legacy-concepts.md#item-encryptor) di livello inferiore. Utilizza queste classi a meno che non sia necessario impostare opzioni avanzate nel componente di crittografia dell'item.
Le classi helper del client includono:
+ [EncryptedTable](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/table.html#module-dynamodb_encryption_sdk.encrypted.table)per le applicazioni che utilizzano la risorsa [Table](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#table) in DynamoDB per elaborare una tabella alla volta.
+ [EncryptedResource](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/resource.html)per le applicazioni che utilizzano la classe [Service Resource](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#service-resource) in DynamoDB per l'elaborazione in batch.
+ [EncryptedClient](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/client.html)per applicazioni che utilizzano il [client di livello inferiore](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#client) in DynamoDB.
Per utilizzare le classi client helper, il chiamante deve avere l'autorizzazione a chiamare l'operazione DynamoDB sulla tabella di destinazione [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html).
## TableInfo classe
La [TableInfo](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/tools/structures.html#dynamodb_encryption_sdk.structures.TableInfo)classe è una classe di supporto che rappresenta una tabella DynamoDB, completa di campi per la chiave primaria e gli indici secondari. Ti consente di ottenere informazioni precise e in tempo reale sulla tabella.
Se utilizzi una [classe helper del client](#python-helpers), questa crea e utilizza un oggetto `TableInfo` per tuo conto. Altrimenti, puoi crearne uno esplicitamente. Per vedere un esempio, consulta [Utilizzo del componente di crittografia dell'item](python-examples.md#python-example-item-encryptor).
Quando si chiama il `refresh_indexed_attributes` metodo su un `TableInfo` oggetto, popola i valori delle proprietà dell'oggetto chiamando l'operazione DynamoDB [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). L'esecuzione di query sulla tabella è molto più affidabile rispetto all'impostazione come hardcoded dei nomi di indice. La `TableInfo` classe include anche una `encryption_context_values` proprietà che fornisce i valori richiesti per il contesto di crittografia [DynamoDB](concepts.md#encryption-context).
Per utilizzare il `refresh_indexed_attributes` metodo, il chiamante deve avere il permesso di chiamare l'operazione [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB sulla tabella di destinazione.
## Operazioni di attributo in Python
Le [operazioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) comunicano al componente di crittografia dell'item quali operazioni effettuare su ciascun attributo dell'item. Per specificare le operazioni di attributo in Python, creare un oggetto `AttributeActions` con un'operazione predefinita ed eventuali eccezioni per determinati attributi. I valori validi vengono definiti nel tipo enumerato `CryptoAction`.
**Importante**
Dopo aver utilizzato le azioni degli attributi per crittografare gli elementi della tabella, l'aggiunta o la rimozione di attributi dal modello di dati potrebbe causare un errore di convalida della firma che impedisce di decrittografare i dati. Per una spiegazione dettagliata, consulta [Modifica del modello di dati](data-model.md).
```
DO_NOTHING = 0
SIGN_ONLY = 1
ENCRYPT_AND_SIGN = 2
```
Ad esempio, questo oggetto `AttributeActions` stabilisce l'operazione `ENCRYPT_AND_SIGN` come predefinita per tutti gli attributi e specifica le eccezioni per gli attributi `ISBN` e `PublicationYear`.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={
'ISBN': CryptoAction.DO_NOTHING,
'PublicationYear': CryptoAction.SIGN_ONLY
}
)
```
Se utilizzi una [classe helper del client](#python-helpers), non è necessario specificare un'operazione di attributo per gli attributi della chiave primaria. Le classi helper del client impediscono la crittografia della chiave primaria.
Se non utilizzi una classe helper del client e l'operazione predefinita è `ENCRYPT_AND_SIGN`, devi specificare un'operazione per la chiave primaria. L'operazione consigliata per le chiavi primarie è `SIGN_ONLY`. Per semplificare la procedura, utilizza il metodo `set_index_keys`, che utilizza l'operazione SIGN\$1ONLY per le chiavi primarie o l'operazione DO\$1NOTHING quando questa è impostata come operazione predefinita.
**avvertimento**
Non crittografare gli attributi che vengono usati per la chiave primaria. Devono rimanere in testo semplice in modo che DynamoDB possa trovare l'elemento senza eseguire una scansione completa della tabella.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
)
actions.set_index_keys(*table_info.protected_index_keys())
```
# Codice di esempio per il client di crittografia DynamoDB per Python
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Gli esempi seguenti mostrano come utilizzare il DynamoDB Encryption Client for Python per proteggere i dati DynamoDB nella tua applicazione. Puoi trovare altri esempi (e contribuire con i tuoi) nella directory [examples](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) del repository su. [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/) GitHub
**Topics**
+ [Usa la classe EncryptedTable client helper](#python-example-table)
+ [Utilizzo del componente di crittografia dell'item](#python-example-item-encryptor)
## Usa la classe EncryptedTable client helper
L'esempio seguente mostra come utilizzare il [provider KMS diretto](direct-kms-provider.md) con la `EncryptedTable` [classe helper del client](python-using.md#python-helpers). Questo esempio utilizza lo stesso [provider di materiali crittografici](DDBEC-legacy-concepts.md#concept-material-provider) dell'esempio [Utilizzo del componente di crittografia dell'item](#python-example-item-encryptor) seguente. Tuttavia, utilizza la classe `EncryptedTable` invece di interagire direttamente con il [componente di crittografia dell'item](DDBEC-legacy-concepts.md#item-encryptor) di livello inferiore.
Confrontando questi esempi, puoi visualizzare il lavoro che la classe helper del client esegue per tuo conto. Ciò include la creazione del contesto di [crittografia DynamoDB](concepts.md#encryption-context) e la verifica che gli attributi della chiave primaria siano sempre firmati, ma mai crittografati. Per creare il contesto di crittografia e scoprire la chiave primaria, le classi client helper chiamano l'operazione DynamoDB [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html). Per eseguire questo codice, devi disporre dell'autorizzazione per chiamare questa operazione.
**Consulta l'esempio di codice completo**: [aws\$1kms\$1encrypted\$1table.py](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_table.py)
Fase 1: creazione della tabella
Inizia creando un'istanza di una tabella DynamoDB standard con il nome della tabella.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Fase 2: creazione di un provider di materiali crittografici
Crea un'istanza del [provider di materiali crittografici](crypto-materials-providers.md) (cryptographic materials provider, CMP) selezionato.
Questo esempio utilizza il [provider KMS diretto](direct-kms-provider.md), ma puoi utilizzare qualunque CMP compatibile. Per creare un provider Direct KMS, specifica un. [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) Questo esempio utilizza l'Amazon Resource Name (ARN) di AWS KMS key, ma puoi utilizzare qualsiasi identificatore di chiave valido.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Fase 3: creazione dell'oggetto delle operazioni di attributo.
Le [operazioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) comunicano al componente di crittografia dell'item quali operazioni effettuare su ciascun attributo dell'item. L'oggetto `AttributeActions` in questo esempio crittografa e firma tutti gli item tranne l'attributo `test`, che viene ignorato.
Non devi specificare operazioni di attributo per gli attributi della chiave primaria quando utilizzi una classe helper del client. La classe `EncryptedTable` firma gli attributi della chiave primaria, ma non li crittografa mai.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
```
Fase 4: creazione della tabella crittografata
Crea la tabella criptata utilizzando la tabella standard, il provider KMS diretto e le operazioni di attributo. Questa fase completa la configurazione.
```
encrypted_table = EncryptedTable(
table=table,
materials_provider=kms_cmp,
attribute_actions=actions
)
```
Fase 5: inserimento dell'item non crittografato nella tabella
Quando si chiama il `put_item` metodo su`encrypted_table`, gli elementi della tabella vengono crittografati, firmati e aggiunti in modo trasparente alla tabella DynamoDB.
Come prima cosa, definisci l'item della tabella.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_attribute': 55
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Inseriscilo quindi nella tabella.
```
encrypted_table.put_item(Item=plaintext_item)
```
Per ottenere l'elemento dalla tabella DynamoDB nella sua forma crittografata, chiamate `get_item` il metodo sull'oggetto. `table` Per ottenere l'item decrittografato, chiama il metodo `get_item` nell'oggetto `encrypted_table`.
## Utilizzo del componente di crittografia dell'item
Questo esempio mostra come interagire direttamente con l'[elemento encryptor nel DynamoDB Encryptor](DDBEC-legacy-concepts.md#item-encryptor) Client durante la crittografia degli elementi della tabella, invece di utilizzare le [classi client helper che interagiscono con l'crittografo degli elementi per](python-using.md#python-helpers) te.
Quando si utilizza questa tecnica, si creano manualmente il contesto di crittografia DynamoDB e l'oggetto `CryptoConfig` di configurazione (). Inoltre, si crittografano gli elementi in una chiamata e li si inserisce nella tabella DynamoDB in una chiamata separata. Ciò consente di personalizzare `put_item` le chiamate e utilizzare il DynamoDB Encryption Client per crittografare e firmare dati strutturati che non vengono mai inviati a DynamoDB.
Questo esempio utilizza il [provider KMS diretto](direct-kms-provider.md), ma puoi utilizzare qualunque CMP compatibile.
**Consulta l'esempio di codice completo**: [aws\$1kms\$1encrypted\$1item.py](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_item.py)
Fase 1: creazione della tabella
Inizia creando un'istanza di una risorsa di tabella DynamoDB standard con il nome della tabella.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Fase 2: creazione di un provider di materiali crittografici
Crea un'istanza del [provider di materiali crittografici](crypto-materials-providers.md) (cryptographic materials provider, CMP) selezionato.
Questo esempio utilizza il [provider KMS diretto](direct-kms-provider.md), ma puoi utilizzare qualunque CMP compatibile. Per creare un provider Direct KMS, specifica un. [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) Questo esempio utilizza l'Amazon Resource Name (ARN) di AWS KMS key, ma puoi utilizzare qualsiasi identificatore di chiave valido.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Passaggio 3: usa la classe helper TableInfo
Per ottenere informazioni sulla tabella da DynamoDB, create un'istanza della [TableInfo](python-using.md#python-helpers)classe helper. Quando lavori direttamente con il componente di crittografia dell'item, devi creare un'istanza `TableInfo` e chiamarne i metodi. Le [classi helper del client](python-using.md#python-helpers) eseguono questa operazione per tuo conto.
Il `refresh_indexed_attributes` metodo `TableInfo` utilizza l'operazione [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB per ottenere informazioni accurate e in tempo reale sulla tabella. Queste comprendono la chiave primaria e gli indici secondari locali e globali. L'intermediario deve disporre dell'autorizzazione a chiamare `DescribeTable`.
```
table_info = TableInfo(name=table_name)
table_info.refresh_indexed_attributes(table.meta.client)
```
Fase 4: Creare il contesto di crittografia DynamoDB
Il contesto di [crittografia DynamoDB](concepts.md#encryption-context) contiene informazioni sulla struttura della tabella e su come viene crittografata e firmata. Questo esempio crea un contesto di crittografia DynamoDB in modo esplicito, poiché interagisce con l'elemento encryptor. Le [classi client helper creano automaticamente](python-using.md#python-helpers) il contesto di crittografia DynamoDB.
Per ottenere la chiave di partizione e la chiave di ordinamento, puoi utilizzare le proprietà della classe helper. [TableInfo](python-using.md#python-helpers)
```
index_key = {
'partition_attribute': 'value1',
'sort_attribute': 55
}
encryption_context = EncryptionContext(
table_name=table_name,
partition_key_name=table_info.primary_index.partition,
sort_key_name=table_info.primary_index.sort,
attributes=dict_to_ddb(index_key)
)
```
Fase 5: creazione dell'oggetto delle operazioni di attributo.
Le [operazioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) comunicano al componente di crittografia dell'item quali operazioni effettuare su ciascun attributo dell'item. L'oggetto `AttributeActions` in questo esempio crittografa e firma tutti gli item tranne gli attributi della chiave primaria, che vengono firmati ma non crittografati, e l'attributo `test`, che viene ignorato.
Quando interagisci direttamente con il componente di crittografia dell'item e l'operazione predefinita è `ENCRYPT_AND_SIGN`, devi specificare un'operazione alternativa per la chiave primaria. Puoi utilizzare il metodo `set_index_keys`, che utilizza `SIGN_ONLY` per la chiave primaria o `DO_NOTHING` se questa è l'operazione predefinita.
Per specificare la chiave primaria, questo esempio utilizza le chiavi di indice nell'[TableInfo](python-using.md#python-helpers)oggetto, che viene popolato da una chiamata a DynamoDB. Questa tecnica è più sicura rispetto all'impostazione come hardcoded dei nomi della chiave primaria.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
actions.set_index_keys(*table_info.protected_index_keys())
```
Fase 6: creazione della configurazione dell'item
Per configurare il client di crittografia DynamoDB, utilizza gli oggetti appena creati in [CryptoConfig](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/config.html)una configurazione per l'elemento della tabella. Le classi client helper lo creano per te. CryptoConfig
```
crypto_config = CryptoConfig(
materials_provider=kms_cmp,
encryption_context=encryption_context,
attribute_actions=actions
)
```
Fase 7: crittografia dell'item
Questo passaggio crittografa e firma l'elemento, ma non lo inserisce nella tabella DynamoDB.
Quando si utilizza una classe client helper, gli elementi vengono crittografati e firmati in modo trasparente e quindi aggiunti alla tabella DynamoDB quando si chiama il `put_item` metodo della classe helper. Quando utilizzi direttamente il componente di crittografia dell'item, le operazioni di crittografia e di inserimento sono indipendenti.
Crea prima un item non crittografato.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_key': 55,
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Poi, crittografalo e firmalo. Il metodo `encrypt_python_item` richiede l'oggetto di configurazione `CryptoConfig`.
```
encrypted_item = encrypt_python_item(plaintext_item, crypto_config)
```
Fase 8: inserimento dell'item nella tabella
Questo passaggio inserisce l'elemento crittografato e firmato nella tabella DynamoDB.
```
table.put_item(Item=encrypted_item)
```
Per visualizzare l'item crittografato, chiama il metodo `get_item` nell'oggetto `table` originale, invece che nell'oggetto `encrypted_table`. Il metodo ottiene l'item dalla tabella DynamoDB senza verificarlo né decrittografarlo.
```
encrypted_item = table.get_item(Key=partition_key)['Item']
```
L'immagine seguente mostra parte di un esempio di item della tabella crittografato e firmato.
I valori dell'attributo crittografato sono dati binari. I nomi e i valori degli attributi della chiave primaria (`partition_attribute` e `sort_attribute`) e l'attributo `test` restano non crittografati. L'output mostra anche l'attributo che contiene la firma (`*amzn-ddb-map-sig*`) e l'[attributo di descrizione del materiale](DDBEC-legacy-concepts.md#legacy-material-description) (`*amzn-ddb-map-desc*`).
![\[Un estratto di un item crittografato e firmato\]](http://docs.aws.amazon.com/it_it/database-encryption-sdk/latest/devguide/images/encrypted-item-closeup.png)
# Modifica del modello di dati
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Ogni volta che si crittografa o decrittografa un elemento, è necessario fornire [azioni di attributo](DDBEC-legacy-concepts.md#legacy-attribute-actions) che indichino al DynamoDB Encryption Client quali attributi crittografare e firmare, quali attributi firmare (ma non crittografare) e quali ignorare. Le azioni degli attributi non vengono salvate nell'elemento crittografato e il DynamoDB Encryption Client non aggiorna automaticamente le azioni degli attributi.
**Importante**
Il DynamoDB Encryption Client non supporta la crittografia dei dati delle tabelle DynamoDB esistenti e non crittografati.
Ogni volta che modifichi il modello di dati, ovvero quando aggiungi o rimuovi attributi dagli item della tabella, rischi di incorrere un errore. Se le operazioni di attributo specificate non valgono per tutti gli attributi nell'item, l'item potrebbe non essere crittografato e firmato secondo le tue intenzioni. E, cosa più importante, se le operazioni di attributo che fornisci quando decrittografi un item sono diverse da quelle che hai fornito quando lo hai crittografato, la verifica della firma potrebbe non andare a buon fine.
Ad esempio, se le operazioni di attributo usate per crittografare l'item gli comunicano di firmare l'attributo `test`, la firma nell'item comprenderà l'attributo `test`. Ma se le operazioni di attributo usate per decrittografare l'item non valgono per l'attributo `test`, la verifica non andrà a buon fine, perché il client proverà a verificare una firma che non comprende l'attributo `test`.
Questo è un problema particolare quando più applicazioni leggono e scrivono gli stessi elementi di DynamoDB, perché il DynamoDB Encryption Client deve calcolare la stessa firma per gli elementi in tutte le applicazioni. È anche un problema per qualsiasi applicazione distribuita perché le modifiche nelle operazioni di attributo devono propagarsi a tutti gli host. Anche se alle tabelle DynamoDB accede un solo host in un unico processo, stabilire una procedura basata sulle best practice aiuterà a prevenire gli errori nel caso in cui il progetto dovesse diventare più complesso.
Per evitare errori di convalida delle firme che impediscono la lettura degli item della tabella, utilizza le istruzioni riportate di seguito.
+ [Aggiungere un attributo](#add-attribute): se il nuovo attributo modifica le azioni dell'attributo, implementa completamente la modifica dell'azione dell'attributo prima di includere il nuovo attributo in un elemento.
+ [Rimozione di un attributo](#remove-attribute): se smetti di utilizzare un attributo nei tuoi articoli, non modificare le azioni relative agli attributi.
+ Modifica dell'azione: dopo aver utilizzato una configurazione delle azioni degli attributi per crittografare gli elementi della tabella, non è possibile modificare in modo sicuro l'azione predefinita o l'azione per un attributo esistente senza crittografare nuovamente ogni elemento della tabella.
Gli errori di convalida delle firme possono essere estremamente difficili da risolvere, quindi l'approccio migliore è prevenirli.
**Topics**
+ [Aggiunta di un attributo](#add-attribute)
+ [Rimozione di un attributo](#remove-attribute)
## Aggiunta di un attributo
Quando aggiungi un nuovo attributo agli item della tabella, potrebbe essere necessario modificare le operazioni di attributo. Per evitare errori di convalida delle firme, ti consigliamo di implementare questa modifica in un processo a due fasi. Verifica che la prima fase sia completata prima di iniziare la seconda fase.
1. Modifica le operazioni di attributo in tutte le applicazioni che leggono o scrivono nella tabella. Distribuisci queste modifiche e conferma che l'aggiornamento è stato propagato a tutti gli host di destinazione.
1. Scrivi i valori nel nuovo attributo negli item della tabella.
Questo approccio in due fasi garantisce che tutte le applicazioni e gli host abbiano le stesse operazioni di attributo e calcolerà la stessa firma prima che qualsiasi elemento incontri il nuovo attributo. Ciò è importante anche quando l'operazione di attributo è *Non fare nulla* (non crittografare o firmare), perché l'impostazione predefinita per alcuni sistemi di crittografia è crittografare e firmare.
Negli esempi seguenti viene illustrato il codice per la prima fase di questo processo. Viene aggiunto un nuovo attributo dell’item, `link`, che memorizza un collegamento a un altro item della tabella. Poiché questo collegamento deve rimanere in testo normale, l'esempio assegna l'operazione di sola firma. Dopo aver distribuito completamente questa modifica e aver verificato che tutte le applicazioni e gli host abbiano le nuove operazioni di attributo, puoi iniziare a utilizzare l'attributo `link` negli item della tabella.
------
#### [ Java DynamoDB Mapper ]
Quando utilizzi `DynamoDB Mapper` e `AttributeEncryptor`, per impostazione predefinita, tutti gli attributi sono crittografati e firmati, tranne le chiavi primarie, che sono firmate ma non crittografate. Per specificare un'operazione di sola firma, utilizza l'annotazione `@DoNotEncrypt`.
In questo esempio viene utilizzata l'annotazione `@DoNotEncrypt` per il nuovo attributo `link`.
```
@DynamoDBTable(tableName = "ExampleTable")
public static final class DataPoJo {
private String partitionAttribute;
private int sortAttribute;
private String link;
@DynamoDBHashKey(attributeName = "partition_attribute")
public String getPartitionAttribute() {
return partitionAttribute;
}
public void setPartitionAttribute(String partitionAttribute) {
this.partitionAttribute = partitionAttribute;
}
@DynamoDBRangeKey(attributeName = "sort_attribute")
public int getSortAttribute() {
return sortAttribute;
}
public void setSortAttribute(int sortAttribute) {
this.sortAttribute = sortAttribute;
}
@DynamoDBAttribute(attributeName = "link")
@DoNotEncrypt
public String getLink() {
return link;
}
public void setLink(String link) {
this.link = link;
}
@Override
public String toString() {
return "DataPoJo [partitionAttribute=" + partitionAttribute + ",
sortAttribute=" + sortAttribute + ",
link=" + link + "]";
}
}
```
------
#### [ Java DynamoDB encryptor ]
Nel criptatore DynamoDB di livello inferiore, è necessario impostare azioni per ogni attributo. In questo esempio viene utilizzata un'istruzione switch in cui l'impostazione predefinita è `encryptAndSign` e vengono specificate eccezioni per la chiave di partizione, la chiave di ordinamento e il nuovo attributo `link`. In questo esempio, se il codice attributo di collegamento non è stato distribuito completamente prima dell'utilizzo, l'attributo di collegamento verrà crittografato e firmato da alcune applicazioni, mentre verrà solo firmato da altre applicazioni.
```
for (final String attributeName : record.keySet()) {
switch (attributeName) {
case partitionKeyName:
// fall through to the next case
case sortKeyName:
// partition and sort keys must be signed, but not encrypted
actions.put(attributeName, signOnly);
break;
case "link":
// only signed
actions.put(attributeName, signOnly);
break;
default:
// Encrypt and sign all other attributes
actions.put(attributeName, encryptAndSign);
break;
}
}
```
------
#### [ Python ]
Nel DynamoDB Encryption Client for Python, è possibile specificare un'azione predefinita per tutti gli attributi e quindi specificare le eccezioni.
Se utilizzi una [classe helper del client](python-using.md#python-helpers) Python, non devi specificare un'operazione di attributo per gli attributi della chiave primaria. Le classi helper del client impediscono la crittografia della chiave primaria. Tuttavia, se utilizzi una classe helper del client, devi impostare l'operazione SIGN\$1ONLY sulla chiave di partizione e la chiave di ordinamento. Se esegui accidentalmente la crittografia della partizione o della chiave di ordinamento, non potrai recuperare i dati senza una scansione completa della tabella.
In questo esempio viene specificata un'eccezione per il nuovo attributo `link`, che ottiene l'operazione `SIGN_ONLY`.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={
'example': CryptoAction.DO_NOTHING,
'link': CryptoAction.SIGN_ONLY
}
)
```
------
## Rimozione di un attributo
Se non è più necessario un attributo negli elementi che sono stati crittografati con il DynamoDB Encryption Client, è possibile smettere di utilizzare l'attributo. Tuttavia, non eliminare o modificare l'operazione per tale attributo. In tal caso, se viene riscontrato un item con tale attributo, la firma calcolata per l'item non corrisponderà alla firma originale e la convalida della firma avrà esito negativo.
Anche se potresti essere tentato di rimuovere tutte le tracce dell'attributo dal tuo codice, aggiungi un commento che indica che l'item non è più utilizzato invece di eliminarlo. Anche se esegui una scansione completa della tabella per eliminare tutte le istanze dell'attributo, un item crittografato con tale attributo potrebbe essere memorizzato nella cache o in fase di elaborazione in qualche punto della configurazione.
# Risoluzione dei problemi nell'applicazione DynamoDB Encryption Client
**Nota**
La nostra libreria di crittografia lato client è stata [rinominata](DDBEC-rename.md) Database Encryption SDK. AWS Il seguente argomento fornisce informazioni sulle versioni 1. *x* —2. *x* del DynamoDB Encryption Client for Java e versioni 1. *x —3.* *x* del client di crittografia DynamoDB per Python. Per ulteriori informazioni, consulta [AWS Database Encryption SDK per il supporto della versione DynamoDB](legacy-dynamodb-encryption-client.md#legacy-support).
Questa sezione descrive i problemi che si possono incontrare durante l'utilizzo del DynamoDB Encryption Client e offre suggerimenti per risolverli.
Per fornire feedback sul DynamoDB Encryption Client, segnala un problema nel [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/)repository or. [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/) GitHub
Per fornire feedback su questa documentazione, utilizzare il link di feedback in qualsiasi pagina.
**Topics**
+ [Accesso negato](#kms-permissions)
+ [La verifica della firma non va a buon fine](#change-data-model)
+ [Problemi con le tabelle globali delle versioni precedenti](#fix-global-tables)
+ [Scarse prestazioni del provider più recente](#mrp-ttl-delay)
## Accesso negato
**Problema**: la tua applicazione non può accedere a una risorsa necessaria.
**Suggerimento**: scopri le autorizzazioni richieste e aggiungile al contesto di sicurezza in cui opera la tua applicazione.
**Dettagli**
Per eseguire un'applicazione che utilizza la libreria DynamoDB Encryption Client, il chiamante deve disporre dell'autorizzazione per utilizzarne i componenti. In caso contrario, le applicazioni non potranno accedere agli elementi richiesti.
+ Il client di crittografia DynamoDB non richiede un account Amazon Web Services AWS() né dipende da alcun servizio. AWS Tuttavia, se l'applicazione utilizza l'account AWS, è necessario disporre di [un](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) [utente Account AWS and che disponga dell'autorizzazione](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) per utilizzare l'account.
+ Il client di crittografia DynamoDB non richiede Amazon DynamoDB. Tuttavia, se l'applicazione che utilizza il client crea tabelle DynamoDB, inserisce elementi in una tabella o ottiene elementi da una tabella, il chiamante deve avere l'autorizzazione per utilizzare le operazioni DynamoDB richieste nel tuo. Account AWS Per i dettagli, consulta gli [argomenti sul controllo degli accessi](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-overview.html) nella *Amazon DynamoDB Developer Guide*.
+ Se l'applicazione utilizza una [classe client helper](python-using.md#python-helpers) nel client di crittografia DynamoDB per Python, il chiamante deve avere l'autorizzazione per chiamare l'operazione DynamoDB. [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)
+ Il client di crittografia DynamoDB non AWS Key Management Service richiede ().AWS KMS[Tuttavia, se l'applicazione utilizza un [Direct KMS Materials Provider o utilizza un fornitore](direct-kms-provider.md)[più recente con un provider](most-recent-provider.md) store che utilizza Direct KMS Materials Provider AWS KMS, il chiamante deve essere autorizzato a utilizzare le AWS KMS[GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)operazioni e Decrypt.](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
## La verifica della firma non va a buon fine
**Problema**: un item non può essere decrittografato perché la verifica della firma non va a buon fine. L'item potrebbe anche non essere crittografato e firmato secondo le tue intenzioni.
**Suggerimento**: assicurati che tutte le operazioni di attributo valgano per tutti gli attributi dell'item. Quando decrittografi un item, assicurati di fornire operazioni di attributo che corrispondano a quelle utilizzate per crittografare l'item.
**Dettagli**
[Le azioni relative agli attributi](DDBEC-legacy-concepts.md#legacy-attribute-actions) fornite indicano al DynamoDB Encryption Client quali attributi crittografare e firmare, quali attributi firmare (ma non crittografare) e quali ignorare.
Se le operazioni di attributo specificate non valgono per tutti gli attributi nell'item, l'item potrebbe non essere crittografato e firmato secondo le tue intenzioni. Se le operazioni di attributo che fornisci quando decrittografi un item sono diverse da quelle che hai fornito quando lo hai crittografato, la verifica della firma potrebbe non andare a buon fine. Questo è problema tipico delle applicazioni distribuite, in cui le nuove operazioni di attributo non sono state propagate a tutti gli host.
Gli errori di convalida delle firme sono difficili da risolvere. Per aiutare a prevenirli, adotta ulteriori precauzioni quando modifichi il modello di dati. Per informazioni dettagliate, vedi [Modifica del modello di dati](data-model.md).
## Problemi con le tabelle globali delle versioni precedenti
**Problema**: gli elementi in una versione precedente della tabella globale di Amazon DynamoDB non possono essere decrittografati perché la verifica della firma non riesce.
**Suggerimento**: imposta le azioni relative agli attributi in modo che i campi di replica riservati non siano crittografati o firmati.
**Dettagli**
È possibile utilizzare il DynamoDB Encryption Client con le tabelle globali [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html). Ti consigliamo di utilizzare tabelle globali con una chiave KMS [multiregionale e di replicare la chiave KMS](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) in tutti i luoghi in cui viene replicata la tabella globale. Regioni AWS
A partire dalla [versione 2019.11.21](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html) delle tabelle globali, puoi utilizzare le tabelle globali con il DynamoDB Encryption Client senza alcuna configurazione speciale. Tuttavia, se si utilizza la [versione 2017.11.29](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html) delle tabelle globali, è necessario assicurarsi che i campi di replica riservati non siano crittografati o firmati.
[Se si utilizza la versione delle tabelle globali 2017.11.29, è necessario impostare le azioni degli attributi per i seguenti attributi `DO_NOTHING` in [`@DoNotTouch`Java](java-using.md#attribute-actions-java) o Python.](python-using.md#python-attribute-actions)
+ `aws:rep:deleting`
+ `aws:rep:updatetime`
+ `aws:rep:updateregion`
Se si utilizza un'altra versione delle tabelle globali, non è richiesta alcuna azione.
## Scarse prestazioni del provider più recente
**Problema**: l'applicazione è meno reattiva, soprattutto dopo l'aggiornamento a una versione più recente del DynamoDB Encryption Client.
**Suggerimento**: modifica il valore e la dimensione della cache. time-to-live
**Dettagli**
The Most Recent Provider è progettato per migliorare le prestazioni delle applicazioni che utilizzano il DynamoDB Encryption Client consentendo un riutilizzo limitato dei materiali crittografici. Quando configuri il provider più recente per la tua applicazione, devi bilanciare il miglioramento delle prestazioni con i problemi di sicurezza derivanti dalla memorizzazione nella cache e dal riutilizzo.
Nelle versioni più recenti di DynamoDB Encryption Client, time-to-live il valore (TTL) determina per quanto tempo possono essere utilizzati i provider di materiale crittografico memorizzati nella cache (). CMPs Il TTL determina anche la frequenza con cui il provider più recente verifica la presenza di una nuova versione della CMP.
Se il TTL è troppo lungo, l'applicazione potrebbe violare le regole aziendali o gli standard di sicurezza. Se il TTL è troppo breve, le chiamate frequenti al provider store possono far sì che quest'ultimo limiti le richieste provenienti dall'applicazione e da altre applicazioni che condividono l'account di servizio. Per risolvere questo problema, regolate il TTL e le dimensioni della cache a un valore che soddisfi gli obiettivi di latenza e disponibilità e sia conforme ai vostri standard di sicurezza. Per informazioni dettagliate, vedi [Impostazione di un valore time-to-live](most-recent-provider.md#most-recent-provider-ttl).