Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# AWS Datenbankverschlüsselungs-SDK für DynamoDB
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
[Das AWS Database Encryption SDK für DynamoDB ist eine Softwarebibliothek, mit der Sie clientseitige Verschlüsselung in Ihr Amazon DynamoDB-Design integrieren können.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/) Das AWS Database Encryption SDK für DynamoDB bietet Verschlüsselung auf Attributebene und ermöglicht es Ihnen, anzugeben, welche Elemente verschlüsselt werden sollen und welche Elemente in die Signaturen aufgenommen werden sollen, die die Authentizität Ihrer Daten sicherstellen. Durch die Verschlüsselung Ihrer sensiblen Daten während der Übertragung und im Speicher wird sichergestellt, dass Ihre Klartextdaten nicht für Dritte verfügbar sind, auch nicht. AWS
**Anmerkung**
Das AWS Database Encryption SDK unterstützt PartiQL nicht.
In DynamoDB ist eine [Tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.TablesItemsAttributes) eine Sammlung von Elementen. Jedes *Element* ist eine Sammlung von *Attributen*. Jedes Attribut verfügt über einen Namen und einen Wert. Das AWS Database Encryption SDK für DynamoDB verschlüsselt die Werte von Attributen. Dann berechnet er eine Signatur unter Verwendung der Attribute. [Sie geben an, welche Attributwerte verschlüsselt und welche in die Signatur der kryptografischen Aktionen aufgenommen werden sollen.](concepts.md#crypt-actions)
Die Themen in diesem Kapitel bieten einen Überblick über das AWS Database Encryption SDK für DynamoDB, einschließlich der verschlüsselten Felder, Anleitungen zur Client-Installation und -Konfiguration sowie Java-Beispiele, die Ihnen den Einstieg erleichtern.
**Topics**
+ [Clientseitige und serverseitige Verschlüsselung](client-server-side.md)
+ [Welche Felder sind verschlüsselt und signiert?](DDB-encrypted-and-signed.md)
+ [Durchsuchbare Verschlüsselung in DynamoDB](ddb-searchable-encryption.md)
+ [Aktualisierung Ihres Datenmodells](ddb-update-data-model.md)
+ [AWS Database Encryption SDK für DynamoDB, verfügbare Programmiersprachen](ddb-programming-languages.md)
+ [Legacy-DynamoDB-Verschlüsselungsclient](legacy-dynamodb-encryption-client.md)
# Clientseitige und serverseitige Verschlüsselung
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in AWS Database Encryption SDK umbenannt. Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Das AWS Database Encryption SDK für DynamoDB unterstützt die *clientseitige Verschlüsselung*, bei der Sie Ihre Tabellendaten verschlüsseln, bevor Sie sie an Ihre Datenbank senden. DynamoDB bietet jedoch eine serverseitige Funktion zur *Verschlüsselung im Ruhezustand*, die Ihre Tabelle transparent verschlüsselt, wenn sie auf der Festplatte gespeichert wird, und sie entschlüsselt, wenn Sie auf die Tabelle zugreifen.
Welche Tools Sie wählen, hängt von der Sensibilität Ihrer Daten und den Sicherheitsanforderungen Ihrer Anwendung ab. Sie können sowohl das AWS Database Encryption SDK für DynamoDB als auch Encryption at Rest verwenden. Wenn Sie verschlüsselte und signierte Elemente an DynamoDB senden, erkennt DynamoDB die Elemente nicht als geschützt. Er erkennt nur typische Tabellenelemente mit binären Attributwerten.
**Serverseitige Verschlüsselung im Ruhezustand**
DynamoDB unterstützt [Encryption at Rest](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/EncryptionAtRest.html), eine *serverseitige Verschlüsselungsfunktion*, bei der DynamoDB Ihre Tabellen transparent für Sie verschlüsselt, wenn die Tabelle dauerhaft auf der Festplatte gespeichert wird, und sie entschlüsselt, wenn Sie auf die Tabellendaten zugreifen.
Wenn Sie ein AWS SDK für die Interaktion mit DynamoDB verwenden, werden Ihre Daten standardmäßig bei der Übertragung über eine HTTPS-Verbindung verschlüsselt, am DynamoDB-Endpunkt entschlüsselt und dann erneut verschlüsselt, bevor sie in DynamoDB gespeichert werden.
+ **Standardmäßig Verschlüsselung.** DynamoDB verschlüsselt und entschlüsselt alle Tabellen transparent, wenn sie geschrieben werden. Es ist nicht möglich, die Verschlüsselung im Ruhezustand zu aktivieren oder zu deaktivieren.
+ **DynamoDB erstellt und verwaltet die kryptografischen Schlüssel.**Der eindeutige Schlüssel für jede Tabelle ist durch eine, die niemals [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)()AWS KMS unverschlüsselt verlässt [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys), geschützt. Standardmäßig verwendet DynamoDB ein [AWS-eigener Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-owned-cmk)im DynamoDB-Dienstkonto, aber Sie können einen [Von AWS verwalteter Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk)oder einen vom [Kunden verwalteten Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) in Ihrem Konto wählen, um einige oder alle Ihre Tabellen zu schützen.
+ **Alle Tabellendaten sind auf der Festplatte verschlüsselt.**[Wenn eine verschlüsselte Tabelle auf der Festplatte gespeichert wird, verschlüsselt DynamoDB alle Tabellendaten, einschließlich des [Primärschlüssels](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) und der lokalen und globalen Sekundärindizes.](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.SecondaryIndexes) Wenn Ihre Tabelle einen Sortierschlüssel hat, werden einige der Sortierschlüssel, die Bereichsgrenzen markieren, in Klartext in den Metadaten der Tabelle gespeichert.
+ **Objekte, die sich auf Tabellen beziehen, werden ebenfalls verschlüsselt.** Verschlüsselung im Ruhezustand schützt [DynamoDB-Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html), [globale Tabellen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) und [Backups](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/BackupRestore.html), wann immer sie auf dauerhafte Medien geschrieben werden.
+ **Ihre Elemente werden entschlüsselt, wenn Sie darauf zugreifen.**Wenn Sie auf die Tabelle zugreifen, entschlüsselt DynamoDB den Teil der Tabelle, der Ihr Zielelement enthält, und gibt das Klartextelement an Sie zurück.
**AWS Datenbankverschlüsselungs-SDK für DynamoDB**
Die clientseitige Verschlüsselung bietet end-to-end Schutz für Ihre Daten bei der Übertragung und im Speicher, von der Quelle bis zur Speicherung in DynamoDB. Ihre Klartextdaten werden niemals Dritten zugänglich gemacht, auch nicht. AWS Sie können das AWS Database Encryption SDK für DynamoDB mit neuen DynamoDB-Tabellen verwenden oder Ihre vorhandenen Amazon DynamoDB-Tabellen auf die neueste Version des Database Encryption SDK für DynamoDB migrieren. AWS
+ **Ihre Daten sind während des Transports und im Ruhezustand geschützt.** Es wird niemals Dritten zugänglich gemacht, auch nicht. AWS
+ **Sie können Ihre Tabellenelemente signieren.** Sie können das AWS Database Encryption SDK for DynamoDB anweisen, eine Signatur für das gesamte oder einen Teil eines Tabellenelements, einschließlich der Primärschlüsselattribute, zu berechnen. Mit dieser Signatur können Sie nicht autorisierte Änderungen am gesamten Element erkennen, einschließlich des Hinzufügens oder Löschens von Attributen oder des Vertauschens von Attributwerten.
+ **Sie bestimmen, wie Ihre Daten geschützt** werden, indem [Sie einen Schlüsselbund auswählen](keyrings.md). Ihr Schlüsselbund bestimmt die Umschließungsschlüssel, die Ihre Datenschlüssel und letztlich Ihre Daten schützen. Verwenden Sie die sichersten Verpackungsschlüssel, die für Ihre Aufgabe praktisch sind.
+ **Das AWS Database Encryption SDK für DynamoDB verschlüsselt nicht die gesamte Tabelle.** Sie wählen aus, welche Attribute in Ihren Elementen verschlüsselt werden. Das AWS Database Encryption SDK für DynamoDB verschlüsselt nicht ein ganzes Element. Es verschlüsselt weder Attributnamen noch die Namen oder Werte der Primärschlüsselattribute (Partitionsschlüssel und Sortierschlüssel).
**AWS Encryption SDK**
Wenn Sie Daten verschlüsseln, die Sie in DynamoDB speichern, empfehlen wir das AWS Database Encryption SDK für DynamoDB.
Die [AWS Encryption SDK](https://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/) ist eine clientseitige Verschlüsselungsbibliothek, die Ihnen hilft, generische Daten zu verschlüsseln und zu entschlüsseln. Obwohl sie beliebige Datentypen schützen kann, ist sie nicht darauf ausgelegt, mit strukturierten Daten wie Datenbankeinträgen zu arbeiten. Im Gegensatz zum AWS Database Encryption SDK für DynamoDB AWS Encryption SDK kann das keine Integritätsprüfung auf Elementebene bereitstellen und hat keine Logik, um Attribute zu erkennen oder die Verschlüsselung von Primärschlüsseln zu verhindern.
Wenn Sie das verwenden AWS Encryption SDK , um ein Element Ihrer Tabelle zu verschlüsseln, denken Sie daran, dass es nicht mit dem AWS Database Encryption SDK für DynamoDB kompatibel ist. Sie können nicht mit einer Bibliothek verschlüsseln und mit einer anderen entschlüsseln.
# Welche Felder sind verschlüsselt und signiert?
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in AWS Database Encryption SDK umbenannt. Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Das AWS Database Encryption SDK für DynamoDB ist eine clientseitige Verschlüsselungsbibliothek, die speziell für Amazon DynamoDB DynamoDB-Anwendungen entwickelt wurde. Amazon DynamoDB speichert Daten in [Tabellen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.TablesItemsAttributes), bei denen es sich um eine Sammlung von Elementen handelt. Jedes *Element* ist eine Sammlung von *Attributen*. Jedes Attribut verfügt über einen Namen und einen Wert. Das AWS Database Encryption SDK für DynamoDB verschlüsselt die Werte von Attributen. Dann berechnet er eine Signatur unter Verwendung der Attribute. Sie können festlegen, welche Attributwerte verschlüsselt und welche in die Signatur aufgenommen werden sollen.
Die Verschlüsselung schützt die Vertraulichkeit des Attributwerts. Das Signieren sorgt für die Integrität aller signierten Attribute und deren Beziehung zueinander, und ermöglicht eine Authentifizierung. Es ermöglicht Ihnen, nicht autorisierte Änderungen am gesamten Element zu erkennen, einschließlich des Hinzufügens oder Löschens von Attributen oder des Ersetzens eines verschlüsselten Werts durch einen anderen.
In einem verschlüsselten Element verbleiben einige Daten im Klartext, einschließlich des Tabellennamens, aller Attributnamen, der Attributwerte, die Sie nicht verschlüsseln, der Namen und Werte der Primärschlüsselattribute (Partitionsschlüssel und Sortierschlüssel) und der Attributtypen. Speichern Sie keine sensiblen Daten in diesen Feldern.
Weitere Informationen zur Funktionsweise des AWS Database Encryption SDK für DynamoDB finden Sie unter. [So funktioniert das AWS Database Encryption SDK](how-it-works.md)
**Anmerkung**
Alle Erwähnungen von *Attributaktionen* in den Themen zum AWS Database Encryption SDK für DynamoDB beziehen sich auf [kryptografische](concepts.md#crypt-actions) Aktionen.
**Topics**
+ [Verschlüsseln von Attributwerten](#encrypt-attribute-values)
+ [Signieren des Elements](#sign-the-item)
## Verschlüsseln von Attributwerten
Das AWS Database Encryption SDK für DynamoDB verschlüsselt die Werte (aber nicht den Attributnamen oder -typ) der von Ihnen angegebenen Attribute. Um festzulegen, welche Attributwerte verschlüsselt werden, verwenden Sie [Attribut-Aktionen](concepts.md#crypt-actions).
Das folgende Element beispielsweise enthält die Attribute `example` und `test`.
```
'example': 'data',
'test': 'test-value',
...
```
Wenn Sie das Attribut `example` verschlüsseln, aber nicht das Attribut `test`, sehen die Ergebnisse wie folgt aus. Der Wert des verschlüsselten `example`-Attributs ist ein Binärwert anstelle einer Zeichenfolge.
```
'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'
...
```
Die Primärschlüsselattribute — Partitionsschlüssel und Sortierschlüssel — jedes Elements müssen im Klartext bleiben, da DynamoDB sie verwendet, um das Element in der Tabelle zu finden. Sie sollten signiert, aber nicht verschlüsselt werden.
Das AWS Database Encryption SDK für DynamoDB identifiziert die Primärschlüsselattribute für Sie und stellt sicher, dass ihre Werte signiert, aber nicht verschlüsselt sind. Und wenn Sie Ihren Primärschlüssel identifizieren und dann versuchen, ihn zu verschlüsseln, wirft der Client eine Ausnahme auf.
Der Client speichert die [Materialbeschreibung](concepts.md#material-description) in einem neuen Attribut (`aws_dbe_head`), das er dem Artikel hinzufügt. Die Materialbeschreibung beschreibt, wie der Artikel verschlüsselt und signiert wurde. Der Client verwendet diese Informationen, um das Element zu überprüfen und zu entschlüsseln. Das Feld, in dem die Materialbeschreibung gespeichert ist, ist nicht verschlüsselt.
## Signieren des Elements
[Nach der Verschlüsselung der angegebenen Attributwerte berechnet das AWS Database Encryption SDK for DynamoDB Hash-Based Message Authentication Codes (HMACs) und eine [digitale Signatur](concepts.md#digital-sigs) über die Kanonisierung der Materialbeschreibung, des [Verschlüsselungskontextes](concepts.md#encryption-context) und jedes mit oder markierten `ENCRYPT_AND_SIGN` Felds in den Attributaktionen. `SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`](concepts.md#crypt-actions) ECDSA-Signaturen sind standardmäßig aktiviert, aber nicht erforderlich. Der Client speichert die HMACs UND-Signaturen in einem neuen Attribut (`aws_dbe_foot`), das er dem Element hinzufügt.
# Durchsuchbare Verschlüsselung in DynamoDB
Um Ihre Amazon DynamoDB-Tabellen für durchsuchbare Verschlüsselung zu konfigurieren, müssen Sie den [AWS KMS hierarchischen Schlüsselbund](use-hierarchical-keyring.md) verwenden, um die Datenschlüssel zu generieren, zu verschlüsseln und zu entschlüsseln, die zum Schutz Ihrer Elemente verwendet werden. Sie müssen den auch in Ihre Tabellenverschlüsselungskonfiguration einbeziehen. [`SearchConfig`](ddb-net-using.md#ddb-net-search-config)
**Anmerkung**
Wenn Sie die clientseitige Java-Verschlüsselungsbibliothek für DynamoDB verwenden, müssen Sie das AWS Low-Level-Datenbankverschlüsselungs-SDK für DynamoDB-API verwenden, um Ihre Tabellenelemente zu verschlüsseln, zu signieren, zu verifizieren und zu entschlüsseln. Der DynamoDB Enhanced Client und niedrigere Versionen unterstützen `DynamoDBItemEncryptor` keine durchsuchbare Verschlüsselung.
**Topics**
+ [Konfiguration sekundärer Indizes mit Beacons](#ddb-beacon-indexes)
+ [Beacon-Ausgaben werden getestet](#ddb-beacon-testing)
## Konfiguration sekundärer Indizes mit Beacons
Nachdem Sie [Ihre Beacons konfiguriert](configure-beacons.md) haben, müssen Sie einen sekundären Index konfigurieren, der die einzelnen Beacons widerspiegelt, bevor Sie nach den verschlüsselten Attributen suchen können.
Wenn Sie einen Standard- oder Verbundbeacon konfigurieren, fügt das AWS Database Encryption SDK dem Beacon-Namen das `aws_dbe_b_` Präfix hinzu, sodass der Server Beacons leicht identifizieren kann. Wenn Sie beispielsweise einen zusammengesetzten Beacon benennen`compoundBeacon`, lautet der vollständige Beacon-Name tatsächlich. `aws_dbe_b_compoundBeacon` Wenn Sie [Sekundärindizes](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) konfigurieren möchten, die einen Standard- oder Verbundbeacon enthalten, müssen Sie bei der Identifizierung des Beacon-Namens das `aws_dbe_b_` Präfix angeben.
**Schlüssel partitionieren und sortieren**
Sie können Primärschlüsselwerte nicht verschlüsseln. Ihre Partitions- und Sortierschlüssel müssen signiert sein. Ihre Primärschlüsselwerte können kein Standard- oder Verbundbeacon sein.
Ihre Primärschlüsselwerte müssen`SIGN_ONLY`, sofern Sie keine `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, auch die Partitions- und Sortierattribute sein`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Ihre Primärschlüsselwerte können signierte Beacons sein. Wenn Sie für jeden Ihrer Primärschlüsselwerte unterschiedliche signierte Beacons konfiguriert haben, müssen Sie den Attributnamen, der den Primärschlüsselwert identifiziert, als signierten Beacon-Namen angeben. Das AWS Database Encryption SDK fügt das `aws_dbe_b_` Präfix jedoch nicht zu signierten Beacons hinzu. Selbst wenn Sie unterschiedliche signierte Beacons für Ihre Primärschlüsselwerte konfiguriert haben, müssen Sie bei der Konfiguration eines Sekundärindexes nur die Attributnamen für die Primärschlüsselwerte angeben.
**Lokale sekundäre Indizes**
Der Sortierschlüssel für einen [lokalen Sekundärindex](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LSI.html) kann ein Beacon sein.
Wenn Sie einen Beacon für den Sortierschlüssel angeben, muss der Typ String sein. Wenn Sie einen Standard- oder Verbundbeacon für den Sortierschlüssel angeben, müssen Sie das `aws_dbe_b_` Präfix angeben, wenn Sie den Beacon-Namen angeben. Wenn Sie einen signierten Beacon angeben, geben Sie den Beacon-Namen ohne Präfix an.
**Globale sekundäre Indizes**
Sowohl die Partitions- als auch die Sortierschlüssel für einen [globalen sekundären Index](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html) können Beacons sein.
Wenn Sie einen Beacon für die Partition oder den Sortierschlüssel angeben, muss der Typ String sein. Wenn Sie einen Standard- oder Verbundbeacon für den Sortierschlüssel angeben, müssen Sie das `aws_dbe_b_` Präfix angeben, wenn Sie den Beacon-Namen angeben. Wenn Sie einen signierten Beacon angeben, geben Sie den Beacon-Namen ohne Präfix an.
**Attributprojektionen**
Eine [Projektion](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GSI.html#GSI.Projections) ist der Satz von Attributen, die aus einer Tabelle in einen sekundären Index kopiert werden. Der Partitionsschlüssel und der Sortierschlüssel der Tabelle werden immer in den Index projiziert. Sie können andere Attribute projizieren, um die Abfrageanforderungen Ihrer Anwendung zu unterstützen. DynamoDB bietet drei verschiedene Optionen für Attributprojektionen: `KEYS_ONLY``INCLUDE`, und. `ALL`
Wenn Sie die INCLUDE-Attributprojektion verwenden, um auf einem Beacon zu suchen, müssen Sie die Namen für alle Attribute angeben, aus denen das Beacon aufgebaut ist, sowie den Beacon-Namen mit dem Präfix. `aws_dbe_b_` Wenn Sie beispielsweise einen Verbundbeacon,, von, `compoundBeacon` und konfiguriert haben `field1``field2`, müssen Sie`field3`,, und in der `aws_dbe_b_compoundBeacon` `field1` Projektion `field2` angeben. `field3`
Ein globaler sekundärer Index kann nur die in der Projektion explizit angegebenen Attribute verwenden, ein lokaler sekundärer Index kann jedoch jedes beliebige Attribut verwenden.
## Beacon-Ausgaben werden getestet
Wenn Sie [zusammengesetzte Beacons konfiguriert](configure-beacons.md#config-compound-beacons) oder Ihre Beacons mithilfe [virtueller Felder](configure-beacons.md#create-virtual-field) erstellt haben, empfehlen wir, zu überprüfen, ob diese Beacons die erwartete Ausgabe erzeugen, bevor Sie Ihre DynamoDB-Tabelle füllen.
Das AWS Database Encryption SDK bietet den `DynamoDbEncryptionTransforms` Service, der Sie bei der Fehlerbehebung bei der Ausgabe virtueller Felder und zusammengesetzter Beacons unterstützt.
### Testen virtueller Felder
Der folgende Ausschnitt erstellt Testelemente, definiert den `DynamoDbEncryptionTransforms` Dienst mit der [DynamoDB-Tabellenverschlüsselungskonfiguration](ddb-java-using.md#ddb-config-encrypt) und zeigt, wie überprüft werden kann, ob das virtuelle Feld die erwartete Ausgabe erzeugt. `ResolveAttributes`
------
#### [ Java ]
**Sehen Sie sich das vollständige Codebeispiel an**[: .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 ]
**Sehen Sie sich das vollständige Codebeispiel** an: [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 ]
**Sehen Sie sich das vollständige Codebeispiel** an: [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");
```
------
### Testen von Compound-Beacons
Der folgende Ausschnitt erstellt ein Testelement, definiert den `DynamoDbEncryptionTransforms` Dienst mit der [DynamoDB-Tabellenverschlüsselungskonfiguration](ddb-java-using.md#ddb-config-encrypt) und zeigt, wie überprüft werden kann, ob der Compound Beacon die erwartete Ausgabe erzeugt. `ResolveAttributes`
------
#### [ Java ]
**Sehen Sie sich das vollständige Codebeispiel an**[: .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 ]
**[Sehen Sie sich das vollständige Codebeispiel an: .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 ]
**Sehen Sie sich das vollständige Codebeispiel** [an: 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
```
------
# Aktualisierung Ihres Datenmodells
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Wenn Sie das AWS Database Encryption SDK für DynamoDB konfigurieren, geben Sie [Attributaktionen](concepts.md#crypt-actions) an. Beim Verschlüsseln identifiziert das AWS Database Encryption SDK anhand der Attributaktionen, welche Attribute verschlüsselt und signiert, welche Attribute signiert (aber nicht verschlüsselt) und welche ignoriert werden sollen. Sie definieren auch [zulässige unsignierte Attribute](ddb-java-using.md#allowed-unauth), um dem Client explizit mitzuteilen, welche Attribute von den Signaturen ausgeschlossen sind. Beim Entschlüsseln verwendet das AWS Database Encryption SDK die erlaubten unsignierten Attribute, die Sie definiert haben, um zu identifizieren, welche Attribute nicht in den Signaturen enthalten sind. Attributaktionen werden nicht im verschlüsselten Element gespeichert und das AWS Database Encryption SDK aktualisiert Ihre Attributaktionen nicht automatisch.
Wählen Sie Ihre Attributaktionen sorgfältig aus. Verwenden Sie im Zweifelsfall **Verschlüsseln und signieren**. Nachdem Sie das AWS Database Encryption SDK zum Schutz Ihrer Elemente verwendet haben, können Sie ein `ENCRYPT_AND_SIGN` vorhandenes oder `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` -Attribut nicht mehr in ändern`DO_NOTHING`. `SIGN_ONLY` Sie können jedoch ohne Bedenken die folgenden Änderungen vornehmen.
+ [Fügen Sie neue `ENCRYPT_AND_SIGN``SIGN_ONLY`, und `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute hinzu](#ddb-add-auth-attribute)
+ [Entfernen Sie vorhandene Attribute](#ddb-remove-attribute)
+ [Ändern Sie ein vorhandenes `ENCRYPT_AND_SIGN` Attribut in `SIGN_ONLY` oder `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`](#ddb-encrypt-to-sign)
+ [Ändern Sie ein vorhandenes `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribut `SIGN_ONLY` oder `ENCRYPT_AND_SIGN`](#ddb-sign-to-encrypt)
+ [Fügen Sie ein neues `DO_NOTHING` Attribut hinzu](#ddb-add-unauth-attribute)
+ [Ändern Sie ein vorhandenes `SIGN_ONLY` Attribut in `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`](#ddb-signOnly-to-signInclude)
+ [Ändern Sie ein vorhandenes `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribut in `SIGN_ONLY`](#ddb-signInclude-to-signOnly)
**Überlegungen zur durchsuchbaren Verschlüsselung**
Bevor Sie Ihr Datenmodell aktualisieren, sollten Sie sorgfältig überlegen, wie sich Ihre Aktualisierungen auf [Beacons](beacons.md) auswirken könnten, die Sie anhand der Attribute erstellt haben. Nachdem Sie mit einem Beacon neue Datensätze geschrieben haben, können Sie die Konfiguration des Beacons nicht mehr aktualisieren. Sie können die Attributaktionen, die den Attributen zugeordnet sind, die Sie zum Aufbau von Beacons verwendet haben, nicht aktualisieren. Wenn Sie ein vorhandenes Attribut und den zugehörigen Beacon entfernen, können Sie mit diesem Beacon keine vorhandenen Datensätze abfragen. Sie können neue Beacons für neue Felder erstellen, die Sie Ihrem Datensatz hinzufügen, aber Sie können bestehende Beacons nicht so aktualisieren, dass sie das neue Feld aufnehmen.
**Überlegungen zu Attributen `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`**
Standardmäßig sind die Partitions- und Sortierschlüssel das einzige Attribut, das im Verschlüsselungskontext enthalten ist. Sie könnten erwägen, zusätzliche Felder zu definieren, `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` damit der Anbieter der Branch-Schlüssel-ID für Ihren [AWS KMS hierarchischen Schlüsselbund](use-hierarchical-keyring.md) ermitteln kann, welcher Filialschlüssel für die Entschlüsselung aus dem Verschlüsselungskontext erforderlich ist. Weitere Informationen finden Sie unter Lieferant für die [Filialschlüssel-ID](use-hierarchical-keyring.md#branch-key-id-supplier). Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen auch die Partitions- und Sortierattribute angegeben werden`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**Anmerkung**
Um die `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` kryptografische Aktion verwenden zu können, müssen Sie Version 3.3 oder höher des AWS Database Encryption SDK verwenden. Stellen Sie die neue Version für alle Lesegeräte bereit, bevor [Sie Ihr Datenmodell so aktualisieren](#ddb-update-data-model), dass es diese enthält`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
## Fügen Sie neue `ENCRYPT_AND_SIGN``SIGN_ONLY`, und `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute hinzu
Um ein neues `ENCRYPT_AND_SIGN``SIGN_ONLY`, oder `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribut hinzuzufügen, definieren Sie das neue Attribut in Ihren Attributaktionen.
Sie können ein vorhandenes `DO_NOTHING` Attribut nicht entfernen und es als`ENCRYPT_AND_SIGN`,`SIGN_ONLY`, `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` -Attribut wieder hinzufügen.
**Verwenden einer Datenklasse mit Anmerkungen**
Wenn Sie Ihre Attributaktionen mit a definiert haben`TableSchema`, fügen Sie das neue Attribut Ihrer annotierten Datenklasse hinzu. Wenn Sie keine Attributaktions-Anmerkung für das neue Attribut angeben, verschlüsselt und signiert der Client das neue Attribut standardmäßig (es sei denn, das Attribut ist Teil des Primärschlüssels). Wenn Sie nur das neue Attribut signieren möchten, müssen Sie das neue Attribut mit der `@DynamoDBEncryptionSignAndIncludeInEncryptionContext` Anmerkung `@DynamoDBEncryptionSignOnly` oder hinzufügen.
**Verwenden Sie ein Objektmodell**
Wenn Sie Ihre Attributaktionen manuell definiert haben, fügen Sie das neue Attribut zu den Attributaktionen in Ihrem Objektmodell hinzu und geben Sie `ENCRYPT_AND_SIGN``SIGN_ONLY`, oder `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` als Attributaktion an.
## Entfernen Sie vorhandene Attribute
Wenn Sie entscheiden, dass Sie ein Attribut nicht mehr benötigen, können Sie das Schreiben von Daten in dieses Attribut beenden oder es formell aus Ihren Attributaktionen entfernen. Wenn Sie aufhören, neue Daten in ein Attribut zu schreiben, wird das Attribut weiterhin in Ihren Attributaktionen angezeigt. Dies kann hilfreich sein, wenn Sie das Attribut in future erneut verwenden müssen. Wenn Sie das Attribut formal aus Ihren Attributaktionen entfernen, wird es nicht aus Ihrem Datensatz entfernt. Ihr Datensatz wird weiterhin Elemente enthalten, die dieses Attribut enthalten.
Um ein vorhandenes`ENCRYPT_AND_SIGN`, `SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, oder `DO_NOTHING` Attribut formell zu entfernen, aktualisieren Sie Ihre Attributaktionen.
Wenn Sie ein `DO_NOTHING` Attribut entfernen, dürfen Sie dieses Attribut nicht aus Ihren [zulässigen Attributen ohne Vorzeichen](ddb-java-using.md#allowed-unauth) entfernen. Auch wenn Sie keine neuen Werte mehr in dieses Attribut schreiben, muss der Client trotzdem wissen, dass das Attribut vorzeichenlos ist, um vorhandene Elemente lesen zu können, die das Attribut enthalten.
**Verwenden einer Datenklasse mit Anmerkungen**
Wenn Sie Ihre Attributaktionen mit a definiert haben`TableSchema`, entfernen Sie das Attribut aus Ihrer annotierten Datenklasse.
**Verwenden Sie ein Objektmodell**
Wenn Sie Ihre Attributaktionen manuell definiert haben, entfernen Sie das Attribut aus den Attributaktionen in Ihrem Objektmodell.
## Ändern Sie ein vorhandenes `ENCRYPT_AND_SIGN` Attribut in `SIGN_ONLY` oder `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
Um ein vorhandenes `ENCRYPT_AND_SIGN` Attribut in `SIGN_ONLY` oder zu ändern`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, müssen Sie Ihre Attributaktionen aktualisieren. Nachdem Sie das Update bereitgestellt haben, kann der Client vorhandene Werte, die in das Attribut geschrieben wurden, verifizieren und entschlüsseln, signiert jedoch nur neue Werte, die in das Attribut geschrieben wurden.
**Anmerkung**
Überlegen Sie sich sorgfältig Ihre Sicherheitsanforderungen, bevor Sie ein vorhandenes `ENCRYPT_AND_SIGN` Attribut in `SIGN_ONLY` oder `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` ändern. Jedes Attribut, das vertrauliche Daten speichern kann, sollte verschlüsselt werden.
**Verwendung einer annotierten Datenklasse**
Wenn Sie Ihre Attributaktionen mit einem definiert haben`TableSchema`, aktualisieren Sie das vorhandene Attribut, sodass die `@DynamoDBEncryptionSignAndIncludeInEncryptionContext` Anmerkung `@DynamoDBEncryptionSignOnly` oder in Ihre annotierte Datenklasse aufgenommen wird.
**Verwenden Sie ein Objektmodell**
Wenn Sie Ihre Attributaktionen manuell definiert haben, aktualisieren Sie die dem vorhandenen Attribut zugeordnete Attributaktion von `ENCRYPT_AND_SIGN` bis `SIGN_ONLY` oder `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` in Ihrem Objektmodell.
## Ändern Sie ein vorhandenes `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribut `SIGN_ONLY` oder `ENCRYPT_AND_SIGN`
Um ein vorhandenes `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribut `SIGN_ONLY` oder ein Attribut in zu ändern`ENCRYPT_AND_SIGN`, müssen Sie Ihre Attributaktionen aktualisieren. Nachdem Sie das Update bereitgestellt haben, kann der Client die vorhandenen Werte überprüfen, die in das Attribut geschrieben wurden, und verschlüsselt und signiert neue Werte, die in das Attribut geschrieben wurden.
**Verwenden einer Datenklasse mit Anmerkungen**
Wenn Sie Ihre Attributaktionen mit einem definiert haben`TableSchema`, entfernen Sie die `@DynamoDBEncryptionSignAndIncludeInEncryptionContext` Anmerkung `@DynamoDBEncryptionSignOnly` oder aus dem vorhandenen Attribut.
**Verwenden eines Objektmodells**
Wenn Sie Ihre Attributaktionen manuell definiert haben, aktualisieren Sie die Attributaktion, die dem Attribut von `SIGN_ONLY` oder `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` nach zugeordnet ist, `ENCRYPT_AND_SIGN` in Ihrem Objektmodell.
## Fügen Sie ein neues `DO_NOTHING` Attribut hinzu
Um das Fehlerrisiko beim Hinzufügen eines neuen `DO_NOTHING` Attributs zu verringern, empfehlen wir, bei der Benennung Ihrer `DO_NOTHING` Attribute ein eindeutiges Präfix anzugeben und dieses Präfix dann zu verwenden, um Ihre [zulässigen Attribute ohne Vorzeichen](ddb-java-using.md#allowed-unauth) zu definieren.
Sie können kein `ENCRYPT_AND_SIGN` vorhandenes `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribut oder aus Ihrer annotierten Datenklasse entfernen und das Attribut dann wieder als `DO_NOTHING` Attribut hinzufügen. `SIGN_ONLY` Sie können nur völlig neue `DO_NOTHING` Attribute hinzufügen.
Die Schritte, die Sie unternehmen, um ein neues `DO_NOTHING` Attribut hinzuzufügen, hängen davon ab, ob Sie Ihre zulässigen Attribute ohne Vorzeichen explizit in einer Liste oder mit einem Präfix definiert haben.
**Verwenden Sie ein zulässiges Präfix für vorzeichenlose Attribute**
Wenn Sie Ihre Attributaktionen mit einem definiert haben`TableSchema`, fügen Sie das neue `DO_NOTHING` Attribut mit der Anmerkung zu Ihrer annotierten Datenklasse hinzu. `@DynamoDBEncryptionDoNothing` Wenn Sie Ihre Attributaktionen manuell definiert haben, aktualisieren Sie Ihre Attributaktionen, sodass sie das neue Attribut enthalten. Achten Sie darauf, das neue Attribut explizit mit der `DO_NOTHING` Attributaktion zu konfigurieren. Sie müssen dasselbe eindeutige Präfix in den Namen des neuen Attributs aufnehmen.
**Verwenden Sie eine Liste mit zulässigen Attributen ohne Vorzeichen**
1. Fügen Sie das neue `DO_NOTHING` Attribut zu Ihrer Liste der zulässigen unsignierten Attribute hinzu und stellen Sie die aktualisierte Liste bereit.
1. Stellen Sie die Änderung aus **Schritt 1** bereit.
Sie können erst mit **Schritt 3** fortfahren, wenn die Änderung auf alle Hosts übertragen wurde, die diese Daten lesen müssen.
1. Fügen Sie das neue `DO_NOTHING` Attribut zu Ihren Attributaktionen hinzu.
1. Wenn Sie Ihre Attributaktionen mit einem definiert haben`TableSchema`, fügen Sie das neue `DO_NOTHING` Attribut mit der `@DynamoDBEncryptionDoNothing` Anmerkung zu Ihrer annotierten Datenklasse hinzu.
1. Wenn Sie Ihre Attributaktionen manuell definiert haben, aktualisieren Sie Ihre Attributaktionen, sodass sie das neue Attribut enthalten. Achten Sie darauf, das neue Attribut explizit mit der `DO_NOTHING` Attributaktion zu konfigurieren.
1. Stellen Sie die Änderung aus **Schritt 3** bereit.
## Ändern Sie ein vorhandenes `SIGN_ONLY` Attribut in `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`
Um ein vorhandenes `SIGN_ONLY` Attribut zu ändern`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, müssen Sie Ihre Attributaktionen aktualisieren. Nachdem Sie das Update bereitgestellt haben, kann der Client die vorhandenen Werte überprüfen, die in das Attribut geschrieben wurden, und signiert weiterhin neue Werte, die in das Attribut geschrieben wurden. Neue Werte, die in das Attribut geschrieben werden, werden in den [Verschlüsselungskontext](concepts.md#encryption-context) aufgenommen.
Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen auch die Partitions- und Sortierattribute angegeben werden`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**Verwenden Sie eine annotierte Datenklasse**
Wenn Sie Ihre Attributaktionen mit a definiert haben`TableSchema`, aktualisieren Sie die dem Attribut zugeordnete Attributaktion von `@DynamoDBEncryptionSignOnly` bis`@DynamoDBEncryptionSignAndIncludeInEncryptionContext`.
**Verwenden Sie ein Objektmodell**
Wenn Sie Ihre Attributaktionen manuell definiert haben, aktualisieren Sie die dem Attribut zugeordnete Attributaktion von `SIGN_ONLY` bis `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` in Ihrem Objektmodell.
## Ändern Sie ein vorhandenes `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribut in `SIGN_ONLY`
Um ein vorhandenes `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribut zu ändern`SIGN_ONLY`, müssen Sie Ihre Attributaktionen aktualisieren. Nachdem Sie das Update bereitgestellt haben, kann der Client die vorhandenen Werte überprüfen, die in das Attribut geschrieben wurden, und signiert weiterhin neue Werte, die in das Attribut geschrieben wurden. Neue Werte, die in das Attribut geschrieben werden, werden nicht in den [Verschlüsselungskontext](concepts.md#encryption-context) aufgenommen.
Bevor Sie ein vorhandenes `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribut in ändern`SIGN_ONLY`, sollten Sie sorgfältig abwägen, wie sich Ihre Aktualisierungen auf die Funktionalität Ihres [Branch Key ID-Anbieters](use-hierarchical-keyring.md#branch-key-id-supplier) auswirken könnten.
**Verwenden einer Datenklasse mit Anmerkungen**
Wenn Sie Ihre Attributaktionen mit a definiert haben`TableSchema`, aktualisieren Sie die dem Attribut zugeordnete Attributaktion von `@DynamoDBEncryptionSignAndIncludeInEncryptionContext` bis`@DynamoDBEncryptionSignOnly`.
**Verwenden Sie ein Objektmodell**
Wenn Sie Ihre Attributaktionen manuell definiert haben, aktualisieren Sie die dem Attribut zugeordnete Attributaktion von `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` bis `SIGN_ONLY` in Ihrem Objektmodell.
# AWS Database Encryption SDK für DynamoDB, verfügbare Programmiersprachen
Das AWS Database Encryption SDK für DynamoDB ist für die folgenden Programmiersprachen verfügbar. Die sprachspezifischen Bibliotheken sind unterschiedlich, aber die daraus resultierenden Implementierungen sind interoperabel. Sie können mit einer Sprachimplementierung verschlüsseln und mit einer anderen entschlüsseln. Die Interoperabilität ist möglicherweise von Spracheinschränkungen abhängig. Wenn dies der Fall ist, werden diese Einschränkungen im Thema zur Sprachimplementierung beschrieben.
**Topics**
+ [Java](ddb-java.md)
+ [.NET](ddb-net.md)
+ [Rust](ddb-rust.md)
# Java
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
In diesem Thema wird erklärt, wie Version 3 installiert und verwendet wird. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB. Einzelheiten zur Programmierung mit dem AWS Database Encryption SDK für DynamoDB finden Sie in den [Java-Beispielen](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) im aws-database-encryption-sdk -dynamodb-Repository unter. GitHub
**Anmerkung**
Die folgenden Themen konzentrieren sich auf Version 3. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB.
[Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS](DDBEC-rename.md) Das AWS Database Encryption SDK unterstützt weiterhin [ältere Versionen des DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md).
**Topics**
+ [Voraussetzungen](#ddb-java-prerequisites)
+ [Installation](#ddb-java-installation)
+ [Verwenden des Java-Clients](ddb-java-using.md)
+ [Java-Beispiele](ddb-java-examples.md)
+ [Fügen Sie Version 3.x zu einer vorhandenen Tabelle hinzu](ddb-java-config-existing-table.md)
+ [Migrieren Sie auf Version 3.x](ddb-java-migrate.md)
## Voraussetzungen
Bevor Sie Version 3 installieren. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen.
**Eine Java-Entwicklungsumgebung**
Sie benötigen Java 8 oder höher. Klicken Sie auf der Oracle-Website auf [Java SE Downloads](https://www.oracle.com/java/technologies/downloads/) und laden und installieren Sie anschließend das Java SE Development Kit (JDK).
Wenn Sie das Oracle JDK verwenden, müssen Sie auch die [Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files](http://www.oracle.com/java/technologies/javase-jce8-downloads.html) herunterladen und installieren.
**AWS SDK for Java 2.x**
Das AWS Database Encryption SDK für DynamoDB erfordert das [DynamoDB Enhanced Client-Modul](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) von. AWS SDK for Java 2.x Sie können das gesamte SDK oder nur dieses Modul installieren.
Informationen zur Aktualisierung Ihrer Version von finden Sie unter [Migration von Version 1.x auf 2.x von](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html). AWS SDK für Java AWS SDK für Java
Das AWS SDK für Java ist über Apache Maven verfügbar. Sie können eine Abhängigkeit für das gesamte AWS SDK für Java Modul oder nur für das `dynamodb-enhanced` Modul deklarieren.
**Installieren Sie das AWS SDK für Java mit Apache Maven**
+ Um [das gesamte AWS SDK für Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#build-the-entire-sdk-into-your-project) als Abhängigkeit zu importieren, deklarieren Sie es in Ihrer `pom.xml`-Datei.
+ Um eine Abhängigkeit nur für das Amazon DynamoDB DynamoDB-Modul in der zu erstellen AWS SDK für Java, folgen Sie den Anweisungen zur [Angabe bestimmter](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/setup-project-maven.html#modules-dependencies) Module. Stellen Sie „`groupId`bis“ `software.amazon.awssdk` und „Bis“ ein. `artifactID` `dynamodb-enhanced`
**Anmerkung**
Wenn Sie den AWS KMS Schlüsselbund oder den AWS KMS hierarchischen Schlüsselbund verwenden, müssen Sie auch eine Abhängigkeit für das Modul erstellen. AWS KMS Stellen Sie „bis“ `software.amazon.awssdk` und „`groupId`Bis“ ein. `artifactID` `kms`
## Installation
Sie können Version 3 installieren. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB auf folgende Weise.
**Verwenden von Apache Maven**
Der Amazon DynamoDB Encryption Client für Java ist über [Apache Maven](https://maven.apache.org/) mit der folgenden Abhängigkeitsdefinition verfügbar.
```
software.amazon.cryptography
aws-database-encryption-sdk-dynamodb
version-number
```
**Verwenden von Gradle Kotlin**
Sie können [Gradle](https://gradle.org/) verwenden, um eine Abhängigkeit vom Amazon DynamoDB Encryption Client for Java zu deklarieren, indem Sie Folgendes zum Abschnitt mit den *Abhängigkeiten* Ihres Gradle-Projekts hinzufügen.
```
implementation("software.amazon.cryptography:aws-database-encryption-sdk-dynamodb:version-number")
```
**manuell**
[Um die clientseitige Java-Verschlüsselungsbibliothek für DynamoDB zu installieren, klonen Sie das -dynamodb-Repository oder laden Sie es herunter. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
Nachdem Sie das SDK installiert haben, schauen Sie sich zunächst den Beispielcode in diesem Handbuch und die [Java-Beispiele](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) im -dynamodb-Repository an. aws-database-encryption-sdk GitHub
# Verwendung der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
In diesem Thema werden einige der Funktionen und Hilfsklassen in Version 3 erklärt. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB.
Einzelheiten zur Programmierung mit der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB finden Sie in den Java-Beispielen, in den [Java-Beispielen](java-examples.md) [im -dynamodb-Repository](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) unter. aws-database-encryption-sdk GitHub
**Topics**
+ [Elementverschlüssler](#ddb-item-encryptors)
+ [Attributaktionen](#ddb-attribute-actions)
+ [Verschlüsselungskonfiguration](#ddb-config-encrypt)
+ [Artikel werden aktualisiert](#ddb-update-items)
+ [Signierte Sets entschlüsseln](#ddb-java-signed-sets)
## Elementverschlüssler
Im Kern ist das AWS Database Encryption SDK für DynamoDB ein Elementverschlüsseler. Sie können Version 3 verwenden. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB, um Ihre DynamoDB-Tabellenelemente auf folgende Weise zu verschlüsseln, zu signieren, zu verifizieren und zu entschlüsseln.
**Der erweiterte DynamoDB-Client**
Sie können den [DynamoDB Enhanced Client](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) so konfigurieren, `DynamoDbEncryptionInterceptor` dass er Elemente automatisch clientseitig mit Ihren DynamoDB-Anfragen verschlüsselt und signiert. `PutItem` Mit dem DynamoDB Enhanced Client können Sie Ihre Attributaktionen mithilfe einer [annotierten](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean) Datenklasse definieren. Wir empfehlen, wann immer möglich den DynamoDB Enhanced Client zu verwenden.
Der DynamoDB Enhanced Client unterstützt keine [durchsuchbare](searchable-encryption.md) Verschlüsselung.
[Das AWS Database Encryption SDK unterstützt keine Anmerkungen zu verschachtelten Attributen.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html)
**Die DynamoDB-API auf niedriger Ebene**
Sie können die [Low-Level-DynamoDB-API so konfigurieren, `DynamoDbEncryptionInterceptor` dass Elemente automatisch clientseitig mit Ihren DynamoDB-Anfragen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html) verschlüsselt und signiert werden. `PutItem`
[Sie müssen die Low-Level-DynamoDB-API verwenden, um durchsuchbare Verschlüsselung zu verwenden.](searchable-encryption.md)
**Die untergeordnete Ebene `DynamoDbItemEncryptor`**
Die untergeordnete Ebene verschlüsselt und signiert oder entschlüsselt und verifiziert Ihre Tabellenelemente `DynamoDbItemEncryptor` direkt, ohne DynamoDB aufzurufen. Es stellt keine DynamoDB `PutItem` oder `GetItem` Anfragen. Sie können beispielsweise die untergeordnete Ebene verwenden, `DynamoDbItemEncryptor` um ein DynamoDB-Element, das Sie bereits abgerufen haben, direkt zu entschlüsseln und zu verifizieren.
[Die untergeordnete Ebene unterstützt keine durchsuchbare Verschlüsselung`DynamoDbItemEncryptor`.](searchable-encryption.md)
## Attributaktionen im AWS Database Encryption SDK für DynamoDB
[Attributaktionen](concepts.md#crypt-actions) bestimmen, welche Attributwerte verschlüsselt und signiert werden, welche nur signiert sind, welche signiert und in den Verschlüsselungskontext aufgenommen werden und welche ignoriert werden.
**Anmerkung**
Um die `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` kryptografische Aktion verwenden zu können, müssen Sie Version 3.3 oder höher des AWS Database Encryption SDK verwenden. Stellen Sie die neue Version für alle Lesegeräte bereit, bevor [Sie Ihr Datenmodell so aktualisieren](ddb-update-data-model.md), dass es diese enthält`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Wenn Sie die Low-Level-DynamoDB-API oder die Low-Level-API verwenden`DynamoDbItemEncryptor`, müssen Sie Ihre Attributaktionen manuell definieren. [Wenn Sie den DynamoDB Enhanced Client verwenden, können Sie Ihre Attributaktionen entweder manuell definieren oder Sie können eine annotierte Datenklasse verwenden, um eine zu generieren. `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) Um den Konfigurationsprozess zu vereinfachen, empfehlen wir die Verwendung einer annotierten Datenklasse. Wenn Sie eine annotierte Datenklasse verwenden, müssen Sie Ihr Objekt nur einmal modellieren.
**Anmerkung**
Nachdem Sie Ihre Attributaktionen definiert haben, müssen Sie definieren, welche Attribute von den Signaturen ausgeschlossen werden. Um das future Hinzufügen neuer Attribute ohne Vorzeichen zu vereinfachen, empfehlen wir, ein eindeutiges Präfix (wie "`:`„) zu wählen, um Ihre vorzeichenlosen Attribute zu identifizieren. Nehmen Sie dieses Präfix in den Attributnamen für alle Attribute auf, die Sie bei der Definition Ihres DynamoDB-Schemas und Ihrer Attributaktionen markiert `DO_NOTHING` haben.
### Verwenden Sie eine Datenklasse mit Anmerkungen
Verwenden Sie eine [annotierte Datenklasse](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html#ddb-en-client-gs-tableschema-anno-bean), um Ihre Attributaktionen mit dem DynamoDB Enhanced Client und zu spezifizieren. `DynamoDbEncryptionInterceptor` Das AWS Database Encryption SDK für DynamoDB verwendet die [standardmäßigen DynamoDB-Attributanmerkungen, die den Attributtyp](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/enhanced/dynamodb/mapper/annotations/package-summary.html) definieren, um zu bestimmen, wie ein Attribut geschützt werden soll. Standardmäßig sind alle Attribute verschlüsselt und signiert, mit Ausnahme der Primärschlüssel, die zwar signiert, aber nicht verschlüsselt sind.
**Anmerkung**
Um die `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` kryptografische Aktion verwenden zu können, müssen Sie Version 3.3 oder höher des Database Encryption SDK verwenden. AWS Stellen Sie die neue Version für alle Lesegeräte bereit, bevor [Sie Ihr Datenmodell so aktualisieren](ddb-update-data-model.md), dass es diese enthält`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
Weitere Hinweise zu den aws-database-encryption-sdk DynamoDB Enhanced Client-Anmerkungen finden Sie unter [SimpleClass GitHub .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) im -dynamodb-Repository unter.
Standardmäßig sind Primärschlüsselattribute signiert, aber nicht verschlüsselt (`SIGN_ONLY`), und alle anderen Attribute sind verschlüsselt und signiert (). `ENCRYPT_AND_SIGN` Wenn Sie Attribute als definieren`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, müssen dies auch die Partitions- und Sortierattribute sein`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Um Ausnahmen anzugeben, verwenden Sie die Verschlüsselungsanmerkungen, die in der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB definiert sind. Wenn Sie beispielsweise möchten, dass ein bestimmtes Attribut nur signiert wird, verwenden Sie die Anmerkung. `@DynamoDbEncryptionSignOnly` Wenn Sie möchten, dass ein bestimmtes Attribut signiert und in den Verschlüsselungskontext aufgenommen wird, verwenden Sie die`@DynamoDbEncryptionSignAndIncludeInEncryptionContext`. Wenn Sie möchten, dass ein bestimmtes Attribut weder signiert noch verschlüsselt (`DO_NOTHING`) wird, verwenden Sie die `@DynamoDbEncryptionDoNothing` Anmerkung.
**Anmerkung**
Das AWS Database Encryption SDK unterstützt keine Anmerkungen zu [verschachtelten Attributen](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html).
Das folgende Beispiel zeigt die Anmerkungen, die zur Definition von `ENCRYPT_AND_SIGN``SIGN_ONLY`, und `DO_NOTHING` Attributaktionen verwendet werden. [Ein Beispiel, das die zur Definition verwendeten Anmerkungen zeigt`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, finden Sie unter 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;
}
}
```
Verwenden Sie Ihre annotierte Datenklasse, um die zu erstellen, `TableSchema` wie im folgenden Codeausschnitt gezeigt.
```
final TableSchema tableSchema = TableSchema.fromBean(SimpleClass.class);
```
### Definieren Sie Ihre Attributaktionen manuell
Um Attributaktionen manuell zu spezifizieren, erstellen Sie ein `Map` Objekt, in dem die Name-Wert-Paare für Attributnamen und die angegebenen Aktionen stehen.
Geben Sie `ENCRYPT_AND_SIGN` an, dass ein Attribut verschlüsselt und signiert werden soll. Geben Sie `SIGN_ONLY` an, dass ein Attribut signiert, aber nicht verschlüsselt werden soll. Geben Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` an, dass ein Attribut signiert und in den Verschlüsselungskontext aufgenommen werden soll. Sie können ein Attribut nicht verschlüsseln, ohne es auch zu signieren. Geben Sie `DO_NOTHING` an, ob ein Attribut ignoriert werden soll.
Die Partitions- und Sortierattribute müssen entweder `SIGN_ONLY` oder lauten`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Wenn Sie Attribute als definieren`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, müssen dies auch die Partitions- und Sortierattribute sein`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**Anmerkung**
Um die `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` kryptografische Aktion verwenden zu können, müssen Sie Version 3.3 oder höher des AWS Database Encryption SDK verwenden. Stellen Sie die neue Version für alle Lesegeräte bereit, bevor [Sie Ihr Datenmodell so aktualisieren](ddb-update-data-model.md), dass es diese enthält`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);
```
## Verschlüsselungskonfiguration im AWS Database Encryption SDK für DynamoDB
Wenn Sie das AWS Database Encryption SDK verwenden, müssen Sie explizit eine Verschlüsselungskonfiguration für Ihre DynamoDB-Tabelle definieren. Die in Ihrer Verschlüsselungskonfiguration erforderlichen Werte hängen davon ab, ob Sie Ihre Attributaktionen manuell oder mit einer annotierten Datenklasse definiert haben.
Der folgende Ausschnitt definiert eine DynamoDB-Tabellenverschlüsselungskonfiguration unter Verwendung des DynamoDB Enhanced Client und erlaubte unsignierte Attribute [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), die durch ein eindeutiges Präfix definiert sind.
```
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());
```
**Logischer Tabellenname**
Ein logischer Tabellenname für Ihre DynamoDB-Tabelle.
Der logische Tabellenname ist kryptografisch an alle in der Tabelle gespeicherten Daten gebunden, um DynamoDB-Wiederherstellungsvorgänge zu vereinfachen. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Sie müssen immer denselben logischen Tabellennamen angeben. Damit die Entschlüsselung erfolgreich ist, muss der Name der logischen Tabelle mit dem Namen übereinstimmen, der bei der Verschlüsselung angegeben wurde. Falls sich Ihr DynamoDB-Tabellenname nach dem [Wiederherstellen Ihrer DynamoDB-Tabelle aus einer Sicherung](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) ändert, stellt der logische Tabellenname sicher, dass der Entschlüsselungsvorgang die Tabelle weiterhin erkennt.
**Zulässige Attribute ohne Vorzeichen**
Die `DO_NOTHING` in Ihren Attributaktionen markierten Attribute.
Die zulässigen Attribute ohne Vorzeichen teilen dem Client mit, welche Attribute von den Signaturen ausgeschlossen sind. Der Client geht davon aus, dass alle anderen Attribute in der Signatur enthalten sind. Beim Entschlüsseln eines Datensatzes bestimmt der Client dann aus den von Ihnen angegebenen zulässigen unsignierten Attributen, welche er überprüfen muss und welche ignoriert werden sollen. Sie können kein Attribut aus Ihren zulässigen Attributen ohne Vorzeichen entfernen.
Sie können die zulässigen Attribute ohne Vorzeichen explizit definieren, indem Sie ein Array erstellen, das alle Ihre `DO_NOTHING` Attribute auflistet. Sie können bei der Benennung Ihrer `DO_NOTHING` Attribute auch ein eindeutiges Präfix angeben und das Präfix verwenden, um dem Client mitzuteilen, welche Attribute vorzeichenlos sind. Wir empfehlen dringend, ein eindeutiges Präfix anzugeben, da dies das Hinzufügen eines neuen `DO_NOTHING` Attributs in der future vereinfacht. Weitere Informationen finden Sie unter [Aktualisierung Ihres Datenmodells](ddb-update-data-model.md).
Wenn Sie kein Präfix für alle `DO_NOTHING` Attribute angeben, können Sie ein `allowedUnsignedAttributes` Array konfigurieren, das explizit alle Attribute auflistet, von denen der Client erwarten sollte, dass sie nicht signiert sind, wenn er sie bei der Entschlüsselung findet. Sie sollten Ihre erlaubten vorzeichenlosen Attribute nur dann explizit definieren, wenn dies unbedingt erforderlich ist.
**Suchkonfiguration (optional)**
Das `SearchConfig` definiert die [Beacon-Version](using-beacons.md#beacon-version).
Der `SearchConfig` muss angegeben werden, um [durchsuchbare Verschlüsselung](searchable-encryption.md) oder [signierte](configure.md#signed-beacons) Beacons verwenden zu können.
**Algorithm Suite (optional)**
Die `algorithmSuiteId` definiert, welche Algorithmus-Suite das AWS Database Encryption SDK verwendet.
Sofern Sie nicht explizit eine alternative Algorithmussuite angeben, verwendet das AWS Database Encryption SDK die [Standard-Algorithmussuite](supported-algorithms.md#recommended-algorithms). [Die Standard-Algorithmussuite verwendet den AES-GCM-Algorithmus mit Schlüsselableitung, [digitalen Signaturen](concepts.md#digital-sigs) und Schlüsselzusage.](concepts.md#key-commitment) Obwohl die Standard-Algorithmus-Suite wahrscheinlich für die meisten Anwendungen geeignet ist, können Sie auch eine alternative Algorithmussuite wählen. Einige Vertrauensmodelle würden beispielsweise durch eine Algorithmus-Suite ohne digitale Signaturen erfüllt. Hinweise zu den Algorithmus-Suites, die das AWS Database Encryption SDK unterstützt, finden Sie unter[Unterstützte Algorithmus-Suiten im AWS Database Encryption SDK](supported-algorithms.md).
Um die [AES-GCM-Algorithmussuite ohne digitale ECDSA-Signaturen](supported-algorithms.md#other-algorithms) auszuwählen, nehmen Sie den folgenden Ausschnitt in Ihre Tabellenverschlüsselungskonfiguration auf.
```
.algorithmSuiteId(
DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384)
```
## Elemente mit dem Database Encryption SDK aktualisieren AWS
Das AWS Database Encryption SDK unterstützt [ddb:](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) nicht UpdateItem für Elemente, die verschlüsselt oder signiert wurden. Um ein verschlüsseltes oder signiertes Element zu aktualisieren, müssen Sie [ddb](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html): verwenden. PutItem Wenn Sie in Ihrer `PutItem` Anfrage denselben Primärschlüssel wie ein vorhandenes Element angeben, ersetzt das neue Element das vorhandene Element vollständig. Sie können [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) auch verwenden, um alle Attribute beim Speichern zu löschen und zu ersetzen, nachdem Sie Ihre Artikel aktualisiert haben.
## Signierte Sets entschlüsseln
Wenn Sie in den Versionen 3.0.0 und 3.1.0 des AWS Database Encryption SDK ein [Set-Typ-Attribut](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes.SetTypes) als definieren`SIGN_ONLY`, werden die Werte des Satzes in der Reihenfolge kanonisiert, in der sie bereitgestellt werden. DynamoDB behält die Reihenfolge der Sätze nicht bei. Daher besteht die Möglichkeit, dass die Signaturvalidierung des Elements, das den Satz enthält, fehlschlägt. Die Signaturvalidierung schlägt fehl, wenn die Werte des Satzes in einer anderen Reihenfolge zurückgegeben werden, als sie dem AWS Database Encryption SDK zur Verfügung gestellt wurden, auch wenn die Satzattribute dieselben Werte enthalten.
**Anmerkung**
Versionen 3.1.1 und höher des AWS Database Encryption SDK kanonisieren die Werte aller festgelegten Typattribute, sodass die Werte in derselben Reihenfolge gelesen werden, in der sie in DynamoDB geschrieben wurden.
Wenn die Signaturvalidierung fehlschlägt, schlägt der Entschlüsselungsvorgang fehl und es wird die folgende Fehlermeldung zurückgegeben.
| |
| --- |
| software.amazon.cryptography.dbencryptionsdk.structuredencryption.model. StructuredEncryptionException: Es wurde kein Empfänger-Tag gefunden. |
Wenn Sie die obige Fehlermeldung erhalten und glauben, dass das Element, das Sie zu entschlüsseln versuchen, einen Satz enthält, der mit Version 3.0.0 oder 3.1.0 signiert wurde, finden Sie im [DecryptWithPermute](https://github.com/aws/aws-database-encryption-sdk-dynamodb-java/tree/v3.1.1/DecryptWithPermute)Verzeichnis des aws-database-encryption-sdk -dynamodb-java-Repositorys weitere Informationen GitHub zur erfolgreichen Validierung des Satzes.
# Java-Beispiele
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Die folgenden Beispiele zeigen Ihnen, wie Sie die clientseitige Java-Verschlüsselungsbibliothek für DynamoDB verwenden, um die Tabellenelemente in Ihrer Anwendung zu schützen. Weitere Beispiele (und eigene Beispiele) finden Sie in den [Java-Beispielen](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/java/DynamoDbEncryption/src/main/java/software/amazon/cryptography/examples) im -dynamodb-Repository unter aws-database-encryption-sdk. GitHub
Die folgenden Beispiele zeigen, wie die clientseitige Java-Verschlüsselungsbibliothek für DynamoDB in einer neuen, nicht aufgefüllten Amazon DynamoDB-Tabelle konfiguriert wird. Wenn Sie Ihre vorhandenen Amazon DynamoDB-Tabellen für die clientseitige Verschlüsselung konfigurieren möchten, finden Sie weitere Informationen unter. [Fügen Sie Version 3.x zu einer vorhandenen Tabelle hinzu](ddb-java-config-existing-table.md)
**Topics**
+ [Verwenden des erweiterten DynamoDB-Clients](#ddb-java-enhanced-client-example)
+ [Verwenden der Low-Level-DynamoDB-API](#ddb-java-lowlevel-API-example)
+ [Verwenden Sie die untergeordnete Ebene DynamoDbItemEncryptor](#ddb-java-itemencryptor)
## Verwenden des erweiterten DynamoDB-Clients
Das folgende Beispiel zeigt, wie Sie den DynamoDB Enhanced Client und `DynamoDbEncryptionInterceptor` mit einem [AWS KMS Schlüsselbund](use-kms-keyring.md) verwenden, um DynamoDB-Tabellenelemente als Teil Ihrer DynamoDB-API-Aufrufe zu verschlüsseln.
Sie können jeden unterstützten [Schlüsselbund](keyrings.md) mit dem DynamoDB Enhanced Client verwenden, wir empfehlen jedoch, wann immer möglich, einen der AWS KMS Schlüsselringe zu verwenden.
**Anmerkung**
Der DynamoDB Enhanced Client unterstützt keine [durchsuchbare](searchable-encryption.md) Verschlüsselung. Verwenden Sie die `DynamoDbEncryptionInterceptor` zusammen mit der Low-Level-DynamoDB-API, um eine durchsuchbare Verschlüsselung zu verwenden.
**Sehen Sie sich das vollständige Codebeispiel an**[: .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)
**Schritt 1: Erstellen Sie den Schlüsselbund AWS KMS **
Das folgende Beispiel verwendet`CreateAwsKmsMrkMultiKeyring`, um einen AWS KMS Schlüsselbund mit einem symmetrischen Verschlüsselungs-KMS-Schlüssel zu erstellen. Die `CreateAwsKmsMrkMultiKeyring` Methode stellt sicher, dass der Schlüsselbund sowohl Schlüssel mit einer Region als auch Schlüssel mit mehreren Regionen korrekt verarbeitet.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Schritt 2: Erstellen Sie ein Tabellenschema aus der annotierten Datenklasse**
Im folgenden Beispiel wird die annotierte Datenklasse verwendet, um die zu erstellen. `TableSchema`
[In diesem Beispiel wird davon ausgegangen, dass die mit Anmerkungen versehenen Datenklassen- und Attributaktionen mithilfe der SimpleClass Datei .java definiert wurden.](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) Weitere Hinweise zum Kommentieren Ihrer Attributaktionen finden Sie unter. [Verwenden Sie eine Datenklasse mit Anmerkungen](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
Das AWS Database Encryption SDK unterstützt keine Anmerkungen zu [verschachtelten](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-adv-features-nested.html) Attributen.
```
final TableSchema schemaOnEncrypt = TableSchema.fromBean(SimpleClass.class);
```
**Schritt 3: Definieren Sie, welche Attribute von den Signaturen ausgeschlossen werden**
Im folgenden Beispiel wird davon ausgegangen, dass alle `DO_NOTHING` Attribute das eindeutige Präfix "`:`" haben, und verwendet dieses Präfix, um die zulässigen Attribute ohne Vorzeichen zu definieren. Der Client geht davon aus, dass alle Attributnamen mit dem Präfix "`:`" von den Signaturen ausgeschlossen sind. Weitere Informationen finden Sie unter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Schritt 4: Erstellen Sie die Verschlüsselungskonfiguration**
Das folgende Beispiel definiert eine `tableConfigs` Map, die die Verschlüsselungskonfiguration für die DynamoDB-Tabelle darstellt.
In diesem Beispiel wird der DynamoDB-Tabellenname als [logischer Tabellenname](ddb-java-using.md#logical-table-name) angegeben. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Weitere Informationen finden Sie unter [Verschlüsselungskonfiguration im AWS Database Encryption SDK für DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Um [durchsuchbare Verschlüsselung](searchable-encryption.md) oder [signierte Beacons](configure.md#signed-beacons) zu verwenden, müssen Sie die auch [`SearchConfig`](ddb-java-using.md#ddb-search-config)in Ihre Verschlüsselungskonfiguration aufnehmen.
```
final Map tableConfigs = new HashMap<>();
tableConfigs.put(ddbTableName,
DynamoDbEnhancedTableEncryptionConfig.builder()
.logicalTableName(ddbTableName)
.keyring(kmsKeyring)
.allowedUnsignedAttributePrefix(unsignedAttrPrefix)
.schemaOnEncrypt(tableSchema)
.build());
```
**Schritt 5: Erstellt das `DynamoDbEncryptionInterceptor`**
Im folgenden Beispiel wird `DynamoDbEncryptionInterceptor` mit dem `tableConfigs` aus **Schritt 4** ein neues erstellt.
```
final DynamoDbEncryptionInterceptor interceptor =
DynamoDbEnhancedClientEncryption.CreateDynamoDbEncryptionInterceptor(
CreateDynamoDbEncryptionInterceptorInput.builder()
.tableEncryptionConfigs(tableConfigs)
.build()
);
```
**Schritt 6: Einen neuen AWS SDK-DynamoDB-Client erstellen**
Im folgenden Beispiel wird ein neuer AWS SDK-DynamoDB-Client mit dem `interceptor` aus **Schritt** 5 erstellt.
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Schritt 7: DynamoDB Enhanced Client erstellen und eine Tabelle erstellen**
Im folgenden Beispiel wird der DynamoDB Enhanced Client mithilfe des AWS SDK-DynamoDB-Clients erstellt, der in **Schritt 6** erstellt wurde, und es wird eine Tabelle mit der annotierten Datenklasse erstellt.
```
final DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.builder()
.dynamoDbClient(ddb)
.build();
final DynamoDbTable table = enhancedClient.table(ddbTableName, tableSchema);
```
**Schritt 8: Verschlüsseln und signieren Sie ein Tabellenelement**
Im folgenden Beispiel wird mithilfe des DynamoDB Enhanced Client ein Element in die DynamoDB-Tabelle eingefügt. Das Element wird clientseitig verschlüsselt und signiert, bevor es an DynamoDB gesendet wird.
```
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);
```
## Verwenden der Low-Level-DynamoDB-API
Das folgende Beispiel zeigt, wie Sie die Low-Level-DynamoDB-API mit einem [AWS KMS Schlüsselbund](use-kms-keyring.md) verwenden, um Elemente automatisch clientseitig mit Ihren DynamoDB-Anfragen zu verschlüsseln und zu signieren. `PutItem`
Sie können jeden unterstützten [Schlüsselbund verwenden, wir empfehlen jedoch, wann immer möglich, einen der Schlüsselbunde](keyrings.md) zu verwenden. AWS KMS
**Sehen Sie sich das vollständige Codebeispiel** [an: .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)
**Schritt 1: Erstellen Sie den Schlüsselbund AWS KMS **
Das folgende Beispiel verwendet`CreateAwsKmsMrkMultiKeyring`, um einen AWS KMS Schlüsselbund mit einem symmetrischen Verschlüsselungs-KMS-Schlüssel zu erstellen. Die `CreateAwsKmsMrkMultiKeyring` Methode stellt sicher, dass der Schlüsselbund sowohl Schlüssel mit einer Region als auch Schlüssel mit mehreren Regionen korrekt verarbeitet.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Schritt 2: Konfigurieren Sie Ihre Attributaktionen**
Das folgende Beispiel definiert eine `attributeActionsOnEncrypt` Map, die [Beispiel-Attributaktionen](concepts.md#crypt-actions) für ein Tabellenelement darstellt.
Das folgende Beispiel definiert keine Attribute als`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen auch die Partitions- und Sortierattribute angegeben werden`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**Schritt 3: Definieren Sie, welche Attribute von den Signaturen ausgeschlossen werden**
Im folgenden Beispiel wird davon ausgegangen, dass alle `DO_NOTHING` Attribute das eindeutige Präfix "`:`" haben, und verwendet dieses Präfix, um die zulässigen Attribute ohne Vorzeichen zu definieren. Der Client geht davon aus, dass alle Attributnamen mit dem Präfix "`:`" von den Signaturen ausgeschlossen sind. Weitere Informationen finden Sie unter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Schritt 4: Definieren Sie die Konfiguration der DynamoDB-Tabellenverschlüsselung**
Das folgende Beispiel definiert eine `tableConfigs` Map, die die Verschlüsselungskonfiguration für diese DynamoDB-Tabelle darstellt.
In diesem Beispiel wird der DynamoDB-Tabellenname als [logischer Tabellenname](ddb-java-using.md#logical-table-name) angegeben. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Weitere Informationen finden Sie unter [Verschlüsselungskonfiguration im AWS Database Encryption SDK für DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Um [durchsuchbare Verschlüsselung](searchable-encryption.md) oder [signierte Beacons](configure.md#signed-beacons) zu verwenden, müssen Sie die auch [`SearchConfig`](ddb-java-using.md#ddb-search-config)in Ihre Verschlüsselungskonfiguration aufnehmen.
```
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);
```
**Schritt 5: Erstellen Sie das `DynamoDbEncryptionInterceptor`**
Im folgenden Beispiel wird das `DynamoDbEncryptionInterceptor` mit dem `tableConfigs` aus **Schritt 4** erstellt.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
**Schritt 6: Einen neuen AWS SDK-DynamoDB-Client erstellen**
Im folgenden Beispiel wird ein neuer AWS SDK-DynamoDB-Client mit dem `interceptor` aus **Schritt** 5 erstellt.
```
final DynamoDbClient ddb = DynamoDbClient.builder()
.overrideConfiguration(
ClientOverrideConfiguration.builder()
.addExecutionInterceptor(interceptor)
.build())
.build();
```
**Schritt 7: Verschlüsseln und Signieren eines DynamoDB-Tabellenelements**
Das folgende Beispiel definiert eine `item` Map, die ein Beispieltabellenelement darstellt, und platziert das Element in der DynamoDB-Tabelle. Das Element wird clientseitig verschlüsselt und signiert, bevor es an DynamoDB gesendet wird.
```
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);
```
## Verwenden Sie die untergeordnete Ebene DynamoDbItemEncryptor
Das folgende Beispiel zeigt, wie Sie die untergeordnete Ebene `DynamoDbItemEncryptor` mit einem [AWS KMS Schlüsselbund](use-kms-keyring.md) verwenden, um Tabellenelemente direkt zu verschlüsseln und zu signieren. Das `DynamoDbItemEncryptor` fügt das Element nicht in Ihre DynamoDB-Tabelle ein.
Sie können jeden unterstützten [Schlüsselbund](keyrings.md) mit dem DynamoDB Enhanced Client verwenden, wir empfehlen jedoch, wann immer möglich, einen der AWS KMS Schlüsselringe zu verwenden.
**Anmerkung**
[Die untergeordnete Ebene unterstützt keine durchsuchbare Verschlüsselung. `DynamoDbItemEncryptor`](searchable-encryption.md) Verwenden Sie die `DynamoDbEncryptionInterceptor` zusammen mit der Low-Level-DynamoDB-API, um eine durchsuchbare Verschlüsselung zu verwenden.
**Sehen Sie sich das vollständige Codebeispiel an**[: .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)
**Schritt 1: Erstellen Sie den Schlüsselbund AWS KMS **
Das folgende Beispiel verwendet`CreateAwsKmsMrkMultiKeyring`, um einen AWS KMS Schlüsselbund mit einem symmetrischen Verschlüsselungs-KMS-Schlüssel zu erstellen. Die `CreateAwsKmsMrkMultiKeyring` Methode stellt sicher, dass der Schlüsselbund sowohl Schlüssel mit einer Region als auch Schlüssel mit mehreren Regionen korrekt verarbeitet.
```
final MaterialProviders matProv = MaterialProviders.builder()
.MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
.build();
final CreateAwsKmsMrkMultiKeyringInput keyringInput = CreateAwsKmsMrkMultiKeyringInput.builder()
.generator(kmsKeyId)
.build();
final IKeyring kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Schritt 2: Konfigurieren Sie Ihre Attributaktionen**
Das folgende Beispiel definiert eine `attributeActionsOnEncrypt` Map, die [Beispiel-Attributaktionen](concepts.md#crypt-actions) für ein Tabellenelement darstellt.
Das folgende Beispiel definiert keine Attribute als`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen auch die Partitions- und Sortierattribute angegeben werden`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
final Map attributeActionsOnEncrypt = new HashMap<>();
// The partition attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("partition_key", CryptoAction.SIGN_ONLY);
// The sort attribute must be SIGN_ONLY
attributeActionsOnEncrypt.put("sort_key", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put("attribute1", CryptoAction.ENCRYPT_AND_SIGN);
attributeActionsOnEncrypt.put("attribute2", CryptoAction.SIGN_ONLY);
attributeActionsOnEncrypt.put(":attribute3", CryptoAction.DO_NOTHING);
```
**Schritt 3: Definieren Sie, welche Attribute von den Signaturen ausgeschlossen werden**
Im folgenden Beispiel wird davon ausgegangen, dass alle `DO_NOTHING` Attribute das eindeutige Präfix "`:`" haben, und verwendet dieses Präfix, um die zulässigen Attribute ohne Vorzeichen zu definieren. Der Client geht davon aus, dass alle Attributnamen mit dem Präfix "`:`" von den Signaturen ausgeschlossen sind. Weitere Informationen finden Sie unter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**Schritt 4: Definieren Sie die `DynamoDbItemEncryptor` Konfiguration**
Das folgende Beispiel definiert die Konfiguration für die`DynamoDbItemEncryptor`.
In diesem Beispiel wird der DynamoDB-Tabellenname als [logischer Tabellenname](ddb-java-using.md#logical-table-name) angegeben. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Weitere Informationen finden Sie unter [Verschlüsselungskonfiguration im AWS Database Encryption SDK für 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();
```
**Schritt 5: Erstellen Sie das `DynamoDbItemEncryptor`**
Im folgenden Beispiel wird `DynamoDbItemEncryptor` mit dem `config` aus **Schritt 4** ein neues erstellt.
```
final DynamoDbItemEncryptor itemEncryptor = DynamoDbItemEncryptor.builder()
.DynamoDbItemEncryptorConfig(config)
.build();
```
**Schritt 6: Verschlüsseln und signieren Sie ein Tabellenelement direkt**
Im folgenden Beispiel wird ein Element direkt verschlüsselt und signiert mit dem. `DynamoDbItemEncryptor` Das `DynamoDbItemEncryptor` fügt das Element nicht in Ihre DynamoDB-Tabelle ein.
```
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();
```
# Konfigurieren Sie eine bestehende DynamoDB-Tabelle für die Verwendung des AWS Database Encryption SDK für DynamoDB
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Mit Version 3. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB können Sie Ihre vorhandenen Amazon DynamoDB-Tabellen für die clientseitige Verschlüsselung konfigurieren. Dieses Thema enthält Anleitungen zu den drei Schritten, die Sie ausführen müssen, um Version 3 hinzuzufügen. *x* zu einer vorhandenen, gefüllten DynamoDB-Tabelle.
**Voraussetzungen**
Version 3. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB erfordert den DynamoDB Enhanced Client, der unter [bereitgestellt](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) wird. AWS SDK for Java 2.x Wenn Sie [Dynamo weiterhin verwendenDBMapper, müssen Sie auf den DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) AWS SDK for Java 2.x Enhanced Client migrieren.
Folgen Sie den Anweisungen für die [Migration von Version 1.x auf 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) von. AWS SDK für Java
Folgen Sie dann den Anweisungen [unter Erste Schritte mit der DynamoDB Enhanced Client API](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-getting-started.html).
[Bevor Sie Ihre Tabelle für die Verwendung der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB konfigurieren, müssen Sie eine [Datenklasse `TableSchema` mit Anmerkungen generieren und einen erweiterten](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 erstellen.](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)
## Schritt 1: Bereiten Sie das Lesen und Schreiben verschlüsselter Elemente vor
Gehen Sie wie folgt vor, um Ihren AWS Database Encryption SDK-Client auf das Lesen und Schreiben verschlüsselter Elemente vorzubereiten. Nachdem Sie die folgenden Änderungen vorgenommen haben, liest und schreibt Ihr Client weiterhin Klartext-Elemente. Neue Elemente, die in die Tabelle geschrieben werden, werden nicht verschlüsselt oder signiert, aber es kann verschlüsselte Elemente entschlüsseln, sobald sie erscheinen. Diese Änderungen bereiten den Client darauf vor, mit der [Verschlüsselung](#ddb-java-add-step2) neuer Elemente zu beginnen. Die folgenden Änderungen müssen auf jedem Lesegerät installiert werden, bevor Sie mit dem nächsten Schritt fortfahren.
**1. Definieren Sie Ihre [Attributaktionen](concepts.md#crypt-actions)**
Aktualisieren Sie Ihre Datenklasse mit Anmerkungen, sodass sie Attributaktionen enthält, die definieren, welche Attributwerte verschlüsselt und signiert werden, welche nur signiert und welche ignoriert werden.
Weitere Hinweise zu den aws-database-encryption-sdk DynamoDB Enhanced Client-Anmerkungen finden Sie unter [SimpleClass GitHub.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) im -dynamodb-Repository unter.
Standardmäßig sind Primärschlüsselattribute signiert, aber nicht verschlüsselt (`SIGN_ONLY`), und alle anderen Attribute sind verschlüsselt und signiert (). `ENCRYPT_AND_SIGN` Um Ausnahmen anzugeben, verwenden Sie die Verschlüsselungsanmerkungen, die in der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB definiert sind. Wenn Sie beispielsweise möchten, dass ein bestimmtes Attribut nur ein Zeichen sein soll, verwenden Sie die Anmerkung. `@DynamoDbEncryptionSignOnly` Wenn Sie möchten, dass ein bestimmtes Attribut signiert und in den Verschlüsselungskontext aufgenommen wird, verwenden Sie die `@DynamoDbEncryptionSignAndIncludeInEncryptionContext` Anmerkung. Wenn Sie möchten, dass ein bestimmtes Attribut weder signiert noch verschlüsselt (`DO_NOTHING`) wird, verwenden Sie die `@DynamoDbEncryptionDoNothing` Anmerkung.
Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen dies auch die Partitions- und Sortierattribute sein`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Ein Beispiel, das die zur Definition verwendeten Anmerkungen zeigt`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, finden Sie unter [SimpleClass4.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).
Ein Beispiel für Anmerkungen finden Sie unter. [Verwenden Sie eine Datenklasse mit Anmerkungen](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
**2. Definieren Sie, welche Attribute von den Signaturen ausgeschlossen werden**
Das folgende Beispiel geht davon aus, dass alle `DO_NOTHING` Attribute das eindeutige Präfix "`:`" haben, und verwendet dieses Präfix, um die zulässigen Attribute ohne Vorzeichen zu definieren. Der Client geht davon aus, dass alle Attributnamen mit dem Präfix "`:`" von den Signaturen ausgeschlossen sind. Weitere Informationen finden Sie unter [Allowed unsigned attributes](ddb-java-using.md#allowed-unauth).
```
final String unsignedAttrPrefix = ":";
```
**3. Erstellen Sie einen [Schlüsselbund](keyrings.md)**
Im folgenden Beispiel wird ein [AWS KMS Schlüsselbund](use-kms-keyring.md) erstellt. Der AWS KMS Schlüsselbund verwendet symmetrische Verschlüsselung oder asymmetrisches RSA, um Datenschlüssel AWS KMS keys zu generieren, zu verschlüsseln und zu entschlüsseln.
In diesem Beispiel wird ein AWS KMS Schlüsselbund `CreateMrkMultiKeyring` mit einem KMS-Schlüssel mit symmetrischer Verschlüsselung erstellt. Die `CreateAwsKmsMrkMultiKeyring` Methode stellt sicher, dass der Schlüsselbund sowohl Schlüssel mit einer Region als auch Schlüssel mit mehreren Regionen korrekt verarbeitet.
```
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. Definieren Sie die Konfiguration der DynamoDB-Tabellenverschlüsselung **
Das folgende Beispiel definiert eine `tableConfigs` Map, die die Verschlüsselungskonfiguration für diese DynamoDB-Tabelle darstellt.
In diesem Beispiel wird der DynamoDB-Tabellenname als [logischer Tabellenname](ddb-java-using.md#logical-table-name) angegeben. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Weitere Informationen finden Sie unter [Verschlüsselungskonfiguration im AWS Database Encryption SDK für DynamoDB](ddb-java-using.md#ddb-config-encrypt).
Sie müssen `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` als Klartext-Override angeben. Diese Richtlinie liest und schreibt weiterhin Klartext-Elemente, liest verschlüsselte Elemente und bereitet den Client darauf vor, verschlüsselte Elemente zu schreiben.
```
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. Erstellen der `DynamoDbEncryptionInterceptor`**
Im folgenden Beispiel wird das `DynamoDbEncryptionInterceptor` mit dem `tableConfigs` aus **Schritt 3** erstellten erstellt.
```
DynamoDbEncryptionInterceptor interceptor = DynamoDbEncryptionInterceptor.builder()
.config(DynamoDbTablesEncryptionConfig.builder()
.tableEncryptionConfigs(tableConfigs)
.build())
.build();
```
## Schritt 2: Schreiben Sie verschlüsselte und signierte Elemente
Aktualisieren Sie die Klartext-Richtlinie in Ihrer `DynamoDbEncryptionInterceptor` Konfiguration, damit der Client verschlüsselte und signierte Elemente schreiben kann. Nachdem Sie die folgende Änderung implementiert haben, verschlüsselt und signiert der Client neue Elemente auf der Grundlage der Attributaktionen, die Sie in **Schritt** 1 konfiguriert haben. Der Client kann Klartext-Elemente sowie verschlüsselte und signierte Elemente lesen.
Bevor Sie mit [Schritt 3](#ddb-java-add-step3) fortfahren, müssen Sie alle vorhandenen Klartextelemente in Ihrer Tabelle verschlüsseln und signieren. Es gibt keine einzelne Metrik oder Abfrage, die Sie ausführen können, um Ihre vorhandenen Klartextelemente schnell zu verschlüsseln. Verwenden Sie den Prozess, der für Ihr System am sinnvollsten ist. Sie könnten beispielsweise einen asynchronen Prozess verwenden, der die Tabelle langsam scannt und dann die Elemente mithilfe der von Ihnen definierten Attributaktionen und der Verschlüsselungskonfiguration neu schreibt. Um die Klartext-Elemente in Ihrer Tabelle zu identifizieren, empfehlen wir, nach allen Elementen zu suchen, die nicht die `aws_dbe_foot` Attribute `aws_dbe_head` und enthalten, die das AWS Database Encryption SDK Elementen hinzufügt, wenn sie verschlüsselt und signiert sind.
Im folgenden Beispiel wird die Konfiguration der Tabellenverschlüsselung aus **Schritt 1** aktualisiert. Sie müssen die Klartext-Override mit `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` aktualisieren. Diese Richtlinie liest weiterhin Klartext-Elemente, liest und schreibt aber auch verschlüsselte Elemente. Erstellen Sie ein neues `DynamoDbEncryptionInterceptor` mit dem aktualisierten`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);
```
## Schritt 3: Nur verschlüsselte und signierte Elemente lesen
Nachdem Sie alle Ihre Elemente verschlüsselt und signiert haben, aktualisieren Sie die Klartext-Überschreibung in Ihrer `DynamoDbEncryptionInterceptor` Konfiguration, sodass der Client nur verschlüsselte und signierte Elemente lesen und schreiben kann. Nachdem Sie die folgende Änderung implementiert haben, verschlüsselt und signiert der Client neue Elemente auf der Grundlage der Attributaktionen, die Sie in **Schritt** 1 konfiguriert haben. Der Client kann nur verschlüsselte und signierte Elemente lesen.
Im folgenden Beispiel wird die Konfiguration der Tabellenverschlüsselung aus **Schritt 2** aktualisiert. Sie können entweder die Klartext-Override mit der Klartext-Richtlinie aktualisieren `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` oder die Klartext-Richtlinie aus Ihrer Konfiguration entfernen. Der Client liest und schreibt standardmäßig nur verschlüsselte und signierte Elemente. Erstellen Sie ein neues `DynamoDbEncryptionInterceptor` mit dem aktualisierten`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);
```
# Migrieren Sie auf Version 3.x der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB
****
| |
| --- |
| Unsere clientseitige Verschlüsselungsbibliothek wurde in AWS Database Encryption SDK umbenannt. Dieses Entwicklerhandbuch enthält weiterhin Informationen zum [DynamoDB Encryption Client](legacy-dynamodb-encryption-client.md). |
Version 3. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB ist eine grundlegende Neufassung der 2. *x-Codebasis*. Es enthält viele Updates, wie z. B. ein neues strukturiertes Datenformat, verbesserte Mehrmandantenunterstützung, nahtlose Schemaänderungen und Unterstützung für durchsuchbare Verschlüsselung. Dieses Thema enthält Anleitungen zur Migration Ihres Codes auf Version 3. *x.*
## Migration von Version 1.x auf 2.x
Migrieren Sie auf Version 2. *x* bevor Sie auf Version 3 migrieren. *x.* Ausführung 2. *x* hat das Symbol für den neuesten Anbieter von `MostRecentProvider` zu geändert`CachingMostRecentProvider`. Wenn Sie derzeit Version 1 verwenden. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB mit dem `MostRecentProvider` Symbol, auf das Sie den Symbolnamen in Ihrem Code aktualisieren müssen. `CachingMostRecentProvider` Weitere Informationen finden Sie unter [Updates für den neuesten Anbieter](most-recent-provider.md#mrp-versions).
## Migration von Version 2.x auf 3.x
Die folgenden Verfahren beschreiben, wie Sie Ihren Code von Version 2 migrieren. *x* auf Version 3. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB.
### Schritt 1. Bereiten Sie sich darauf vor, Elemente im neuen Format zu lesen
Gehen Sie wie folgt vor, um Ihren AWS Database Encryption SDK-Client darauf vorzubereiten, Elemente im neuen Format zu lesen. Nachdem Sie die folgenden Änderungen implementiert haben, wird sich Ihr Client weiterhin genauso verhalten wie in Version 2. *x.* Ihr Kunde wird weiterhin Elemente in der Version 2 lesen und schreiben. *X-Format*, aber diese Änderungen bereiten den Client darauf vor, [Elemente im neuen Format zu lesen](#ddb-java-migrate-step2).
**Aktualisieren Sie Ihre Version AWS SDK für Java auf Version 2.x**
Version 3. *x* [der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB erfordert den DynamoDB Enhanced Client.](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/dynamodb-enhanced-client.html) Der DynamoDB Enhanced Client ersetzt den in früheren Versionen DBMapper verwendeten [Dynamo](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html). Um den erweiterten Client zu verwenden, müssen Sie den verwenden. AWS SDK for Java 2.x
Folgen Sie den Anweisungen für die [Migration von Version 1.x auf 2.x](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/migration.html) von. AWS SDK für Java
Weitere Informationen darüber, welche AWS SDK for Java 2.x Module erforderlich sind, finden Sie unter. [Voraussetzungen](ddb-java.md#ddb-java-prerequisites)
**Konfigurieren Sie Ihren Client so, dass er Elemente liest, die mit älteren Versionen verschlüsselt wurden**
Die folgenden Verfahren bieten einen Überblick über die Schritte, die im folgenden Codebeispiel demonstriert werden.
1. Erstellen Sie einen [Schlüsselbund](keyrings.md).
Keyrings und [Cryptographic Materials Manager](concepts.md#crypt-materials-manager) ersetzen die Anbieter für kryptografisches Material, die in früheren Versionen der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB verwendet wurden.
**Wichtig**
Die Umschließungsschlüssel, die Sie bei der Erstellung eines Schlüsselbunds angeben, müssen dieselben Wickelschlüssel sein, die Sie in Version 2 mit Ihrem Anbieter für kryptografisches Material verwendet haben. *x.*
1. Erstellen Sie ein Tabellenschema über Ihrer annotierten Klasse.
In diesem Schritt werden die Attributaktionen definiert, die verwendet werden, wenn Sie mit dem Schreiben von Elementen im neuen Format beginnen.
Anleitungen zur Verwendung des neuen DynamoDB Enhanced Client finden Sie unter [Generate a `TableSchema`](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/ddb-en-client-gs-tableschema.html) im *AWS SDK für Java Developer* Guide.
Im folgenden Beispiel wird davon ausgegangen, dass Sie Ihre annotierte Klasse aus Version 2 aktualisiert haben. *x* verwendet die neuen Anmerkungen zu Attributaktionen. Weitere Hinweise zum Kommentieren Ihrer Attributaktionen finden Sie unter. [Verwenden Sie eine Datenklasse mit Anmerkungen](ddb-java-using.md#ddb-attribute-actions-annotated-data-class)
**Anmerkung**
Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen auch die Partitions- und Sortierattribute angegeben werden`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Ein Beispiel, das die zur Definition verwendeten Anmerkungen zeigt`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, finden Sie unter [SimpleClass4.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. Definieren Sie, [welche Attribute von der Signatur ausgeschlossen werden](ddb-java-using.md#allowed-unauth).
1. Konfigurieren Sie eine explizite Zuordnung der Attributaktionen, die in Ihrer modellierten Klasse von Version 2.x konfiguriert sind.
In diesem Schritt werden die Attributaktionen definiert, die zum Schreiben von Elementen im alten Format verwendet wurden.
1. Konfigurieren `DynamoDBEncryptor` Sie die, die Sie in Version 2 verwendet haben. *x* der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB.
1. Konfigurieren Sie das ältere Verhalten.
1. Erstellen Sie einen `DynamoDbEncryptionInterceptor`.
1. Erstellen Sie einen neuen AWS SDK-DynamoDB-Client.
1. Erstellen Sie die `DynamoDBEnhancedClient` und erstellen Sie eine Tabelle mit Ihrer modellierten Klasse.
Weitere Informationen zum DynamoDB Enhanced Client finden Sie unter [Erstellen eines erweiterten](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) Clients.
```
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);
}
}
```
### Schritt 2. Schreiben Sie Elemente im neuen Format
Nachdem Sie die Änderungen aus Schritt 1 für alle Leser bereitgestellt haben, führen Sie die folgenden Schritte aus, um Ihren AWS Database Encryption SDK-Client so zu konfigurieren, dass er Elemente im neuen Format schreibt. Nachdem Sie die folgenden Änderungen implementiert haben, liest Ihr Client weiterhin Elemente im alten Format und beginnt, Elemente im neuen Format zu schreiben und zu lesen.
Die folgenden Verfahren bieten einen Überblick über die Schritte, die im folgenden Codebeispiel demonstriert werden.
1. Fahren Sie mit der Konfiguration Ihres Schlüsselbundes, des Tabellenschemas`allowedUnsignedAttributes`, der veralteten Attributaktionen und `DynamoDBEncryptor` wie in [**Schritt 1 fort**](#ddb-java-migrate-step1).
1. Aktualisieren Sie Ihr bisheriges Verhalten, sodass nur neue Elemente mit dem neuen Format geschrieben werden.
1. Erstellen eines `DynamoDbEncryptionInterceptor `
1. Erstellen Sie einen neuen AWS SDK-DynamoDB-Client.
1. Erstellen Sie die `DynamoDBEnhancedClient` und erstellen Sie eine Tabelle mit Ihrer modellierten Klasse.
Weitere Informationen zum DynamoDB Enhanced Client finden Sie unter [Erstellen eines erweiterten](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) Clients.
```
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);
}
}
```
[Nach der Bereitstellung der Änderungen in Schritt 2 müssen Sie alle alten Elemente in Ihrer Tabelle erneut mit dem neuen Format verschlüsseln, bevor Sie mit Schritt 3 fortfahren können.](#ddb-java-migrate-step3) Es gibt keine einzelne Metrik oder Abfrage, die Sie ausführen können, um Ihre vorhandenen Elemente schnell zu verschlüsseln. Verwenden Sie den Prozess, der für Ihr System am sinnvollsten ist. Sie könnten beispielsweise einen asynchronen Prozess verwenden, der die Tabelle langsam scannt und dann die Elemente mithilfe der neuen Attributaktionen und der Verschlüsselungskonfiguration, die Sie definiert haben, neu schreibt.
### Schritt 3. Nur Elemente im neuen Format lesen und schreiben
Nachdem Sie alle Elemente in Ihrer Tabelle mit dem neuen Format erneut verschlüsselt haben, können Sie das alte Verhalten aus Ihrer Konfiguration entfernen. Gehen Sie wie folgt vor, um Ihren Client so zu konfigurieren, dass er nur Elemente im neuen Format liest und schreibt.
Die folgenden Verfahren bieten einen Überblick über die Schritte, die im folgenden Codebeispiel demonstriert werden.
1. Fahren Sie mit der Konfiguration Ihres Schlüsselbundes und des `allowedUnsignedAttributes` Tabellenschemas wie in [**Schritt 1 fort**](#ddb-java-migrate-step1). Entfernen Sie die veralteten Attributaktionen und `DynamoDBEncryptor` aus Ihrer Konfiguration.
1. Erstellen Sie einen `DynamoDbEncryptionInterceptor`.
1. Erstellen Sie einen neuen AWS SDK-DynamoDB-Client.
1. Erstellen Sie die `DynamoDBEnhancedClient` und erstellen Sie eine Tabelle mit Ihrer modellierten Klasse.
Weitere Informationen zum DynamoDB Enhanced Client finden Sie unter [Erstellen eines erweiterten](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) Clients.
```
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
In diesem Thema wird erklärt, wie Version 3 installiert und verwendet wird. *x* der clientseitigen .NET-Verschlüsselungsbibliothek für DynamoDB. Einzelheiten zur Programmierung mit dem AWS Database Encryption SDK für DynamoDB finden Sie in [den.NET-Beispielen](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/) im aws-database-encryption-sdk -dynamodb-Repository unter. GitHub
Die clientseitige .NET-Verschlüsselungsbibliothek für DynamoDB richtet sich an Entwickler, die Anwendungen in C\$1 und anderen .NET-Programmiersprachen schreiben. Sie wird unter Windows, macOS und Linux unterstützt.
Alle [Programmiersprachenimplementierungen](ddb-programming-languages.md) des AWS Database Encryption SDK für DynamoDB sind interoperabel. Leere Werte für Listen- oder Zuordnungsdatentypen werden jedoch SDK für .NET nicht unterstützt. Das heißt, wenn Sie die clientseitige Java-Verschlüsselungsbibliothek für DynamoDB verwenden, um ein Element zu schreiben, das leere Werte für einen Listen- oder Zuordnungsdatentyp enthält, können Sie dieses Element nicht mit der clientseitigen .NET-Verschlüsselungsbibliothek für DynamoDB entschlüsseln und lesen.
**Topics**
+ [Installation](#ddb-net-install)
+ [Debuggen](#ddb-net-debugging)
+ [Verwenden des .NET-Clients](ddb-net-using.md)
+ [.NET-Beispiele](ddb-net-examples.md)
+ [Fügen Sie Version 3.x zu einer vorhandenen Tabelle hinzu](ddb-net-config-existing-table.md)
## Installation der clientseitigen .NET-Verschlüsselungsbibliothek für DynamoDB
[Die.NET-clientseitige Verschlüsselungsbibliothek für DynamoDB ist als AWS.Cryptography verfügbar. DbEncryptionSDK. DynamoDb](https://www.nuget.org/packages/AWS.Cryptography.DbEncryptionSDK.DynamoDb/)verpacken in NuGet. Einzelheiten zur Installation und Erstellung der Bibliothek finden Sie in [der.NET-README.md-Datei](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/DynamoDbEncryption/runtimes/net/README.md) im -dynamodb-Repository. aws-database-encryption-sdk Die.NET-clientseitige Verschlüsselungsbibliothek für DynamoDB erfordert die Schlüssel, SDK für .NET auch wenn Sie keine () verwenden AWS Key Management Service .AWS KMS Die SDK für .NET wird mit dem Paket installiert. NuGet
Version 3. *x* der clientseitigen .NET-Verschlüsselungsbibliothek für DynamoDB unterstützt .NET 6.0 und .NET Framework net48 und höher.
## Debuggen mit.NET
Die.NET-clientseitige Verschlüsselungsbibliothek für DynamoDB generiert keine Protokolle. Ausnahmen in der clientseitigen .NET-Verschlüsselungsbibliothek für DynamoDB generieren eine Ausnahmemeldung, aber keine Stack-Traces.
Um Ihnen beim Debuggen zu helfen, stellen Sie sicher, dass Sie die Anmeldung bei aktivieren. SDK für .NET Mithilfe der Protokolle und Fehlermeldungen von SDK für .NET können Sie Fehler, die in der auftreten, SDK für .NET von denen in der clientseitigen .NET-Verschlüsselungsbibliothek für DynamoDB unterscheiden. *Hilfe zur SDK für .NET Protokollierung finden Sie [AWSLogging](https://docs.aws.amazon.com/sdk-for-net/latest/developer-guide/net-dg-config-other.html#config-setting-awslogging)im Entwicklerhandbuch.AWS SDK für .NET * (Um das Thema zu lesen, erweitern Sie den Abschnitt **Öffnen, um .NET Framework-Inhalte anzuzeigen**.)
# Verwenden der clientseitigen .NET-Verschlüsselungsbibliothek für DynamoDB
In diesem Thema werden einige der Funktionen und Hilfsklassen in Version 3 erklärt. *x* der clientseitigen .NET-Verschlüsselungsbibliothek für DynamoDB.
Einzelheiten zur Programmierung mit der clientseitigen .NET-Verschlüsselungsbibliothek für DynamoDB finden Sie in [den.NET-Beispielen](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/) im -dynamodb-Repository unter. aws-database-encryption-sdk GitHub
**Topics**
+ [Elementverschlüssler](#ddb-net-item-encryptors)
+ [Attributaktionen](#ddb-net-attribute-actions)
+ [Verschlüsselungskonfiguration](#ddb-net-config-encrypt)
+ [Artikel werden aktualisiert](#ddb-net-update-items)
## Elementverschlüssler
Im Kern ist das AWS Database Encryption SDK für DynamoDB ein Elementverschlüsseler. Sie können Version 3 verwenden. *x* der clientseitigen .NET-Verschlüsselungsbibliothek für DynamoDB, um Ihre DynamoDB-Tabellenelemente auf folgende Weise zu verschlüsseln, zu signieren, zu verifizieren und zu entschlüsseln.
**Das AWS Low-Level-Datenbankverschlüsselungs-SDK für die DynamoDB-API**
Sie können Ihre [Tabellenverschlüsselungskonfiguration](#ddb-net-config-encrypt) verwenden, um einen DynamoDB-Client zu erstellen, der Elemente automatisch clientseitig mit Ihren DynamoDB-Anfragen verschlüsselt und signiert. `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)
[Sie müssen das AWS Low-Level-Datenbankverschlüsselungs-SDK für DynamoDB-API verwenden, um durchsuchbare Verschlüsselung verwenden zu können.](searchable-encryption.md)
**Die untergeordnete Ebene `DynamoDbItemEncryptor`**
Die untergeordnete Ebene verschlüsselt und signiert oder entschlüsselt und verifiziert Ihre Tabellenelemente `DynamoDbItemEncryptor` direkt, ohne DynamoDB aufzurufen. Es stellt keine DynamoDB `PutItem` oder `GetItem` Anfragen. Sie können beispielsweise die untergeordnete Ebene verwenden, `DynamoDbItemEncryptor` um ein DynamoDB-Element, das Sie bereits abgerufen haben, direkt zu entschlüsseln und zu verifizieren. Wenn Sie die untergeordnete Ebene verwenden`DynamoDbItemEncryptor`, empfehlen wir die Verwendung des [Low-Level-Programmiermodells](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/dynamodb-intro.html#dynamodb-intro-apis-low-level), das für die Kommunikation mit SDK für .NET DynamoDB vorgesehen ist.
[Die untergeordnete Ebene unterstützt keine durchsuchbare Verschlüsselung`DynamoDbItemEncryptor`.](searchable-encryption.md)
## Attributaktionen im AWS Database Encryption SDK für DynamoDB
[Attributaktionen](concepts.md#crypt-actions) bestimmen, welche Attributwerte verschlüsselt und signiert werden, welche nur signiert sind, welche signiert und in den Verschlüsselungskontext aufgenommen werden und welche ignoriert werden.
Um Attributaktionen mit dem .NET-Client anzugeben, definieren Sie Attributaktionen manuell mithilfe eines Objektmodells. Geben Sie Ihre Attributaktionen an, indem Sie ein `Dictionary` Objekt erstellen, in dem die Name-Wert-Paare für Attributnamen und die angegebenen Aktionen stehen.
Geben Sie `ENCRYPT_AND_SIGN` an, dass ein Attribut verschlüsselt und signiert werden soll. Geben Sie `SIGN_ONLY` an, dass ein Attribut signiert, aber nicht verschlüsselt werden soll. Geben Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` an, dass ein Attribut signiert und in den Verschlüsselungskontext aufgenommen werden soll. Sie können ein Attribut nicht verschlüsseln, ohne es auch zu signieren. Geben Sie `DO_NOTHING` an, ob ein Attribut ignoriert werden soll.
Die Partitions- und Sortierattribute müssen entweder `SIGN_ONLY` oder lauten`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Wenn Sie Attribute als definieren`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, müssen dies auch die Partitions- und Sortierattribute sein`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**Anmerkung**
Nachdem Sie Ihre Attributaktionen definiert haben, müssen Sie definieren, welche Attribute von den Signaturen ausgeschlossen werden. Um das future Hinzufügen neuer Attribute ohne Vorzeichen zu vereinfachen, empfehlen wir, ein eindeutiges Präfix (wie "`:`„) zu wählen, um Ihre vorzeichenlosen Attribute zu identifizieren. Nehmen Sie dieses Präfix in den Attributnamen für alle Attribute auf, die Sie bei der Definition Ihres DynamoDB-Schemas und Ihrer Attributaktionen markiert `DO_NOTHING` haben.
Das folgende Objektmodell veranschaulicht, wie Sie`ENCRYPT_AND_SIGN`, `SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, und `DO_NOTHING` Attributaktionen mit dem .NET-Client angeben. In diesem Beispiel wird das Präfix "`:`" verwendet, um `DO_NOTHING` Attribute zu identifizieren.
**Anmerkung**
Um die `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` kryptografische Aktion verwenden zu können, müssen Sie Version 3.3 oder höher des AWS Database Encryption SDK verwenden. Stellen Sie die neue Version für alle Leser bereit, bevor [Sie Ihr Datenmodell so aktualisieren](ddb-update-data-model.md), dass es diese enthält`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
};
```
## Verschlüsselungskonfiguration im AWS Database Encryption SDK für DynamoDB
Wenn Sie das AWS Database Encryption SDK verwenden, müssen Sie explizit eine Verschlüsselungskonfiguration für Ihre DynamoDB-Tabelle definieren. Die in Ihrer Verschlüsselungskonfiguration erforderlichen Werte hängen davon ab, ob Sie Ihre Attributaktionen manuell oder mit einer annotierten Datenklasse definiert haben.
Der folgende Ausschnitt definiert eine DynamoDB-Tabellenverschlüsselungskonfiguration unter Verwendung des AWS Low-Level-Datenbankverschlüsselungs-SDK für DynamoDB-API und zulässige unsignierte Attribute, die durch ein eindeutiges Präfix definiert sind.
```
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);
```
**Logischer Tabellenname**
Ein logischer Tabellenname für Ihre DynamoDB-Tabelle.
Der logische Tabellenname ist kryptografisch an alle in der Tabelle gespeicherten Daten gebunden, um DynamoDB-Wiederherstellungsvorgänge zu vereinfachen. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Sie müssen immer denselben logischen Tabellennamen angeben. Damit die Entschlüsselung erfolgreich ist, muss der Name der logischen Tabelle mit dem Namen übereinstimmen, der bei der Verschlüsselung angegeben wurde. Falls sich Ihr DynamoDB-Tabellenname nach dem [Wiederherstellen Ihrer DynamoDB-Tabelle aus einer Sicherung](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) ändert, stellt der logische Tabellenname sicher, dass der Entschlüsselungsvorgang die Tabelle weiterhin erkennt.
**Zulässige Attribute ohne Vorzeichen**
Die `DO_NOTHING` in Ihren Attributaktionen markierten Attribute.
Die zulässigen Attribute ohne Vorzeichen teilen dem Client mit, welche Attribute von den Signaturen ausgeschlossen sind. Der Client geht davon aus, dass alle anderen Attribute in der Signatur enthalten sind. Beim Entschlüsseln eines Datensatzes bestimmt der Client dann anhand der von Ihnen angegebenen zulässigen Attribute ohne Vorzeichen, welche er überprüfen muss und welche ignoriert werden sollen. Sie können kein Attribut aus Ihren zulässigen Attributen ohne Vorzeichen entfernen.
Sie können die zulässigen Attribute ohne Vorzeichen explizit definieren, indem Sie ein Array erstellen, das alle Ihre `DO_NOTHING` Attribute auflistet. Sie können bei der Benennung Ihrer `DO_NOTHING` Attribute auch ein eindeutiges Präfix angeben und das Präfix verwenden, um dem Client mitzuteilen, welche Attribute vorzeichenlos sind. Wir empfehlen dringend, ein eindeutiges Präfix anzugeben, da dies das Hinzufügen eines neuen `DO_NOTHING` Attributs in der future vereinfacht. Weitere Informationen finden Sie unter [Aktualisierung Ihres Datenmodells](ddb-update-data-model.md).
Wenn Sie kein Präfix für alle `DO_NOTHING` Attribute angeben, können Sie ein `allowedUnsignedAttributes` Array konfigurieren, das explizit alle Attribute auflistet, von denen der Client erwarten sollte, dass sie nicht signiert sind, wenn er sie bei der Entschlüsselung findet. Sie sollten Ihre erlaubten vorzeichenlosen Attribute nur dann explizit definieren, wenn dies unbedingt erforderlich ist.
**Suchkonfiguration (optional)**
Das `SearchConfig` definiert die [Beacon-Version](using-beacons.md#beacon-version).
Der `SearchConfig` muss angegeben werden, um [durchsuchbare Verschlüsselung](searchable-encryption.md) oder [signierte](configure.md#signed-beacons) Beacons verwenden zu können.
**Algorithm Suite (optional)**
Die `algorithmSuiteId` definiert, welche Algorithmus-Suite das AWS Database Encryption SDK verwendet.
Sofern Sie nicht explizit eine alternative Algorithmussuite angeben, verwendet das AWS Database Encryption SDK die [Standard-Algorithmussuite](supported-algorithms.md#recommended-algorithms). [Die Standard-Algorithmussuite verwendet den AES-GCM-Algorithmus mit Schlüsselableitung, [digitalen Signaturen](concepts.md#digital-sigs) und Schlüsselzusage.](concepts.md#key-commitment) Obwohl die Standard-Algorithmus-Suite wahrscheinlich für die meisten Anwendungen geeignet ist, können Sie auch eine alternative Algorithmussuite wählen. Einige Vertrauensmodelle würden beispielsweise durch eine Algorithmus-Suite ohne digitale Signaturen erfüllt. Hinweise zu den Algorithmus-Suites, die das AWS Database Encryption SDK unterstützt, finden Sie unter[Unterstützte Algorithmus-Suiten im AWS Database Encryption SDK](supported-algorithms.md).
Um die [AES-GCM-Algorithmussuite ohne digitale ECDSA-Signaturen](supported-algorithms.md#other-algorithms) auszuwählen, nehmen Sie den folgenden Ausschnitt in Ihre Tabellenverschlüsselungskonfiguration auf.
```
AlgorithmSuiteId = DBEAlgorithmSuiteId.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY_SYMSIG_HMAC_SHA384
```
## Elemente mit dem Database Encryption SDK aktualisieren AWS
Das AWS Database Encryption SDK unterstützt [ddb:](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) nicht UpdateItem für Elemente, die verschlüsselte oder signierte Attribute enthalten. Um ein verschlüsseltes oder signiertes Attribut zu aktualisieren, müssen Sie [ddb](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html): verwenden. PutItem Wenn Sie in Ihrer `PutItem` Anfrage denselben Primärschlüssel wie ein vorhandenes Element angeben, ersetzt das neue Element das vorhandene Element vollständig. Sie können [CLOBBER](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/dynamodbv2/datamodeling/DynamoDBMapperConfig.SaveBehavior.html#CLOBBER) auch verwenden, um alle Attribute beim Speichern zu löschen und zu ersetzen, nachdem Sie Ihre Artikel aktualisiert haben.
# .NET-Beispiele
Die folgenden Beispiele zeigen, wie Sie die clientseitige .NET-Verschlüsselungsbibliothek für DynamoDB verwenden, um die Tabellenelemente in Ihrer Anwendung zu schützen. Weitere Beispiele (und eigene Beispiele) finden Sie in den [.NET-Beispielen](https://github.com/aws/aws-database-encryption-sdk-dynamodb//tree/main/Examples/runtimes/net/src) im -dynamodb-Repository unter. aws-database-encryption-sdk GitHub
Die folgenden Beispiele zeigen, wie die clientseitige .NET-Verschlüsselungsbibliothek für DynamoDB in einer neuen, nicht aufgefüllten Amazon DynamoDB-Tabelle konfiguriert wird. Wenn Sie Ihre vorhandenen Amazon DynamoDB-Tabellen für die clientseitige Verschlüsselung konfigurieren möchten, finden Sie weitere Informationen unter. [Fügen Sie Version 3.x zu einer vorhandenen Tabelle hinzu](ddb-net-config-existing-table.md)
**Topics**
+ [Verwenden des AWS Low-Level-Datenbankverschlüsselungs-SDK für DynamoDB-API](#ddb-net-lowlevel-API-example)
+ [Verwenden Sie die untergeordnete Ebene `DynamoDbItemEncryptor`](#ddb-net-itemencryptor)
## Verwenden des AWS Low-Level-Datenbankverschlüsselungs-SDK für DynamoDB-API
Das folgende Beispiel zeigt, wie Sie das AWS Low-Level-Datenbankverschlüsselungs-SDK für die DynamoDB-API mit einem [AWS KMS Schlüsselbund](use-kms-keyring.md) verwenden, um Elemente automatisch clientseitig mit Ihren DynamoDB-Anfragen zu verschlüsseln und zu signieren. `PutItem`
Sie können jeden unterstützten [Schlüsselbund verwenden, wir empfehlen jedoch, wann immer möglich, einen der Schlüsselringe](keyrings.md) zu verwenden. AWS KMS
**Sehen Sie sich das vollständige Codebeispiel** [an: .cs BasicPutGetExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/BasicPutGetExample.cs)
**Schritt 1: Erstellen Sie den Schlüsselbund AWS KMS **
Das folgende Beispiel verwendet`CreateAwsKmsMrkMultiKeyring`, um einen AWS KMS Schlüsselbund mit einem symmetrischen Verschlüsselungs-KMS-Schlüssel zu erstellen. Die `CreateAwsKmsMrkMultiKeyring` Methode stellt sicher, dass der Schlüsselbund sowohl Schlüssel mit einer Region als auch Schlüssel mit mehreren Regionen korrekt verarbeitet.
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsMrkMultiKeyringInput { Generator = kmsKeyId };
var kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Schritt 2: Konfigurieren Sie Ihre Attributaktionen**
Das folgende Beispiel definiert ein `attributeActionsOnEncrypt` Wörterbuch, das Beispiele für [Attributaktionen](concepts.md#crypt-actions) für ein Tabellenelement darstellt.
Das folgende Beispiel definiert keine Attribute als`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen auch die Partitions- und Sortierattribute angegeben werden`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
var attributeActionsOnEncrypt = new Dictionary
{
["partition_key"] = CryptoAction.SIGN_ONLY, // The partition attribute must be SIGN_ONLY
["sort_key"] = CryptoAction.SIGN_ONLY, // The sort attribute must be SIGN_ONLY
["attribute1"] = CryptoAction.ENCRYPT_AND_SIGN,
["attribute2"] = CryptoAction.SIGN_ONLY,
[":attribute3"] = CryptoAction.DO_NOTHING
};
```
**Schritt 3: Definieren Sie, welche Attribute von den Signaturen ausgeschlossen werden**
Im folgenden Beispiel wird davon ausgegangen, dass alle `DO_NOTHING` Attribute das eindeutige Präfix "`:`" haben, und verwendet dieses Präfix, um die zulässigen Attribute ohne Vorzeichen zu definieren. Der Client geht davon aus, dass alle Attributnamen mit dem Präfix "`:`" von den Signaturen ausgeschlossen sind. Weitere Informationen finden Sie unter [Allowed unsigned attributes](ddb-net-using.md#net-allowed-unauth).
```
const String unsignAttrPrefix = ":";
```
**Schritt 4: Definieren Sie die Konfiguration der DynamoDB-Tabellenverschlüsselung**
Das folgende Beispiel definiert eine `tableConfigs` Map, die die Verschlüsselungskonfiguration für diese DynamoDB-Tabelle darstellt.
In diesem Beispiel wird der DynamoDB-Tabellenname als [logischer Tabellenname](ddb-net-using.md#net-logical-table-name) angegeben. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Weitere Informationen finden Sie unter [Verschlüsselungskonfiguration im AWS Database Encryption SDK für DynamoDB](ddb-net-using.md#ddb-net-config-encrypt).
Um [durchsuchbare Verschlüsselung](searchable-encryption.md) oder [signierte Beacons](configure.md#signed-beacons) zu verwenden, müssen Sie die auch [`SearchConfig`](ddb-java-using.md#ddb-search-config)in Ihre Verschlüsselungskonfiguration aufnehmen.
```
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);
```
**Schritt 5: Einen neuen AWS SDK-DynamoDB-Client erstellen**
Im folgenden Beispiel wird ein neuer AWS SDK-DynamoDB-Client mit dem `TableEncryptionConfigs` aus **Schritt** 4 erstellt.
```
var ddb = new Client.DynamoDbClient(
new DynamoDbTablesEncryptionConfig { TableEncryptionConfigs = tableConfigs });
```
**Schritt 6: Verschlüsseln und Signieren eines DynamoDB-Tabellenelements**
Das folgende Beispiel definiert ein `item` Dictionary, das ein Beispieltabellenelement darstellt und das Element in die DynamoDB-Tabelle einfügt. Das Element wird clientseitig verschlüsselt und signiert, bevor es an DynamoDB gesendet wird.
```
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);
```
## Verwenden Sie die untergeordnete Ebene `DynamoDbItemEncryptor`
Das folgende Beispiel zeigt, wie Sie die untergeordnete Ebene `DynamoDbItemEncryptor` mit einem [AWS KMS Schlüsselbund](use-kms-keyring.md) verwenden, um Tabellenelemente direkt zu verschlüsseln und zu signieren. Das `DynamoDbItemEncryptor` fügt das Element nicht in Ihre DynamoDB-Tabelle ein.
Sie können jeden unterstützten [Schlüsselbund](keyrings.md) mit dem DynamoDB Enhanced Client verwenden, wir empfehlen jedoch, wann immer möglich, einen der AWS KMS Schlüsselringe zu verwenden.
**Anmerkung**
[Die untergeordnete Ebene unterstützt keine durchsuchbare Verschlüsselung. `DynamoDbItemEncryptor`](searchable-encryption.md) Verwenden Sie das AWS Low-Level-Datenbankverschlüsselungs-SDK für DynamoDB-API, um durchsuchbare Verschlüsselung zu verwenden.
**Sehen Sie sich das vollständige Codebeispiel an**[: .cs ItemEncryptDecryptExample](https://github.com/aws/aws-database-encryption-sdk-dynamodb/tree/main/Examples/runtimes/net/src/itemencryptor/ItemEncryptDecryptExample.cs)
**Schritt 1: Erstellen Sie den Schlüsselbund AWS KMS **
Das folgende Beispiel verwendet`CreateAwsKmsMrkMultiKeyring`, um einen AWS KMS Schlüsselbund mit einem symmetrischen Verschlüsselungs-KMS-Schlüssel zu erstellen. Die `CreateAwsKmsMrkMultiKeyring` Methode stellt sicher, dass der Schlüsselbund sowohl Schlüssel mit einer Region als auch Schlüssel mit mehreren Regionen korrekt verarbeitet.
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsMrkMultiKeyringInput { Generator = kmsKeyId };
var kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**Schritt 2: Konfigurieren Sie Ihre Attributaktionen**
Das folgende Beispiel definiert ein `attributeActionsOnEncrypt` Wörterbuch, das Beispiele für [Attributaktionen](concepts.md#crypt-actions) für ein Tabellenelement darstellt.
Das folgende Beispiel definiert keine Attribute als`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen auch die Partitions- und Sortierattribute angegeben werden`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
var attributeActionsOnEncrypt = new Dictionary
{
["partition_key"] = CryptoAction.SIGN_ONLY, // The partition attribute must be SIGN_ONLY
["sort_key"] = CryptoAction.SIGN_ONLY, // The sort attribute must be SIGN_ONLY
["attribute1"] = CryptoAction.ENCRYPT_AND_SIGN,
["attribute2"] = CryptoAction.SIGN_ONLY,
[":attribute3"] = CryptoAction.DO_NOTHING
};
```
**Schritt 3: Definieren Sie, welche Attribute von den Signaturen ausgeschlossen werden**
Im folgenden Beispiel wird davon ausgegangen, dass alle `DO_NOTHING` Attribute das eindeutige Präfix "`:`" haben, und verwendet dieses Präfix, um die zulässigen Attribute ohne Vorzeichen zu definieren. Der Client geht davon aus, dass alle Attributnamen mit dem Präfix "`:`" von den Signaturen ausgeschlossen sind. Weitere Informationen finden Sie unter [Allowed unsigned attributes](ddb-net-using.md#net-allowed-unauth).
```
String unsignAttrPrefix = ":";
```
**Schritt 4: Definieren Sie die `DynamoDbItemEncryptor` Konfiguration**
Das folgende Beispiel definiert die Konfiguration für die`DynamoDbItemEncryptor`.
In diesem Beispiel wird der DynamoDB-Tabellenname als [logischer Tabellenname](ddb-net-using.md#net-logical-table-name) angegeben. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Weitere Informationen finden Sie unter [Verschlüsselungskonfiguration im AWS Database Encryption SDK für 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
};
```
**Schritt 5: Erstellen Sie das `DynamoDbItemEncryptor`**
Im folgenden Beispiel wird `DynamoDbItemEncryptor` mit dem `config` aus **Schritt 4** ein neues erstellt.
```
var itemEncryptor = new DynamoDbItemEncryptor(config);
```
**Schritt 6: Verschlüsseln und signieren Sie ein Tabellenelement direkt**
Im folgenden Beispiel wird ein Element direkt verschlüsselt und signiert mit dem. `DynamoDbItemEncryptor` Das `DynamoDbItemEncryptor` fügt das Element nicht in Ihre DynamoDB-Tabelle ein.
```
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;
```
# Konfigurieren Sie eine bestehende DynamoDB-Tabelle für die Verwendung des AWS Database Encryption SDK für DynamoDB
Mit Version 3. *x* der clientseitigen .NET-Verschlüsselungsbibliothek für DynamoDB können Sie Ihre vorhandenen Amazon DynamoDB-Tabellen für die clientseitige Verschlüsselung konfigurieren. Dieses Thema enthält Anleitungen zu den drei Schritten, die Sie ausführen müssen, um Version 3 hinzuzufügen. *x* zu einer vorhandenen, gefüllten DynamoDB-Tabelle.
## Schritt 1: Bereiten Sie das Lesen und Schreiben verschlüsselter Elemente vor
Gehen Sie wie folgt vor, um Ihren AWS Database Encryption SDK-Client auf das Lesen und Schreiben verschlüsselter Elemente vorzubereiten. Nachdem Sie die folgenden Änderungen vorgenommen haben, liest und schreibt Ihr Client weiterhin Klartext-Elemente. Neue Elemente, die in die Tabelle geschrieben werden, werden nicht verschlüsselt oder signiert, aber es kann verschlüsselte Elemente entschlüsseln, sobald sie erscheinen. Diese Änderungen bereiten den Client darauf vor, mit der [Verschlüsselung](#ddb-net-add-step2) neuer Elemente zu beginnen. Die folgenden Änderungen müssen auf jedem Lesegerät installiert werden, bevor Sie mit dem nächsten Schritt fortfahren.
**1. Definieren Sie Ihre [Attributaktionen](concepts.md#crypt-actions)**
Erstellen Sie ein Objektmodell, um zu definieren, welche Attributwerte verschlüsselt und signiert werden, welche nur signiert und welche ignoriert werden.
Standardmäßig sind Primärschlüsselattribute signiert, aber nicht verschlüsselt (`SIGN_ONLY`), und alle anderen Attribute sind verschlüsselt und signiert (`ENCRYPT_AND_SIGN`).
Geben Sie `ENCRYPT_AND_SIGN` an, dass ein Attribut verschlüsselt und signiert werden soll. Geben Sie `SIGN_ONLY` an, dass ein Attribut signiert, aber nicht verschlüsselt werden soll. Geben Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` an, dass das Attribut signiert und in den Verschlüsselungskontext aufgenommen werden soll. Sie können ein Attribut nicht verschlüsseln, ohne es auch zu signieren. Geben Sie `DO_NOTHING` an, ob ein Attribut ignoriert werden soll. Weitere Informationen finden Sie unter [Attributaktionen im AWS Database Encryption SDK für DynamoDB](ddb-net-using.md#ddb-net-attribute-actions).
Wenn Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` Attribute angeben, müssen auch die Partitions- und Sortierattribute angegeben werden`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
```
var attributeActionsOnEncrypt = new Dictionary
{
["partition_key"] = CryptoAction.SIGN_ONLY, // The partition attribute must be SIGN_ONLY
["sort_key"] = CryptoAction.SIGN_ONLY, // The sort attribute must be SIGN_ONLY
["attribute1"] = CryptoAction.ENCRYPT_AND_SIGN,
["attribute2"] = CryptoAction.SIGN_ONLY,
[":attribute3"] = CryptoAction.DO_NOTHING
};
```
**2. Definieren Sie, welche Attribute von den Signaturen ausgeschlossen werden**
Im folgenden Beispiel wird davon ausgegangen, dass alle `DO_NOTHING` Attribute das eindeutige Präfix "`:`" haben, und verwendet dieses Präfix, um die zulässigen Attribute ohne Vorzeichen zu definieren. Der Client geht davon aus, dass alle Attributnamen mit dem Präfix "`:`" von den Signaturen ausgeschlossen sind. Weitere Informationen finden Sie unter [Allowed unsigned attributes](ddb-net-using.md#net-allowed-unauth).
```
const String unsignAttrPrefix = ":";
```
**3. Erstellen Sie einen [Schlüsselbund](keyrings.md)**
Im folgenden Beispiel wird ein [AWS KMS Schlüsselbund](use-kms-keyring.md) erstellt. Der AWS KMS Schlüsselbund verwendet symmetrische Verschlüsselung oder asymmetrisches RSA, um Datenschlüssel AWS KMS keys zu generieren, zu verschlüsseln und zu entschlüsseln.
In diesem Beispiel wird ein AWS KMS Schlüsselbund `CreateMrkMultiKeyring` mit einem KMS-Schlüssel mit symmetrischer Verschlüsselung erstellt. Die `CreateAwsKmsMrkMultiKeyring` Methode stellt sicher, dass der Schlüsselbund sowohl Schlüssel mit einer Region als auch Schlüssel mit mehreren Regionen korrekt verarbeitet.
```
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsMrkMultiKeyringInput { Generator = kmsKeyId };
var kmsKeyring = matProv.CreateAwsKmsMrkMultiKeyring(keyringInput);
```
**4. Definieren Sie die Konfiguration der DynamoDB-Tabellenverschlüsselung **
Das folgende Beispiel definiert eine `tableConfigs` Map, die die Verschlüsselungskonfiguration für diese DynamoDB-Tabelle darstellt.
In diesem Beispiel wird der DynamoDB-Tabellenname als [logischer Tabellenname](ddb-net-using.md#net-logical-table-name) angegeben. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren.
Sie müssen `FORCE_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` als Klartext-Override angeben. Diese Richtlinie liest und schreibt weiterhin Klartext-Elemente, liest verschlüsselte Elemente und bereitet den Client darauf vor, verschlüsselte Elemente zu schreiben.
Weitere Hinweise zu den Werten, die in der Konfiguration der Tabellenverschlüsselung enthalten sind, finden Sie unter[Verschlüsselungskonfiguration im AWS Database Encryption SDK für 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. Einen neuen AWS SDK-DynamoDB-Client erstellen**
Im folgenden Beispiel wird ein neuer AWS SDK-DynamoDB-Client mit dem `TableEncryptionConfigs` aus **Schritt** 4 erstellt.
```
var ddb = new Client.DynamoDbClient(
new DynamoDbTablesEncryptionConfig { TableEncryptionConfigs = tableConfigs });
```
## Schritt 2: Schreiben Sie verschlüsselte und signierte Elemente
Aktualisieren Sie die Klartext-Richtlinie in Ihrer Tabellenverschlüsselungskonfiguration, damit der Client verschlüsselte und signierte Elemente schreiben kann. Nachdem Sie die folgende Änderung implementiert haben, verschlüsselt und signiert der Client neue Elemente auf der Grundlage der Attributaktionen, die Sie in **Schritt** 1 konfiguriert haben. Der Client kann Klartext-Elemente sowie verschlüsselte und signierte Elemente lesen.
Bevor Sie mit [Schritt 3](#ddb-net-add-step3) fortfahren, müssen Sie alle vorhandenen Klartextelemente in Ihrer Tabelle verschlüsseln und signieren. Es gibt keine einzelne Metrik oder Abfrage, die Sie ausführen können, um Ihre vorhandenen Klartextelemente schnell zu verschlüsseln. Verwenden Sie den Prozess, der für Ihr System am sinnvollsten ist. Sie könnten beispielsweise einen asynchronen Prozess verwenden, der die Tabelle langsam scannt und dann die Elemente mithilfe der von Ihnen definierten Attributaktionen und der Verschlüsselungskonfiguration neu schreibt. Um die Klartext-Elemente in Ihrer Tabelle zu identifizieren, empfehlen wir, nach allen Elementen zu suchen, die nicht die `aws_dbe_foot` Attribute `aws_dbe_head` und enthalten, die das AWS Database Encryption SDK Elementen hinzufügt, wenn sie verschlüsselt und signiert sind.
Im folgenden Beispiel wird die Konfiguration der Tabellenverschlüsselung aus **Schritt 1** aktualisiert. Sie müssen die Klartext-Override mit `FORBID_WRITE_PLAINTEXT_ALLOW_READ_PLAINTEXT` aktualisieren. Diese Richtlinie liest weiterhin Klartext-Elemente, liest und schreibt aber auch verschlüsselte Elemente. Erstellen Sie einen neuen AWS SDK-DynamoDB-Client mit dem aktualisierten. `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);
```
## Schritt 3: Nur verschlüsselte und signierte Elemente lesen
Nachdem Sie alle Ihre Elemente verschlüsselt und signiert haben, aktualisieren Sie die Klartext-Überschreibung in Ihrer Tabellenverschlüsselungskonfiguration, sodass der Client nur verschlüsselte und signierte Elemente lesen und schreiben kann. Nachdem Sie die folgende Änderung implementiert haben, verschlüsselt und signiert der Client neue Elemente auf der Grundlage der Attributaktionen, die Sie in **Schritt** 1 konfiguriert haben. Der Client kann nur verschlüsselte und signierte Elemente lesen.
Im folgenden Beispiel wird die Konfiguration der Tabellenverschlüsselung aus **Schritt 2** aktualisiert. Sie können entweder die Klartext-Override mit der Klartext-Richtlinie aktualisieren `FORBID_WRITE_PLAINTEXT_FORBID_READ_PLAINTEXT` oder die Klartext-Richtlinie aus Ihrer Konfiguration entfernen. Der Client liest und schreibt standardmäßig nur verschlüsselte und signierte Elemente. Erstellen Sie einen neuen AWS SDK-DynamoDB-Client mit dem aktualisierten. `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
In diesem Thema wird erklärt, wie Version 1 installiert und verwendet wird. *x* der clientseitigen Rust-Verschlüsselungsbibliothek für DynamoDB. Einzelheiten zur Programmierung mit dem AWS Database Encryption SDK für DynamoDB finden Sie in den [Rust-Beispielen](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/) im aws-database-encryption-sdk -dynamodb-Repository unter. GitHub
Alle Programmiersprachenimplementierungen des AWS Database Encryption SDK für DynamoDB sind interoperabel.
**Topics**
+ [Voraussetzungen](#ddb-rust-prerequisites)
+ [Installation](#ddb-rust-install)
+ [Verwenden des Rust-Clients](ddb-rust-using.md)
## Voraussetzungen
Bevor Sie die clientseitige Rust-Verschlüsselungsbibliothek für DynamoDB installieren, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen.
**Installieren Sie Rust und Cargo**
Installieren Sie die aktuelle stabile Version von [Rust](https://www.rust-lang.org/) mit [Rustup](https://rustup.rs/).
Weitere Informationen zum Herunterladen und Installieren von Rustup finden Sie in den [Installationsverfahren in The Cargo Book](https://doc.rust-lang.org/cargo/getting-started/installation.html).
## Installation
Die clientseitige Rust-Verschlüsselungsbibliothek für DynamoDB ist als Crate auf Crates.io verfügbar. [aws-db-esdk](https://crates.io/crates/aws-db-esdk) [Einzelheiten zur Installation und Erstellung der Bibliothek finden Sie in der Datei README.md im Repository -dynamodb.](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) aws-database-encryption-sdk GitHub
**manuell**
[Um die clientseitige Rust-Verschlüsselungsbibliothek für DynamoDB zu installieren, klonen Sie das -dynamodb-Repository oder laden Sie es herunter. aws-database-encryption-sdk](https://github.com/aws/aws-database-encryption-sdk-dynamodb/) GitHub
**Installieren der neuesten Version**
Führen Sie den folgenden Cargo-Befehl in Ihrem Projektverzeichnis aus:
```
cargo add aws-db-esdk
```
Oder fügen Sie Ihrer Cargo.toml die folgende Zeile hinzu:
```
aws-db-esdk = ""
```
# Verwendung der clientseitigen Rust-Verschlüsselungsbibliothek für DynamoDB
In diesem Thema werden einige der Funktionen und Hilfsklassen in Version 1 erklärt. *x* der clientseitigen Rust-Verschlüsselungsbibliothek für DynamoDB.
Einzelheiten zur Programmierung mit der clientseitigen Rust-Verschlüsselungsbibliothek für DynamoDB finden Sie in den [Rust-Beispielen](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/) im -dynamodb-Repository unter. aws-database-encryption-sdk GitHub
**Topics**
+ [Elementverschlüssler](#ddb-rust-item-encryptors)
+ [Attributaktionen](#ddb-rust-attribute-actions)
+ [Verschlüsselungskonfiguration](#ddb-rust-config-encrypt)
+ [Artikel werden aktualisiert](#ddb-rust-update-items)
## Elementverschlüssler
Im Kern ist das AWS Database Encryption SDK für DynamoDB ein Elementverschlüsseler. Sie können Version 1 verwenden. *x* der clientseitigen Rust-Verschlüsselungsbibliothek für DynamoDB, um Ihre DynamoDB-Tabellenelemente auf folgende Weise zu verschlüsseln, zu signieren, zu verifizieren und zu entschlüsseln.
**Das AWS Low-Level-Datenbankverschlüsselungs-SDK für die DynamoDB-API**
Sie können Ihre [Tabellenverschlüsselungskonfiguration](#ddb-rust-config-encrypt) verwenden, um einen DynamoDB-Client zu erstellen, der Elemente automatisch clientseitig mit Ihren DynamoDB-Anfragen verschlüsselt und signiert. `PutItem`
[Sie müssen das AWS Low-Level-Datenbankverschlüsselungs-SDK für DynamoDB-API verwenden, um durchsuchbare Verschlüsselung verwenden zu können.](searchable-encryption.md)
Ein Beispiel, das zeigt, wie das AWS Low-Level-Datenbankverschlüsselungs-SDK für die DynamoDB-API verwendet wird, finden Sie unter [basic\$1get\$1put\$1example.rs](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/basic_get_put_example.rs) im -dynamodb-Repository unter. aws-database-encryption-sdk GitHub
**Die untergeordnete Ebene `DynamoDbItemEncryptor`**
Die untergeordnete Ebene verschlüsselt und signiert oder entschlüsselt und verifiziert Ihre Tabellenelemente `DynamoDbItemEncryptor` direkt, ohne DynamoDB aufzurufen. Es stellt keine DynamoDB `PutItem` oder `GetItem` Anfragen. Sie können beispielsweise die untergeordnete Ebene verwenden, `DynamoDbItemEncryptor` um ein DynamoDB-Element, das Sie bereits abgerufen haben, direkt zu entschlüsseln und zu verifizieren.
[Die untergeordnete Ebene unterstützt keine durchsuchbare Verschlüsselung`DynamoDbItemEncryptor`.](searchable-encryption.md)
Ein Beispiel, das zeigt, wie die untergeordnete Ebene verwendet wird, finden Sie unter [item\$1encrypt\$1decrypt.rs im `DynamoDbItemEncryptor` -dynamodb-Repository](https://github.com/aws/aws-database-encryption-sdk-dynamodb/blob/main/releases/rust/db_esdk/examples/itemencryptor/item_encrypt_decrypt.rs) unter. aws-database-encryption-sdk GitHub
## Attributaktionen im AWS Database Encryption SDK für DynamoDB
[Attributaktionen](concepts.md#crypt-actions) bestimmen, welche Attributwerte verschlüsselt und signiert werden, welche nur signiert sind, welche signiert und in den Verschlüsselungskontext aufgenommen werden und welche ignoriert werden.
Um Attributaktionen mit dem Rust-Client zu spezifizieren, definieren Sie Attributaktionen manuell mithilfe eines Objektmodells. Spezifizieren Sie Ihre Attributaktionen, indem Sie ein `HashMap` Objekt erstellen, in dem die Name-Wert-Paare für Attributnamen und die angegebenen Aktionen stehen.
Geben Sie `ENCRYPT_AND_SIGN` an, dass ein Attribut verschlüsselt und signiert werden soll. Geben Sie `SIGN_ONLY` an, dass ein Attribut signiert, aber nicht verschlüsselt werden soll. Geben Sie `SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT` an, dass ein Attribut signiert und in den Verschlüsselungskontext aufgenommen werden soll. Sie können ein Attribut nicht verschlüsseln, ohne es auch zu signieren. Geben Sie `DO_NOTHING` an, ob ein Attribut ignoriert werden soll.
Die Partitions- und Sortierattribute müssen entweder `SIGN_ONLY` oder lauten`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`. Wenn Sie Attribute als definieren`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, müssen dies auch die Partitions- und Sortierattribute sein`SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`.
**Anmerkung**
Nachdem Sie Ihre Attributaktionen definiert haben, müssen Sie definieren, welche Attribute von den Signaturen ausgeschlossen werden. Um das future Hinzufügen neuer Attribute ohne Vorzeichen zu vereinfachen, empfehlen wir, ein eindeutiges Präfix (wie "`:`„) zu wählen, um Ihre vorzeichenlosen Attribute zu identifizieren. Nehmen Sie dieses Präfix in den Attributnamen für alle Attribute auf, die Sie bei der Definition Ihres DynamoDB-Schemas und Ihrer Attributaktionen markiert `DO_NOTHING` haben.
Das folgende Objektmodell zeigt, wie Sie`ENCRYPT_AND_SIGN`, `SIGN_ONLY``SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT`, und `DO_NOTHING` Attributaktionen mit dem Rust-Client angeben. In diesem Beispiel wird das Präfix "`:`" verwendet, um `DO_NOTHING` Attribute zu identifizieren.
```
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),
]);
```
## Verschlüsselungskonfiguration im AWS Database Encryption SDK für DynamoDB
Wenn Sie das AWS Database Encryption SDK verwenden, müssen Sie explizit eine Verschlüsselungskonfiguration für Ihre DynamoDB-Tabelle definieren. Die in Ihrer Verschlüsselungskonfiguration erforderlichen Werte hängen davon ab, ob Sie Ihre Attributaktionen manuell oder mit einer annotierten Datenklasse definiert haben.
Der folgende Ausschnitt definiert eine DynamoDB-Tabellenverschlüsselungskonfiguration unter Verwendung des AWS Low-Level-Datenbankverschlüsselungs-SDK für DynamoDB-API und zulässige unsignierte Attribute, die durch ein eindeutiges Präfix definiert sind.
```
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()?;
```
**Logischer Tabellenname**
Ein logischer Tabellenname für Ihre DynamoDB-Tabelle.
Der logische Tabellenname ist kryptografisch an alle in der Tabelle gespeicherten Daten gebunden, um DynamoDB-Wiederherstellungsvorgänge zu vereinfachen. Es wird dringend empfohlen, Ihren DynamoDB-Tabellennamen als logischen Tabellennamen anzugeben, wenn Sie Ihre Verschlüsselungskonfiguration zum ersten Mal definieren. Sie müssen immer denselben logischen Tabellennamen angeben. Damit die Entschlüsselung erfolgreich ist, muss der Name der logischen Tabelle mit dem Namen übereinstimmen, der bei der Verschlüsselung angegeben wurde. Falls sich Ihr DynamoDB-Tabellenname nach dem [Wiederherstellen Ihrer DynamoDB-Tabelle aus einer Sicherung](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Restore.Tutorial.html) ändert, stellt der logische Tabellenname sicher, dass der Entschlüsselungsvorgang die Tabelle weiterhin erkennt.
**Zulässige Attribute ohne Vorzeichen**
Die `DO_NOTHING` in Ihren Attributaktionen markierten Attribute.
Die zulässigen Attribute ohne Vorzeichen teilen dem Client mit, welche Attribute von den Signaturen ausgeschlossen sind. Der Client geht davon aus, dass alle anderen Attribute in der Signatur enthalten sind. Beim Entschlüsseln eines Datensatzes bestimmt der Client dann aus den von Ihnen angegebenen zulässigen unsignierten Attributen, welche er überprüfen muss und welche ignoriert werden sollen. Sie können kein Attribut aus Ihren zulässigen Attributen ohne Vorzeichen entfernen.
Sie können die zulässigen Attribute ohne Vorzeichen explizit definieren, indem Sie ein Array erstellen, das alle Ihre `DO_NOTHING` Attribute auflistet. Sie können bei der Benennung Ihrer `DO_NOTHING` Attribute auch ein eindeutiges Präfix angeben und das Präfix verwenden, um dem Client mitzuteilen, welche Attribute vorzeichenlos sind. Wir empfehlen dringend, ein eindeutiges Präfix anzugeben, da dies das Hinzufügen eines neuen `DO_NOTHING` Attributs in der future vereinfacht. Weitere Informationen finden Sie unter [Aktualisierung Ihres Datenmodells](ddb-update-data-model.md).
Wenn Sie kein Präfix für alle `DO_NOTHING` Attribute angeben, können Sie ein `allowedUnsignedAttributes` Array konfigurieren, das explizit alle Attribute auflistet, von denen der Client erwarten sollte, dass sie nicht signiert sind, wenn er sie bei der Entschlüsselung findet. Sie sollten Ihre erlaubten vorzeichenlosen Attribute nur dann explizit definieren, wenn dies unbedingt erforderlich ist.
**Suchkonfiguration (optional)**
Das `SearchConfig` definiert die [Beacon-Version](using-beacons.md#beacon-version).
Der `SearchConfig` muss angegeben werden, um [durchsuchbare Verschlüsselung](searchable-encryption.md) oder [signierte](configure.md#signed-beacons) Beacons verwenden zu können.
**Algorithm Suite (optional)**
Die `algorithmSuiteId` definiert, welche Algorithmus-Suite das AWS Database Encryption SDK verwendet.
Sofern Sie nicht explizit eine alternative Algorithmussuite angeben, verwendet das AWS Database Encryption SDK die [Standard-Algorithmussuite](supported-algorithms.md#recommended-algorithms). [Die Standard-Algorithmussuite verwendet den AES-GCM-Algorithmus mit Schlüsselableitung, [digitalen Signaturen](concepts.md#digital-sigs) und Schlüsselzusage.](concepts.md#key-commitment) Obwohl die Standard-Algorithmus-Suite wahrscheinlich für die meisten Anwendungen geeignet ist, können Sie auch eine alternative Algorithmussuite wählen. Einige Vertrauensmodelle würden beispielsweise durch eine Algorithmus-Suite ohne digitale Signaturen erfüllt. Hinweise zu den Algorithmus-Suites, die das AWS Database Encryption SDK unterstützt, finden Sie unter[Unterstützte Algorithmus-Suiten im AWS Database Encryption SDK](supported-algorithms.md).
Um die [AES-GCM-Algorithmussuite ohne digitale ECDSA-Signaturen](supported-algorithms.md#other-algorithms) auszuwählen, nehmen Sie den folgenden Ausschnitt in Ihre Tabellenverschlüsselungskonfiguration auf.
```
.algorithm_suite_id(
DbeAlgorithmSuiteId::AlgAes256GcmHkdfSha512CommitKeyEcdsaP384SymsigHmacSha384,
)
```
## Elemente mit dem Database Encryption SDK aktualisieren AWS
Das AWS Database Encryption SDK unterstützt [ddb:](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html) nicht UpdateItem für Elemente, die verschlüsselte oder signierte Attribute enthalten. Um ein verschlüsseltes oder signiertes Attribut zu aktualisieren, müssen Sie [ddb](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html): verwenden. PutItem Wenn Sie in Ihrer `PutItem` Anfrage denselben Primärschlüssel wie ein vorhandenes Element angeben, ersetzt das neue Element das vorhandene Element vollständig.
# Legacy-DynamoDB-Verschlüsselungsclient
Am 9. Juni 2023 wurde unsere clientseitige Verschlüsselungsbibliothek in Database Encryption SDK umbenannt. AWS Das AWS Database Encryption SDK unterstützt weiterhin ältere Versionen des DynamoDB Encryption Client. Weitere Informationen zu den verschiedenen Teilen der clientseitigen Verschlüsselungsbibliothek, die sich mit der Umbenennung geändert haben, finden Sie unter. [Amazon DynamoDB Encryption Client umbenennen](DDBEC-rename.md)
Informationen zur Migration zur neuesten Version der clientseitigen Java-Verschlüsselungsbibliothek für DynamoDB finden Sie unter. [Migrieren Sie auf Version 3.x](ddb-java-migrate.md)
**Topics**
+ [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](#legacy-support)
+ [So funktioniert der DynamoDB Encryption Client](DDBEC-legacy-how-it-works.md)
+ [Konzepte des Amazon DynamoDB DynamoDB-Verschlüsselungsclients](DDBEC-legacy-concepts.md)
+ [Anbieter von kryptografischem Material](crypto-materials-providers.md)
+ [Verfügbare Programmiersprachen für Amazon DynamoDB Encryption Client](programming-languages.md)
+ [Ändern Ihres Datenmodells](data-model.md)
+ [Behebung von Problemen in Ihrer DynamoDB Encryption Client-Anwendung](troubleshooting.md)
## AWS Database Encryption SDK für DynamoDB-Versionsunterstützung
Die Themen im Kapitel Legacy enthalten Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python.
In der folgenden Tabelle sind die Sprachen und Versionen aufgeführt, die die clientseitige Verschlüsselung in Amazon DynamoDB unterstützen.
| Programmiersprache | Version | Lebenszyklusphase der SDK-Hauptversion |
| --- | --- | --- |
| Java | Versionen 1. *x* | [End-of-Support Phase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle), gültig ab Juli 2022 |
| Java | Versionen 2. *x* | [Allgemeine Verfügbarkeit](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle) (GA) |
| Java | Ausführung 3. *x* | [Allgemeine Verfügbarkeit](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle) (GA) |
| Python | Versionen 1. *x* | [End-of-Support Phase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle), gültig ab Juli 2022 |
| Python | Versionen 2. *x* | [End-of-Support Phase](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle), gültig ab Juli 2022 |
| Python | Versionen 3. *x* | [Allgemeine Verfügbarkeit](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle) (GA) |
# So funktioniert der DynamoDB Encryption Client
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
Der DynamoDB Encryption Client wurde speziell für den Schutz der Daten entwickelt, die Sie in DynamoDB speichern. Die Bibliotheken enthalten sichere Implementierungen, die Sie erweitern oder unverändert verwenden können. Und die meisten Elemente werden durch abstrakte Elemente dargestellt, sodass Sie kompatible benutzerdefinierte Komponenten erstellen und verwenden können.
**Verschlüsselung und Signieren von Tabellenelementen**
Das Herzstück des DynamoDB Encryption Client ist ein *Elementverschlüsseler, der Tabellenelemente* verschlüsselt, signiert, verifiziert und entschlüsselt. Er nimmt Informationen über Ihre Tabellenelemente entgegen, sowie Anweisungen, welche Elemente zu verschlüsseln und zu signieren sind. Er ruft von einem [Anbieter für kryptographisches Material](DDBEC-legacy-concepts.md#concept-material-provider), den Sie auswählen und konfigurieren, die Verschlüsselungsmaterialien ab, ebenso wie Anweisungen, wie man sie verwendet.
Das folgende Diagramm zeigt einen allgemeinen Überblick über dieses Verfahren.
![\[Elemente im DynamoDB Encryption Client verschlüsseln und signieren\]](http://docs.aws.amazon.com/de_de/database-encryption-sdk/latest/devguide/images/arch-encrypt.png)
Um ein Tabellenelement zu verschlüsseln und zu signieren, benötigt der DynamoDB Encryption Client:
+ **Informationen über die Tabelle.** Es ruft Informationen über die Tabelle aus einem [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context) ab, den Sie angeben. Einige Helfer rufen die erforderlichen Informationen von DynamoDB ab und erstellen den DynamoDB-Verschlüsselungskontext für Sie.
**Anmerkung**
Der *DynamoDB-Verschlüsselungskontext* im DynamoDB Encryption Client hat nichts mit dem *Verschlüsselungskontext* in AWS Key Management Service ()AWS KMS und dem zu tun. AWS Encryption SDK
+ **Welche Attribute zu verschlüsseln und zu signieren sind.** Er erhält diese Informationen über die Tabelle von den [Attribut-Aktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions), die Sie bereitstellen.
+ **Verschlüsselungsmaterialien, einschließlich Verschlüsselungs- und Signaturschlüssel.** Er erhält diese von einem [Anbieter kryptographischer Materialien](DDBEC-legacy-concepts.md#concept-material-provider) (Cryptographic Materials Provider, CMP), den Sie auswählen und konfigurieren.
+ **Anweisungen für die Verschlüsselung und das Signieren des Elementes**. Der CMP fügt der [tatsächlichen Materialbeschreibung](DDBEC-legacy-concepts.md#legacy-material-description) Anweisungen zur Verwendung der Verschlüsselungsmaterialien hinzu, einschließlich Verschlüsselungs- und Signaturalgorithmen.
Der [Elementverschlüssler](DDBEC-legacy-concepts.md#item-encryptor) verwendet alle diese Dinge, um das Element zu verschlüsseln und zu signieren. Der Elementverschlüssler fügt dem Element außerdem zwei Attribute hinzu: ein [Materialbeschreibungsattribut](DDBEC-legacy-concepts.md#legacy-material-description), das die Verschlüsselungs- und Signaturanweisungen (die tatsächliche Materialbeschreibung) enthält, und ein Attribut, das die Signatur enthält. Sie können direkt mit dem Elementverschlüsseler interagieren oder Helferfunktionen verwenden, die mit dem Elementverschlüssler interagieren, um ein sicheres Standardverhalten zu implementieren.
Das Ergebnis ist ein DynamoDB-Element mit verschlüsselten und signierten Daten.
**Verifizieren und Entschlüsseln von Tabellenelementen**
Diese Komponenten arbeiten auch zusammen, um Ihr Element zu verifizieren und zu entschlüsseln, wie in der folgenden Abbildung gezeigt.
![\[Überprüfen und Entschlüsseln von Elementen im DynamoDB Encryption Client\]](http://docs.aws.amazon.com/de_de/database-encryption-sdk/latest/devguide/images/arch-decrypt.png)
Um ein Element zu verifizieren und zu entschlüsseln, benötigt der DynamoDB Encryption Client dieselben Komponenten, Komponenten mit derselben Konfiguration oder Komponenten, die speziell für die Entschlüsselung der Elemente entwickelt wurden, und zwar wie folgt:
+ **Informationen über die Tabelle** aus dem [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context).
+ **Welche Attribute zu überprüfen und zu entschlüsseln sind.** Diese erhält er von den [Attribut-Aktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions).
+ **Entschlüsselungsmaterialien, einschließlich Verifikations- und Entschlüsselungsschlüssel**, von dem [Anbieter kryptographischer Materialien (Cryptographic Materials Provider, CMP)](DDBEC-legacy-concepts.md#concept-material-provider), den Sie auswählen und konfigurieren.
Das verschlüsselte Element enthält keine Aufzeichnung des CMP, mit dem es verschlüsselt wurde. Sie müssen den gleichen CMP, einen CMP mit der gleichen Konfiguration oder einen CMP, der zum Entschlüsseln von Elementen vorgesehen ist, bereitstellen.
+ **Informationen darüber, wie das Element verschlüsselt und signiert wurde**, einschließlich der Verschlüsselungs- und Signierungsalgorithmen. Der Client erhält sie vom [Materialbeschreibungsattribut](DDBEC-legacy-concepts.md#legacy-material-description) im Element.
Der [Elementverschlüssler](DDBEC-legacy-concepts.md#item-encryptor) verwendet alle diese Dinge, um das Element zu verifizieren und zu entschlüsseln. Außerdem entfernt er die Materialbezeichnung und die Signaturattribute. Das Ergebnis ist ein DynamoDB-Element im Klartext-Format.
# Konzepte des Amazon DynamoDB DynamoDB-Verschlüsselungsclients
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
In diesem Thema werden die Konzepte und die Terminologie erklärt, die im Amazon DynamoDB Encryption Client verwendet werden.
Informationen zum Zusammenspiel der Komponenten des DynamoDB Encryption Client finden Sie unter. [So funktioniert der DynamoDB Encryption Client](DDBEC-legacy-how-it-works.md)
**Topics**
+ [Anbieter von kryptographischen Materialien (Cryptographic Materials Provider (CMP))](#concept-material-provider)
+ [Elementverschlüssler](#item-encryptor)
+ [Attributaktionen](#legacy-attribute-actions)
+ [Materialbeschreibung](#legacy-material-description)
+ [DynamoDB-Verschlüsselungsclient](#legacy-encryption-context)
+ [Provider-Store](#provider-store)
## Anbieter von kryptographischen Materialien (Cryptographic Materials Provider (CMP))
Bei der Implementierung des DynamoDB Encryption Client besteht eine Ihrer ersten Aufgaben darin, [einen Anbieter für kryptografisches Material (CMP) (auch bekannt als Anbieter von *Verschlüsselungsmaterialien*) auszuwählen](crypto-materials-providers.md). Ihre Wahl bestimmt einen Großteil der restlichen Implementierung.
Ein *Anbieter von kryptographischem Material (Cryptographic Materials Provider, CMP)* erfasst und erstellt die kryptographischen Materialien und gibt sie zurück, die der [Elementverschlüssler](#item-encryptor) verwendet, um Ihre Tabellenelemente zu verschlüsseln und zu signieren. Der CMP bestimmt die zu verwendenden Verschlüsselungsalgorithmen, und wie Verschlüsselungs- und Signierschlüssel erzeugt und geschützt werden.
Der CMP interagiert mit dem Elementverschlüssler. Der Elementverschlüssler fordert vom CMP Ver- oder Entschlüsselungsmaterialien an, und der CMP gibt sie an den Elementverschlüsseler zurück. Dann verwendet der Elementverschlüssler die kryptographischen Materialien, um das Element zu verschlüsseln und zu signieren oder zu überprüfen und zu entschlüsseln.
Den CMP geben Sie bei der Konfiguration des Clients an. Sie können ein kompatibles benutzerdefiniertes CMP erstellen oder eines der vielen in der Bibliothek enthaltenen verwenden. CMPs Die meisten CMPs sind für mehrere Programmiersprachen verfügbar.
## Elementverschlüssler
Der *Elementverschlüsseler* ist eine untergeordnete Komponente, die kryptografische Operationen für den DynamoDB Encryption Client ausführt. Er fordert kryptographisches Material von einem [Anbieter von kryptographischem Material (Cryptographic Materials Provider, CMP)](#concept-material-provider) an und verwendet dann die vom CMP zurückgegebenen Materialien, um Ihr Tabellenelement zu verschlüsseln und zu signieren oder zu verifizieren und zu entschlüsseln.
Sie können direkt mit dem Elementverschlüsseler interagieren oder die Helferklassen verwenden, die Ihre Bibliothek zur Verfügung stellt. Der DynamoDB Encryption Client für Java enthält beispielsweise eine `AttributeEncryptor` Hilfsklasse, die Sie mit dem verwenden können`DynamoDBMapper`, anstatt direkt mit dem `DynamoDBEncryptor` Elementverschlüsseler zu interagieren. Die Python-Bibliothek enthält die Helferklassen `EncryptedTable`, `EncryptedClient` und `EncryptedResource`, die für Sie mit dem Elementverschlüssler interagieren.
## Attributaktionen
*Attribut-Aktionen* teilen dem Elementverschlüsseler mit, welche Aktionen er auf jedes Attribut des Elements anwenden soll.
Das Attribut-Aktionswerte können einer der folgenden sein:
+ **Verschlüsseln und signieren** — Verschlüsselt den Attributwert. Nehmen Sie das Attribut (Name und Wert) in die Elementsignatur auf.
+ **Nur signieren** — Schließt das Attribut in die Artikelsignatur ein.
+ **Nichts tun** — Verschlüsseln oder signieren Sie das Attribut nicht.
Verwenden Sie für jedes Attribut, das vertrauliche Daten speichern kann, **Verschlüsseln und signieren**. Für Primärschlüsselattribute (Partitionsschlüssel und Sortierschlüssel) verwenden Sie **Nur signieren**. Das [Materialverschlüsselungsattribut](#legacy-material-description) und das Signaturattribut werden wird nicht verschlüsselt oder signiert. Sie müssen für diese Attribute keine Attribut-Aktionen angeben.
Wählen Sie Ihre Attributaktionen sorgfältig aus. Verwenden Sie im Zweifelsfall **Verschlüsseln und signieren**. Sobald Sie den DynamoDB Encryption Client zum Schutz Ihrer Tabellenelemente verwendet haben, können Sie die Aktion für ein Attribut nicht mehr ändern, ohne einen Signaturvalidierungsfehler zu riskieren. Details hierzu finden Sie unter [Ändern Ihres Datenmodells](data-model.md).
**Warnung**
Verschlüsseln Sie die primären Schlüsselattribute nicht. Sie müssen im Klartext bleiben, damit DynamoDB das Element finden kann, ohne einen vollständigen Tabellenscan ausführen zu müssen.
Wenn der [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context) Ihre Primärschlüsselattribute identifiziert, gibt der Client einen Fehler aus, wenn Sie versuchen, sie zu verschlüsseln.
Die Technik, mit der Sie die Attribut-Aktionen festlegen, ist für jede Programmiersprache unterschiedlich. Sie kann auch spezifisch für Helferklassen sein, die Sie verwenden.
Weitere Informationen finden Sie in der Dokumentation Ihrer Programmiersprache.
+ [Python](python-using.md#python-attribute-actions)
+ [Java](java-using.md#attribute-actions-java)
## Materialbeschreibung
Die *Materialbeschreibung* für ein verschlüsseltes Tabellenelement besteht aus Informationen, wie z. B. Verschlüsselungsalgorithmen, wie das Tabellenelement verschlüsselt und signiert wird. Ein [Anbieter von kryptographischem Material (Cryptographic Materials Provider, CMP)](#concept-material-provider) zeichnet die Materialbeschreibung auf, wenn er die kryptographischen Materialien für die Verschlüsselung und die Signatur zusammenstellt. Später, wenn er kryptographische Materialien zusammenstellen muss, um das Element zu verifizieren und zu entschlüsseln, verwendet er die Materialbeschreibung als seinen Leitfaden.
Im DynamoDB Encryption Client bezieht sich die Materialbeschreibung auf drei verwandte Elemente:
**Angeforderte Materialbeschreibung**
Bei einigen [Anbietern von kryptografischem Material](#concept-material-provider) (CMPs) können Sie erweiterte Optionen angeben, z. B. einen Verschlüsselungsalgorithmus. Um Ihre Auswahlmöglichkeiten anzugeben, fügen Sie der Materialbeschreibungseigenschaft des [DynamoDB-Verschlüsselungskontextes in Ihrer Anforderung zur Verschlüsselung](concepts.md#encryption-context) eines Tabellenelements Name-Wert-Paare hinzu. Dieses Element wird als die *angeforderte Materialbeschreibung* bezeichnet. Die gültigen Werte in der angeforderten Materialbeschreibung werden durch den von Ihnen gewählten CMP definiert.
Da die Materialbeschreibung sichere Standardwerte überschreiben kann, empfehlen wir Ihnen, die angeforderte Materialbeschreibung wegzulassen, es sei denn, Sie haben einen zwingenden Grund, sie zu verwenden.
**Tatsächliche Materialbeschreibung**
*Die Materialbeschreibung, die von den [Anbietern kryptografischer Materialien](#concept-material-provider) (CMPs) zurückgegeben wird, wird als eigentliche Materialbeschreibung bezeichnet.* Sie beschreibt die tatsächlichen Werte, die der CMP bei der Zusammenstellung der kryptographischen Materialien verwendet hat. Sie besteht in der Regel aus der angeforderten Materialbeschreibung, falls vorhanden, mit Ergänzungen und Änderungen.
**Materialbeschreibungsattribut**
Der Client speichert die tatsächliche Materialbeschreibung in dem *Materialbeschreibungsattribut* des verschlüsselten Elements. Der Name des Materialbeschreibungsattributs ist `amzn-ddb-map-desc`, der Wert ist die tatsächliche Materialbeschreibung. Der Client verwendet die Werte im Materialbeschreibungsattribut, um das Element zu überprüfen und zu entschlüsseln.
## DynamoDB-Verschlüsselungsclient
Der *DynamoDB-Verschlüsselungskontext* liefert Informationen über die Tabelle und das Element an den [Cryptographic Materials Provider](#concept-material-provider) (CMP). In fortgeschrittenen Implementierungen kann der DynamoDB-Verschlüsselungskontext eine [angeforderte](#legacy-material-description) Materialbeschreibung enthalten.
Wenn Sie Tabellenelemente verschlüsseln, ist der DynamoDB-Verschlüsselungskontext kryptografisch an die verschlüsselten Attributwerte gebunden. Wenn beim Entschlüsseln der DynamoDB-Verschlüsselungskontext nicht exakt und unter Berücksichtigung der Groß- und Kleinschreibung mit dem DynamoDB-Verschlüsselungskontext übereinstimmt, der für die Verschlüsselung verwendet wurde, schlägt der Entschlüsselungsvorgang fehl. Wenn Sie direkt mit dem [Elementverschlüsseler](#item-encryptor) interagieren, müssen Sie beim Aufrufen einer Verschlüsselungs- oder Entschlüsselungsmethode einen DynamoDB-Verschlüsselungskontext angeben. Die meisten Helfer erstellen den DynamoDB-Verschlüsselungskontext für Sie.
**Anmerkung**
Der *DynamoDB-Verschlüsselungskontext* im DynamoDB Encryption Client hat nichts mit dem *Verschlüsselungskontext* in AWS Key Management Service ()AWS KMS und dem zu tun. AWS Encryption SDK
Der DynamoDB-Verschlüsselungskontext kann die folgenden Felder enthalten. Alle Felder und Werte sind optional.
+ Name der Tabelle
+ Partitionsschlüsselname
+ Sortierschlüsselname
+ Attribut-Namen-Wert-Paare
+ [Angeforderte Materialbeschreibung](#legacy-material-description)
## Provider-Store
Ein *Provider-Store* ist eine Komponente, die [Anbieter von kryptografischem Material](#concept-material-provider) (CMPs) zurückgibt. Der Anbieterspeicher kann sie aus einer anderen Quelle erstellen CMPs oder aus einer anderen Quelle abrufen, z. B. aus einem anderen Anbieterspeicher. Der Provider-Speicher speichert Versionen von CMPs , die er erstellt, im persistenten Speicher, in dem jede gespeicherte CMP durch den Materialnamen des Anforderers und die Versionsnummer identifiziert wird.
Der [neueste Anbieter](most-recent-provider.md) im DynamoDB Encryption Client bezieht seine Daten CMPs aus einem Provider-Store, aber Sie können den Provider-Speicher für die Bereitstellung CMPs an jede Komponente verwenden. Jeder aktuelle Anbieter ist einem Provider-Store zugeordnet, aber ein Provider-Store kann viele Anforderer CMPs auf mehreren Hosts beliefern.
Der Provider-Store erstellt neue Versionen von CMPs On Demand und gibt neue und bestehende Versionen zurück. Außerdem gibt er die neueste Versionsnummer für einen bestimmten Materialnamen zurück. Daran erkennt der Anforderer, dass der Provider-Store eine neue Version seines CMP hat, die er anfordern kann.
Der DynamoDB Encryption Client umfasst einen [ MetaStore](most-recent-provider.md#about-metastore), bei dem es sich um einen Provider-Speicher handelt, der Wrapped CMPs mit Schlüsseln erstellt, die in DynamoDB gespeichert und mit einem internen DynamoDB Encryption Client verschlüsselt werden.
**Weitere Informationen:**
+ Provider-Store: [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)
# Anbieter von kryptografischem Material
**Anmerkung**
[Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS](DDBEC-rename.md) Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
Eine der wichtigsten Entscheidungen, die Sie bei der Verwendung des DynamoDB Encryption Client treffen, ist die Auswahl eines [Anbieters für kryptografisches Material](DDBEC-legacy-concepts.md#concept-material-provider) (CMP). Das CMP stellt kryptographisches Material zusammen und gibt es an den Elementverschlüssler zurück. Außerdem legt er fest, wie Verschlüsselungs- und Signierschlüssel generiert werden, ob für jedes Element neue Schlüsselmaterialien generiert oder wiederverwendet werden und welche Verschlüsselungs- und Signierungsalgorithmen verwendet werden.
Sie können eine CMP aus den Implementierungen auswählen, die in den DynamoDB Encryption Client-Bibliotheken bereitgestellt werden, oder eine kompatible benutzerdefinierte CMP erstellen. Welchen CMP Sie auswählen, hängt möglicherweise auch von der verwendeten [Programmiersprache](programming-languages.md) ab.
Dieses Thema beschreibt die gängigsten CMPs und bietet einige Ratschläge, die Ihnen bei der Auswahl der für Ihre Anwendung am besten geeigneten Lösung helfen sollen.
**Direct KMS Materials Provider**
Der Direct KMS Materials Provider schützt Ihre Tabellenelemente unter einem [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)That Never Leaves [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS) unverschlüsselt. Ihre Anwendung muss kein kryptographisches Material erzeugen oder verwalten. Da er die verwendet AWS KMS key , um eindeutige Verschlüsselungs- und Signaturschlüssel für jedes Element zu generieren, ruft dieser Anbieter AWS KMS jedes Mal auf, wenn er ein Element ver- oder entschlüsselt.
Wenn Sie verwenden AWS KMS und ein AWS KMS Aufruf pro Transaktion für Ihre Anwendung praktikabel ist, ist dieser Anbieter eine gute Wahl.
Details hierzu finden Sie unter [Direct KMS Materials Provider](direct-kms-provider.md).
**Wrapped Materials Provider (Wrapped CMP)**
Mit dem Wrapped Materials Provider (Wrapped CMP) können Sie Ihre Verpackungs- und Signaturschlüssel außerhalb des DynamoDB Encryption Client generieren und verwalten.
Der Wrapped CMP generiert einen eindeutigen Verschlüsselungsschlüssel für jedes Element. Dann verwendet er die von Ihnen bereitgestellten Wrapping- (oder Unwrapping-) und Signierschlüssel. Damit bestimmen Sie, wie die Wrapping- und Signierschlüssel erzeugt werden und ob sie für jedes Element eindeutig sind oder wiederverwendet werden. Der Wrapped CMP ist eine sichere Alternative zum [Direct KMS Provider](direct-kms-provider.md) für Anwendungen, die kein kryptografisches Material verwenden AWS KMS und dieses sicher verwalten können.
Details hierzu finden Sie unter [Wrapped Materials Provider](wrapped-provider.md).
**Most Recent Provider**
Der *Most Recent Provider* ist ein [Anbieter kryptographischer Materialien (Cryptographic Materials Provider (CMP))](DDBEC-legacy-concepts.md#concept-material-provider), der auf die Arbeit mit einem [Provider-Store](DDBEC-legacy-concepts.md#provider-store) ausgelegt ist. Es bezieht sich CMPs aus dem Provider-Store und ruft die kryptografischen Materialien ab, die es von dem zurückgibt. CMPs Der Most Recent Provider verwendet in der Regel jeden CMP, um mehrere Anfragen nach kryptographischem Material zu erfüllen, aber Sie können die Funktionen des Provider-Stores verwenden, um zu steuern, wie oft Materialien wiederverwendet werden, um zu bestimmen, wie oft ein CMP rotiert wird, und sogar, um den Typ des CMP zu ändern, der verwendet wird, ohne den Most Recent Provider zu ändern.
Sie können den Most Recent Provider mit jedem kompatiblen Provider-Store verwenden. Der DynamoDB Encryption Client enthält einen MetaStore, bei dem es sich um einen Provider-Store handelt, der Wrapped zurückgibt. CMPs
Der Most Recent Provider ist eine gute Wahl für Anwendungen, die Aufrufe ihrer kryptographischen Quelle minimieren müssen, sowie für Anwendungen, die bestimmte kryptographische Materialien wiederverwenden können, ohne ihre Sicherheitsanforderungen zu verletzen. So können Sie beispielsweise Ihre kryptografischen Materialien mit einem [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) schützen, ohne AWS KMS jedes Mal, wenn Sie ein Element ver- oder entschlüsseln, erneut aufrufen zu müssen.
Details hierzu finden Sie unter [Most Recent Provider](most-recent-provider.md).
**Static Materials Provider**
Der Static Materials Provider wurde für Tests, proof-of-concept Demonstrationen und Kompatibilität mit älteren Versionen konzipiert. Er generiert keine eindeutigen kryptographischen Materialien für jedes Element. Er gibt dieselben von Ihnen gelieferten Verschlüsselungs- und Signierschlüssel zurück, die direkt zum Verschlüsseln und Signieren Ihrer Tabellenelemente verwendet werden.
Der [Asymmetric Static Provider](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/providers/AsymmetricStaticProvider.html) in der Java-Bibliothek ist kein statischer Anbieter. Er liefert nur alternative Konstruktoren für den [Wrapped CMP](wrapped-provider.md). Er ist sicher für die Produktion, aber Sie sollten den Wrapped CMP nach Möglichkeit direkt verwenden.
**Topics**
+ [Direct KMS Materials Provider](direct-kms-provider.md)
+ [Wrapped Materials Provider](wrapped-provider.md)
+ [Most Recent Provider](most-recent-provider.md)
+ [Static Materials Provider](static-provider.md)
# Direct KMS Materials Provider
**Anmerkung**
[Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS](DDBEC-rename.md) Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
Der *Direct KMS Materials Provider* (Direct KMS Provider) schützt Ihre Tabellenelemente unter einem [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)That Never Leaves [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/)(AWS KMS) unverschlüsselt. Dieser [Anbieter kryptographischer Materialien (Cryptographic Materials Provider)](DDBEC-legacy-concepts.md#concept-material-provider) gibt einen eindeutigen Verschlüsselungsschlüssel und einen Signierschlüssel für jedes Tabellenelement zurück. Zu diesem Zweck ruft er AWS KMS jedes Mal auf, wenn Sie ein Element ver- oder entschlüsseln.
Wenn Sie DynamoDB-Elemente mit hoher Frequenz und in großem Umfang verarbeiten, überschreiten Sie möglicherweise die AWS KMS [requests-per-secondGrenzwerte, was zu Verarbeitungsverzögerungen](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html#requests-per-second) führen kann. [Wenn Sie ein Limit überschreiten müssen, erstellen Sie einen Fall im AWS Support Center.](https://console.aws.amazon.com/support/home) Sie könnten auch erwägen, einen Anbieter für kryptografisches Material mit begrenzter Schlüsselwiederverwendung zu verwenden, z. B. [den neuesten Anbieter](most-recent-provider.md).
Um den Direct KMS Provider verwenden zu können, benötigt der Anrufer mindestens [einen AWS-Konto](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) und die Berechtigung AWS KMS key, die Operationen [GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)und [Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) auf dem aufzurufen. AWS KMS key Das AWS KMS key muss ein symmetrischer Verschlüsselungsschlüssel sein. Der DynamoDB Encryption Client unterstützt keine asymmetrische Verschlüsselung. Wenn Sie eine [globale DynamoDB-Tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) verwenden, möchten Sie möglicherweise einen Schlüssel für [AWS KMS mehrere](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) Regionen angeben. Details hierzu finden Sie unter [Verwendung](#provider-kms-how-to-use).
**Anmerkung**
Wenn Sie den Direct KMS-Anbieter verwenden, werden die Namen und Werte Ihrer Primärschlüsselattribute im [AWS KMS Verschlüsselungskontext und in den AWS CloudTrail Protokollen verwandter Operationen im Klartext](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) angezeigt. AWS KMS Der DynamoDB Encryption Client macht jedoch niemals den Klartext verschlüsselter Attributwerte verfügbar.
Der Direct KMS Provider ist einer von mehreren [Anbietern von kryptografischem Material](DDBEC-legacy-concepts.md#concept-material-provider) (CMPs), die der DynamoDB Encryption Client unterstützt. Hinweise zum anderen CMPs finden Sie unter. [Anbieter von kryptografischem Material](crypto-materials-providers.md)
**Beispielcode finden Sie unter:**
+ 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](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/aws_kms_encrypted_table.py), [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)
**Topics**
+ [Verwendung](#provider-kms-how-to-use)
+ [Funktionsweise](#provider-kms-how-it-works)
## Verwendung
Um einen Direct KMS-Anbieter zu erstellen, verwenden Sie den Schlüssel-ID-Parameter, um einen [KMS-Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) mit symmetrischer Verschlüsselung in Ihrem Konto anzugeben. Der Wert des Schlüssel-ID-Parameters kann die Schlüssel-ID, der Schlüssel-ARN, der Aliasname oder der Alias-ARN von sein AWS KMS key. Einzelheiten zu den Schlüsselkennungen finden Sie unter [Schlüsselkennungen](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) im *AWS Key Management Service Entwicklerhandbuch*.
Der Direct KMS Provider benötigt einen KMS-Schlüssel mit symmetrischer Verschlüsselung. Sie können keinen asymmetrischen KMS-Schlüssel verwenden. Sie können jedoch einen KMS-Schlüssel für mehrere Regionen, einen KMS-Schlüssel mit importiertem Schlüsselmaterial oder einen KMS-Schlüssel in einem benutzerdefinierten Schlüsselspeicher verwenden. Sie benötigen die Berechtigungen [kms: GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) und [kms:Decrypt](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html) für den KMS-Schlüssel. Daher müssen Sie einen vom Kunden verwalteten Schlüssel verwenden, keinen verwalteten oder AWS eigenen AWS KMS-Schlüssel.
Der DynamoDB Encryption Client für Python bestimmt die Region für den Aufruf AWS KMS aus der Region im Schlüssel-ID-Parameterwert, falls dieser einen enthält. Andernfalls verwendet er die Region im AWS KMS Client, falls Sie eine angeben, oder die Region, die Sie in der konfigurieren. AWS SDK für Python (Boto3) Informationen zur Regionsauswahl in Python finden Sie unter [Konfiguration](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/configuration.html) in der AWS API-Referenz zum SDK for Python (Boto3).
Der DynamoDB Encryption Client für Java bestimmt die Region für Anrufe AWS KMS von der Region im AWS KMS Client, wenn der von Ihnen angegebene Client eine Region enthält. Andernfalls verwendet er die Region, die Sie in der konfigurieren. AWS SDK für Java Informationen zur Regionsauswahl finden Sie unter [AWS-Region Auswahl](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/java-dg-region-selection.html) im AWS SDK für Java Developer Guide. AWS SDK für Java
------
#### [ 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 ]
Im folgenden Beispiel wird der Schlüssel ARN verwendet, um den zu spezifizieren AWS KMS key. Wenn Ihre Schlüssel-ID keine enthält AWS-Region, ruft der DynamoDB Encryption Client die Region aus der konfigurierten Botocore-Sitzung, falls vorhanden, oder aus den Boto-Standardwerten ab.
```
# 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)
```
------
Wenn Sie [globale Amazon DynamoDB-Tabellen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) verwenden, empfehlen wir Ihnen, Ihre Daten mit einem AWS KMS Schlüssel für mehrere Regionen zu verschlüsseln. Schlüssel mit mehreren Regionen sind AWS KMS keys unterschiedlich und können synonym verwendet werden AWS-Regionen , da sie dieselbe Schlüssel-ID und dasselbe Schlüsselmaterial haben. *Einzelheiten finden Sie unter [Verwenden von Schlüsseln für mehrere Regionen](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) im Entwicklerhandbuch.AWS Key Management Service *
**Anmerkung**
Wenn Sie die [Version 2017.11.29](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html) für globale Tabellen verwenden, müssen Sie Attributaktionen so einrichten, dass die reservierten Replikationsfelder nicht verschlüsselt oder signiert werden. Details hierzu finden Sie unter [Probleme mit globalen Tabellen älterer Versionen](troubleshooting.md#fix-global-tables).
Um einen Schlüssel für mehrere Regionen mit dem DynamoDB Encryption Client zu verwenden, erstellen Sie einen Schlüssel für mehrere Regionen und replizieren Sie ihn in die Regionen, in denen Ihre Anwendung ausgeführt wird. Konfigurieren Sie dann den Direct KMS Provider so, dass er den Schlüssel für mehrere Regionen in der Region verwendet, in der der DynamoDB Encryption Client anruft. AWS KMS
Im folgenden Beispiel wird der DynamoDB Encryption Client so konfiguriert, dass er Daten in der Region USA Ost (Nord-Virginia) (us-east-1) verschlüsselt und in der Region USA West (Oregon) (us-west-2) mit einem Schlüssel für mehrere Regionen entschlüsselt.
------
#### [ Java ]
In diesem Beispiel ruft der DynamoDB Encryption Client die Region für Anrufe AWS KMS von der Region im AWS KMS Client ab. Der `keyArn` Wert identifiziert einen Schlüssel mit mehreren Regionen in derselben Region.
```
// 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 diesem Beispiel ruft der DynamoDB Encryption Client die Region für Anrufe AWS KMS aus der Region im Schlüssel-ARN ab.
```
# 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)
```
------
## Funktionsweise
Der Direct KMS Provider gibt Verschlüsselungs- und Signaturschlüssel zurück, die durch einen AWS KMS key von Ihnen angegebenen Wert geschützt sind, wie in der folgenden Abbildung dargestellt.
![\[Die Eingabe, Verarbeitung und Ausgabe des Direct KMS Providers im DynamoDB Encryption Client\]](http://docs.aws.amazon.com/de_de/database-encryption-sdk/latest/devguide/images/directKMS.png)
+ Um Verschlüsselungsmaterial zu generieren, fordert der Direct KMS Provider AWS KMS auf, mithilfe [eines von Ihnen angegebenen Datenschlüssels für jedes Element einen eindeutigen Datenschlüssel AWS KMS key zu generieren](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html). Er leitet Verschlüsselungs- und Signierschlüssel für das Element aus der Klartextkopie des [Datenschlüssels](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#data-keys) ab und gibt dann die Verschlüsselungs- und Signierschlüssel zusammen mit dem verschlüsselten Datenschlüssel zurück, der im [Materialbeschreibungsattribut](DDBEC-legacy-concepts.md#legacy-material-description) des Elements gespeichert wird.
Der Elementverschlüssler verwendet die Verschlüsselungs- und Signierschlüssel und entfernt sie so schnell wie möglich aus dem Speicher. Nur die verschlüsselte Kopie des Datenschlüssels, von dem sie abgeleitet wurden, wird im verschlüsselten Element gespeichert.
+ Um Entschlüsselungsmaterialien zu generieren, bittet der Direct KMS-Anbieter darum AWS KMS , den verschlüsselten Datenschlüssel zu entschlüsseln. Dann leitet es aus dem Klartextdatenschlüssel Verifizierungs- und Signierschlüssel ab und gibt sie an den Elementverschlüssler zurück.
Der Elementverschlüssler verifiziert das Element und entschlüsselt bei erfolgreicher Verifikation die verschlüsselten Werte. Anschließend entfernt er die Schlüssel so schnell wie möglich aus dem Speicher.
### Verschlüsselungsmaterialien abrufen
Dieser Abschnitt beschreibt detailliert die Ein- und Ausgänge und die Verarbeitung des Direct KMS Providers, wenn er eine Anfrage für Verschlüsselungsmaterialien vom [Elementverschlüssler](DDBEC-legacy-concepts.md#item-encryptor) erhält.
**Eingabe** (von der Anwendung)
+ Die Schlüssel-ID eines. AWS KMS key
**Eingabe** (vom Elementverschlüssler)
+ [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context)
**Ausgabe** (an den Elementverschlüssler)
+ Verschlüsselungsschlüssel (Klartext)
+ Signierschlüssel
+ In der [tatsächlichen Materialbeschreibung](DDBEC-legacy-concepts.md#legacy-material-description): Diese Werte werden im Materialbeschreibungsattribut gespeichert, das der Client dem Element hinzufügt.
+ amzn-ddb-env-key: Base64-codierter Datenschlüssel, verschlüsselt durch AWS KMS key
+ amzn-ddb-env-alg[: Verschlüsselungsalgorithmus, standardmäßig AES/256](https://csrc.nist.gov/projects/cryptographic-standards-and-guidelines/archived-crypto-projects/aes-development)
+ amzn-ddb-sig-alg[: Signierungsalgorithmus, standardmäßig Hmac /256 SHA256](https://en.wikipedia.org/wiki/HMAC)
+ amzn-ddb-wrap-alg: km
**Verarbeitung**
1. Der Direct KMS-Anbieter sendet AWS KMS eine Anfrage, um mithilfe der angegebenen Daten [einen eindeutigen Datenschlüssel für das Element AWS KMS key zu generieren](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html). Die Operation gibt einen Klartextschlüssel und eine Kopie zurück, die unter dem AWS KMS key verschlüsselt ist. Dies wird als *anfängliches Schlüsselmaterial* bezeichnet.
Die Anforderung enthält die folgenden Werte im Klartext im [AWS KMS -Verschlüsselungskontext](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context). Diese nicht geheimen Werte sind kryptographisch an das verschlüsselte Objekt gebunden, sodass beim Entschlüsseln der gleiche Verschlüsselungskontext benötigt wird. Sie können diese Werte verwenden, um den Anruf AWS KMS in [AWS CloudTrail Protokollen](https://docs.aws.amazon.com/kms/latest/developerguide/monitoring-overview.html) zu identifizieren.
+ amzn-ddb-env-alg — Verschlüsselungsalgorithmus, standardmäßig AES/256
+ amzn-ddb-sig-alg — Signaturalgorithmus, standardmäßig Hmac /256 SHA256
+ (Fakultativ) — aws-kms-table *table name*
+ (Optional) *partition key name* — *partition key value* (Binärwerte sind Base64-kodiert)
+ (Optional) *sort key name* — *sort key value* (Binärwerte sind Base64-kodiert)
Der Direct KMS-Anbieter ruft die Werte für den AWS KMS Verschlüsselungskontext aus dem [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context) für das Element ab. Wenn der DynamoDB-Verschlüsselungskontext keinen Wert enthält, z. B. den Tabellennamen, wird dieses Name-Wert-Paar aus dem Verschlüsselungskontext weggelassen. AWS KMS
1. Der Direct KMS Provider leitet aus dem Datenschlüssel einen symmetrischen Verschlüsselungsschlüssel und einen Signierschlüssel ab. Standardmäßig verwendet es den [Secure Hash Algorithm (SHA) 256](https://en.wikipedia.org/wiki/SHA-2) und die [RFC5869 HMAC-basierte Schlüsselableitungsfunktion, um einen symmetrischen 256-Bit-AES-Verschlüsselungsschlüssel und einen 256-Bit-HMAC-SHA-256-Signaturschlüssel](https://tools.ietf.org/html/rfc5869) abzuleiten.
1. Der Direct KMS Provider gibt die Ausgabe an den Elementverschlüssler zurück.
1. Der Elementverschlüssler verwendet den Verschlüsselungsschlüssel, um die angegebenen Attribute zu verschlüsseln, und den Signierschlüssel, um sie mit den in der tatsächlichen Materialbeschreibung angegebenen Algorithmen zu signieren. Er entfernt die Klartextschlüssel so schnell wie möglich aus dem Speicher.
### Entschlüsselungsmaterialien abrufen
Dieser Abschnitt beschreibt detailliert die Ein- und Ausgänge und die Verarbeitung des Direct KMS Providers, wenn er eine Anfrage für Entschlüsselungsmaterialien vom [Elementverschlüssler](DDBEC-legacy-concepts.md#item-encryptor) erhält.
**Eingabe** (von der Anwendung)
+ Die Schlüssel-ID eines. AWS KMS key
Der Wert der Schlüssel-ID kann die Schlüssel-ID, der Schlüssel-ARN, der Aliasname oder der Alias-ARN von sein AWS KMS key. Alle Werte, die nicht in der Schlüssel-ID enthalten sind, z. B. die Region, müssen im [AWS benannten Profil](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-using-profiles) verfügbar sein. Der Schlüssel ARN liefert alle Werte, die AWS KMS benötigt werden.
**Eingabe** (vom Elementverschlüssler)
+ Eine Kopie des [DynamoDB-Verschlüsselungskontextes](concepts.md#encryption-context), der den Inhalt des Materialbeschreibungsattributs enthält.
**Ausgabe** (an den Elementverschlüssler)
+ Verschlüsselungsschlüssel (Klartext)
+ Signierschlüssel
**Verarbeitung**
1. Der Direct KMS-Anbieter ruft den verschlüsselten Datenschlüssel aus dem Materialbeschreibungsattribut im verschlüsselten Element ab.
1. Er fordert Sie AWS KMS auf, den angegebenen Schlüssel AWS KMS key zum [Entschlüsseln](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html) des verschlüsselten Datenschlüssels zu verwenden. Die Operation gibt einen Klartextschlüssel zurück.
Diese Anforderung muss denselben [AWS KMS -Verschlüsselungskontext](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context) verwenden, in dem der Datenschlüssel generiert und verschlüsselt wurde.
+ aws-kms-table – *table name*
+ *partition key name*— *partition key value* (Binärwerte sind Base64-kodiert)
+ (Optional) *sort key name* — *sort key value* (Binärwerte sind Base64-kodiert)
+ amzn-ddb-env-alg — Verschlüsselungsalgorithmus, standardmäßig AES/256
+ amzn-ddb-sig-alg — Signaturalgorithmus, standardmäßig Hmac /256 SHA256
1. Der Direct KMS Provider verwendet den [Secure Hash Algorithm (SHA) 256](https://en.wikipedia.org/wiki/SHA-2) und die [RFC5869 HMAC-basierte Schlüsselableitungsfunktion, um einen symmetrischen 256-Bit-AES-Verschlüsselungsschlüssel und einen 256-Bit-HMAC-SHA-256-Signaturschlüssel](https://tools.ietf.org/html/rfc5869) aus dem Datenschlüssel abzuleiten.
1. Der Direct KMS Provider gibt die Ausgabe an den Elementverschlüssler zurück.
1. Der Elementverschlüssler verwendet den Signierschlüssel, um das Element zu verifizieren. Wenn er erfolgreich ist, verwendet er den symmetrischen Verschlüsselungsschlüssel, um die verschlüsselten Attributwerte zu entschlüsseln. Diese Operationen verwenden die in der tatsächlichen Materialbeschreibung angegebenen Verschlüsselungs- und Signieralgorithmen. Der Elementverschlüssler entfernt die Klartextschlüssel so schnell wie möglich aus dem Speicher.
# Wrapped Materials Provider
**Anmerkung**
[Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS](DDBEC-rename.md) Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
Mit dem *Wrapped Materials Provider* (Wrapped CMP) können Sie Schlüssel aus beliebigen Quellen mit dem DynamoDB Encryption Client verpacken und signieren. Das Wrapped CMP ist von keinem Dienst abhängig. AWS Sie müssen jedoch Ihre Wrapping- und Signierschlüssel außerhalb des Clients generieren und verwalten, einschließlich der Bereitstellung der richtigen Schlüssel zur Verifizierung und Entschlüsselung des Elements.
Der Wrapped CMP generiert einen eindeutigen Verschlüsselungsschlüssel für jedes Element. Er verpackt den Verschlüsselungsschlüssel des Elements mit dem von Ihnen bereitgestellten Wrapping-Schlüssel und speichert den verpackten Elementverschlüsselungsschlüssel im [Materialbeschreibungsattribut](DDBEC-legacy-concepts.md#legacy-material-description) des Elements. Da Sie die Wrapping- und Signierschlüssel bereitstellen, bestimmen Sie, wie die Wrapping- und Signierschlüssel erzeugt werden und ob sie für jedes Element eindeutig sind oder wiederverwendet werden.
Der Wrapped CMP ist eine sichere Implementierung und eine gute Wahl für Anwendungen, die kryptographische Materialien verwalten können.
Der Wrapped CMP ist einer von mehreren [Anbietern von kryptografischem Material](DDBEC-legacy-concepts.md#concept-material-provider) (CMPs), die der DynamoDB Encryption Client unterstützt. Hinweise zum anderen finden Sie unter. CMPs [Anbieter von kryptografischem Material](crypto-materials-providers.md)
**Beispielcode finden Sie unter:**
+ 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](https://github.com/aws/aws-dynamodb-encryption-python/blob/master/examples/src/dynamodb_encryption_sdk_examples/wrapped_rsa_encrypted_table.py), [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)
**Topics**
+ [Verwendung](#wrapped-cmp-how-to-use)
+ [Funktionsweise](#wrapped-cmp-how-it-works)
## Verwendung
Um einen Wrapped CMP zu erstellen, geben Sie einen Wrapping-Schlüssel (beim Verschlüsseln erforderlich), einen Unwrapping-Schlüssel (beim Entschlüsseln erforderlich) und einen Signierschlüssel an. Sie müssen beim Ver- und Entschlüsseln von Elementen Schlüssel bereitstellen.
Die Wrapping-, Unwrapping- und Signierschlüssel können symmetrische Schlüssel oder asymmetrische Schlüsselpaare sein.
------
#### [ 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
)
```
------
## Funktionsweise
Der Wrapped CMP generiert einen neuen Verschlüsselungsschlüssel für jedes Element. Es verwendet die von Ihnen bereitgestellten Wrapping-, Unwrapping- und Signierschlüssel, wie in der folgenden Abbildung gezeigt.
![\[Die Eingabe, Verarbeitung und Ausgabe des Wrapped Materials Provider im DynamoDB Encryption Client\]](http://docs.aws.amazon.com/de_de/database-encryption-sdk/latest/devguide/images/wrappedCMP.png)
### Verschlüsselungsmaterialien abrufen
Dieser Abschnitt beschreibt detailliert die Ein- und Ausgänge und die Verarbeitung des Wrapped Materials Providers (Wrapped CMP), wenn er eine Anfrage für Verschlüsselungsmaterialien erhält.
**Eingabe** (von der Anwendung)
+ Wrapping-Schlüssel: Ein symmetrischer [Advanced Encryption Standard](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) (AES)-Schlüssel oder ein öffentlicher [RSA](https://en.wikipedia.org/wiki/RSA_(cryptosystem))-Schlüssel. Erforderlich, wenn Attributwerte verschlüsselt sind. Andernfalls ist er optional und wird ignoriert.
+ Unwrapping-Schlüssel: Optional und wird ignoriert.
+ Signierschlüssel
**Eingabe** (vom Elementverschlüssler)
+ [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context)
**Ausgabe** (an den Elementverschlüssler):
+ Klartext-Element-Verschlüsselungsschlüssel
+ Signierschlüssel (unverändert)
+ [Tatsächliche Materialbeschreibung](DDBEC-legacy-concepts.md#legacy-material-description): Diese Werte werden im [Materialbeschreibungsattribut](DDBEC-legacy-concepts.md#legacy-material-description) gespeichert, das der Client dem Element hinzufügt.
+ `amzn-ddb-env-key`: Base64-codierter Wrapped-Element-Verschlüsselungsschlüssel
+ `amzn-ddb-env-alg`: Verschlüsselungsalgorithmus, der zur Verschlüsselung des Elements verwendet wird. Der Standardwert ist AES-256-CBC.
+ `amzn-ddb-wrap-alg`: Der Wrapping-Algorithmus, den der Wrapped CMP verwendet hat, um den Elementverschlüsselungsschlüssel zu verpacken. Wenn es sich bei dem Wrapping-Schlüssel um einen AES-Schlüssel handelt, wird der Schlüssel mit nicht aufgefülltem `AES-Keywrap` verpackt, wie in [RFC 3394](https://tools.ietf.org/html/rfc3394.html) definiert. Wenn der Wrapping-Schlüssel ein RSA-Schlüssel ist, wird der Schlüssel mithilfe von RSA OAEP mit Auffüllung verschlüsselt. MGF1
**Verarbeitung**
Wenn Sie ein Element verschlüsseln, übergeben Sie einen Wrapping-Schlüssel und einen Signierschlüssel. Ein Unwrapping-Schlüssel ist optional und wird ignoriert.
1. Der Wrapped CMP generiert einen symmetrischen Elementverschlüsselungsschlüssel für das Tabellenelement.
1. Er verwendet den Wrapping-Schlüssel, den Sie angeben, um den Elementverschlüsselungsschlüssel zu verpacken. Anschließend entfernt er ihn so schnell wie möglich aus dem Speicher.
1. Es gibt den Klartextelementverschlüsselungsschlüssel zurück, den von Ihnen angegebenen Signierschlüssel und eine [tatsächliche Materialbeschreibung](DDBEC-legacy-concepts.md#legacy-material-description), die den Verschlüsselungsschlüssel des verpackten Elements und die Verschlüsselungs- und Wrapping-Algorithmen enthält.
1. Der Elementverschlüssler verwendet den Klartext-Verschlüsselungsschlüssel, um das Element zu verschlüsseln. Es verwendet den von Ihnen bereitgestellten Signierschlüssel, um das Element zu signieren. Anschließend entfernt er die Klartextschlüssel so schnell wie möglich aus dem Speicher. Es kopiert die Felder in der tatsächlichen Materialbeschreibung, einschließlich des verpackten Verschlüsselungsschlüssels (`amzn-ddb-env-key`), in das Materialbeschreibungsattribut des Elements.
### Entschlüsselungsmaterialien abrufen
Dieser Abschnitt beschreibt detailliert die Ein- und Ausgänge und die Verarbeitung des Wrapped Materials Providers (Wrapped CMP), wenn er eine Anfrage für Entschlüsselungsmaterialien erhält.
**Eingabe** (von der Anwendung)
+ Wrapping-Schlüssel: Optional und wird ignoriert.
+ Unwrapping-Schlüssel: Derselbe symmetrische [Advanced Encryption Standard](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) (AES)-Schlüssel oder private [RSA](https://en.wikipedia.org/wiki/RSA_(cryptosystem))-Schlüssel, der dem zum Verschlüsseln verwendeten öffentlichen RSA-Schlüssel entspricht. Erforderlich, wenn Attributwerte verschlüsselt sind. Andernfalls ist er optional und wird ignoriert.
+ Signierschlüssel
**Eingabe** (vom Elementverschlüssler)
+ Eine Kopie des [DynamoDB-Verschlüsselungskontextes](concepts.md#encryption-context), der den Inhalt des Materialbeschreibungsattributs enthält.
**Ausgabe** (an den Elementverschlüssler)
+ Klartext-Element-Verschlüsselungsschlüssel
+ Signierschlüssel (unverändert)
**Verarbeitung**
Wenn Sie ein Element entschlüsseln, übergeben Sie einen Unwrapping-Schlüssel und einen Signierschlüssel. Ein Wrapping-Schlüssel ist optional und wird ignoriert.
1. Der Wrapped CMP erhält den Verschlüsselungsschlüssel des verpackten Elements aus dem Materialbeschreibungsattribut des Elements.
1. Er verwendet den Unwrapping-Schlüssel und den Algorithmus, um den Verschlüsselungsschlüssel des Elements zu entpacken.
1. Es gibt den Klartextelementverschlüsselungsschlüssel, den Signierschlüssel sowie Verschlüsselungs- und Signieralgorithmen an den Elementverschlüsseler zurück.
1. Der Elementverschlüssler verwendet den Signierschlüssel, um das Element zu verifizieren. Wenn dies erfolgreich ist, verwendet er den Verschlüsselungsschlüssel des Elements, um das Element zu entschlüsseln. Anschließend entfernt er die Klartextschlüssel so schnell wie möglich aus dem Speicher.
# Most Recent Provider
**Anmerkung**
[Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK umbenannt. AWS](DDBEC-rename.md) Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
Der *Most Recent Provider* ist ein [Anbieter kryptographischer Materialien (Cryptographic Materials Provider (CMP))](DDBEC-legacy-concepts.md#concept-material-provider), der auf die Arbeit mit einem [Provider-Store](DDBEC-legacy-concepts.md#provider-store) ausgelegt ist. Es wird CMPs aus dem Anbieterspeicher abgerufen und ruft die kryptografischen Materialien ab, die es vom zurückgibt. CMPs Typischerweise wird jeder CMP verwendet, um mehrere Anfragen nach kryptographischem Material zu befriedigen. Sie können jedoch mit den Funktionen des Provider-Stores steuern, inwieweit Materialien wiederverwendet werden, wie oft der CMP gewechselt wird und sogar den Typ des CMP ändern, ohne den Most Recent Provider zu ändern.
**Anmerkung**
Der Code, der dem `MostRecentProvider` Symbol für den neuesten Anbieter zugeordnet ist, speichert möglicherweise kryptografisches Material für die gesamte Lebensdauer des Prozesses im Speicher. Es könnte einem Anrufer ermöglichen, Schlüssel zu verwenden, zu deren Verwendung er nicht mehr berechtigt ist.
Das `MostRecentProvider` Symbol ist in älteren unterstützten Versionen des DynamoDB Encryption Client veraltet und wurde aus Version 2.0.0 entfernt. Es wird durch das Symbol ersetzt. `CachingMostRecentProvider` Details hierzu finden Sie unter [Aktualisierungen für den neuesten Anbieter](#mrp-versions).
Der Most Recent Provider ist eine gute Wahl für Anwendungen, die Aufrufe des Provider-Stores und seiner kryptographischen Quelle minimieren müssen, sowie für Anwendungen, die bestimmte kryptographische Materialien wiederverwenden können, ohne ihre Sicherheitsanforderungen zu verletzen. So können Sie beispielsweise Ihr kryptografisches Material mit einem [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) schützen, ohne AWS KMS jedes Mal, wenn Sie ein Objekt ver- oder entschlüsseln, erneut aufrufen zu müssen.
Der von Ihnen gewählte Anbieterspeicher bestimmt CMPs , welchen Typ der neueste Anbieter verwendet und wie oft er eine neue CMP erhält. Sie können jeden kompatiblen Provider-Store für den Most Recent Provider verwenden, einschließlich benutzerdefinierter Provider-Stores, die Sie entwerfen.
Der DynamoDB Encryption Client enthält einen *MetaStore*, der [Wrapped Materials Providers (Wrapped](wrapped-provider.md)) erstellt und zurückgibt. CMPs Das MetaStore speichert mehrere Versionen von Wrapped CMPs , die es generiert, in einer internen DynamoDB-Tabelle und schützt sie mit clientseitiger Verschlüsselung durch eine interne Instanz des DynamoDB Encryption Client.
Sie können den MetaStore so konfigurieren, dass er jede Art von internem CMP verwendet, um die Materialien in der Tabelle zu schützen, einschließlich eines [direkten KMS-Anbieters](direct-kms-provider.md), der von Ihnen geschütztes kryptografisches Material generiert AWS KMS key, eines Wrapped CMP, das von Ihnen bereitgestellte Wrapping- und Signierschlüssel verwendet, oder eines kompatiblen benutzerdefinierten CMP, das Sie entwerfen.
**Beispielcode finden Sie unter:**
+ 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**
+ [Verwendung](#mrp-how-to-use-it)
+ [Funktionsweise](#mrp-how-it-works)
+ [Aktualisierungen für den neuesten Anbieter](#mrp-versions)
## Verwendung
Um einen Most Recent Provider zu erstellen, müssen Sie einen Provider-Store erstellen und konfigurieren und dann einen Most Recent Provider erstellen, der den Provider-Store verwendet.
Die folgenden Beispiele zeigen, wie Sie einen Aktuellsten Anbieter erstellen, der einen verwendet MetaStore und die Versionen in seiner internen DynamoDB-Tabelle mit kryptografischem Material von einem [Direct](direct-kms-provider.md) KMS-Anbieter schützt. In diesen Beispielen wird das Symbol verwendet. [`CachingMostRecentProvider`](#mrp-versions)
Jeder aktuelle Anbieter hat einen Namen, der ihn CMPs in der MetaStore Tabelle identifiziert, eine Einstellung [time-to-live](#most-recent-provider-ttl)(TTL) und eine Einstellung für die Cachegröße, die bestimmt, wie viele Einträge der Cache aufnehmen kann. In diesen Beispielen wird die Cachegröße auf 1000 Einträge und eine TTL von 60 Sekunden festgelegt.
------
#### [ 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
)
```
------
## Funktionsweise
Der neueste Anbieter wird CMPs aus einem Anbieterspeicher abgerufen. Dann verwendet er den CMP, um die kryptographischen Materialien zu generieren, die er an den Elementverschlüssler zurückgibt.
### Informationen über den Most Recent Provider
Der Most Recent Provider erhält einen [Anbieter kryptographischer Materialien (Cryptographic Materials Provider (CMP)](DDBEC-legacy-concepts.md#concept-material-provider) aus einem [Provider-Store](DDBEC-legacy-concepts.md#provider-store). Dann verwendet er den CMP, um die kryptographischen Materialien zu generieren, die er zurückgibt. Jeder aktuelle Anbieter ist einem Anbieterspeicher zugeordnet, aber ein Anbieterspeicher kann mehrere Anbieter auf mehreren Hosts beliefern CMPs .
Der Most Recent Provider kann mit jedem kompatiblen CMP aus einem beliebigen Provider-Store arbeiten. Es fordert Verschlüsselungs- oder Entschlüsselungsmaterial vom CMP an und gibt die Ausgabe an den Elementverschlüsseler zurück. Er führt keine kryptografischen Operationen durch.
Um einen CMP von seinem Provider-Store anzufordern, gibt der Most Recent Provider seinen Materialnamen und die Version eines bestehenden CMP an, den er verwenden möchte. Bei Verschlüsselungsmaterialien fordert der Most Recent Provider immer die maximale („neueste“) Version an. Bei Entschlüsselungsmaterialien wird die Version des CMP angefordert, die für die Erstellung der Verschlüsselungsmaterialien verwendet wurde, wie in der folgenden Abbildung dargestellt.
![\[Einen Most Recent Provider\]](http://docs.aws.amazon.com/de_de/database-encryption-sdk/latest/devguide/images/most-recent-provider-1.png)
Der neueste Anbieter speichert Versionen von CMPs , die der Anbieter zurückgibt, in einem lokalen LRU-Cache (Least Recently Used) im Arbeitsspeicher. Der Cache ermöglicht es dem neuesten Anbieter, die benötigten Daten abzurufen CMPs , ohne für jedes Element den Anbieterspeicher aufrufen zu müssen. Sie können den Cache bei Bedarf leeren.
Der neueste Anbieter verwendet einen konfigurierbaren [time-to-liveWert](#most-recent-provider-ttl), den Sie an die Eigenschaften Ihrer Anwendung anpassen können.
### Über den MetaStore
Sie können einen Most Recent Provider mit einem beliebigen Provider-Store verwenden, einschließlich eines kompatiblen benutzerdefinierten Provider-Stores. Der DynamoDB Encryption Client umfasst eine MetaStore, eine sichere Implementierung, die Sie konfigurieren und anpassen können.
A *MetaStore*ist ein [Provider-Store](DDBEC-legacy-concepts.md#provider-store), der Wrapped erstellt und zurückgibt CMPs, die mit dem [Wrapped](wrapped-provider.md) Key, dem Unwrapping Key und dem Signaturschlüssel konfiguriert sind, die Wrapped benötigen. CMPs A MetaStore ist eine sichere Option für den neuesten Anbieter, da Wrapped CMPs immer eindeutige Verschlüsselungsschlüssel für jedes Element generiert. Nur der Wrapping-Schlüssel, der den Elementverschlüsselungsschlüssel und die Signierschlüssel schützt, wird wiederverwendet.
Das folgende Diagramm zeigt die Komponenten von MetaStore und wie es mit dem neuesten Anbieter interagiert.
![\[Ein MetaStore\]](http://docs.aws.amazon.com/de_de/database-encryption-sdk/latest/devguide/images/most-recent-provider-2.png)
Der MetaStore generiert das Wrapped CMPs und speichert es dann (in verschlüsselter Form) in einer internen DynamoDB-Tabelle. Der Partitionsschlüssel ist der Name des aktuellsten Provider-Materials, der Sortierschlüssel die Versionsnummer. Die Materialien in der Tabelle sind durch einen internen DynamoDB Encryption Client geschützt, einschließlich eines Elementverschlüsselers und eines internen [Anbieters für kryptografische Materialien](DDBEC-legacy-concepts.md#concept-material-provider) (CMP).
Sie können jede Art von internem CMP in Ihrem verwenden MetaStore, einschließlich eines [direkten KMS-Anbieters](wrapped-provider.md), eines verpackten CMP mit von Ihnen bereitgestellten kryptografischen Materialien oder eines kompatiblen benutzerdefinierten CMP. Wenn es sich bei Ihrem internen CMP um einen Direct KMS-Anbieter MetaStore handelt, sind Ihre wiederverwendbaren Wrapping- und Signaturschlüssel mit einem in () geschützt. [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 Der MetaStore ruft AWS KMS jedes Mal auf, wenn er seiner internen Tabelle eine neue CMP-Version hinzufügt oder eine CMP-Version aus seiner internen Tabelle abruft.
### Einen Wert setzen time-to-live
Sie können für jeden neuesten Anbieter, den Sie erstellen, einen Wert time-to-live (TTL) festlegen. Verwenden Sie im Allgemeinen den niedrigsten TTL-Wert, der für Ihre Anwendung praktikabel ist.
Die Verwendung des TTL-Werts wird im `CachingMostRecentProvider` Symbol für den neuesten Anbieter geändert.
**Anmerkung**
Das `MostRecentProvider` Symbol für den neuesten Anbieter ist in älteren unterstützten Versionen des DynamoDB Encryption Client veraltet und wurde aus Version 2.0.0 entfernt. Es wird durch das Symbol ersetzt. `CachingMostRecentProvider` Wir empfehlen Ihnen, Ihren Code so schnell wie möglich zu aktualisieren. Details hierzu finden Sie unter [Aktualisierungen für den neuesten Anbieter](#mrp-versions).
**`CachingMostRecentProvider`**
Der `CachingMostRecentProvider` verwendet den TTL-Wert auf zwei verschiedene Arten.
+ Die TTL bestimmt, wie oft der neueste Anbieter im Anbieterspeicher nach einer neuen Version der CMP sucht. Wenn eine neue Version verfügbar ist, ersetzt der neueste Anbieter seinen CMP und aktualisiert sein kryptografisches Material. Andernfalls verwendet er weiterhin seine aktuellen CMP- und kryptografischen Materialien.
+ Die TTL bestimmt, wie lange CMPs der Cache verwendet werden kann. Bevor er eine zwischengespeicherte CMP für die Verschlüsselung verwendet, bewertet der aktuelle Anbieter die Zeit, die er im Cache verbracht hat. Wenn die CMP-Cachezeit die TTL überschreitet, wird die CMP aus dem Cache entfernt und der neueste Anbieter erhält eine neue CMP der neuesten Version aus seinem Provider-Speicher.
**`MostRecentProvider`**
In der bestimmt die TTL`MostRecentProvider`, wie oft der neueste Anbieter im Anbieterspeicher nach einer neuen Version des CMP sucht. Wenn eine neue Version verfügbar ist, ersetzt der neueste Anbieter seinen CMP und aktualisiert sein kryptografisches Material. Andernfalls verwendet er weiterhin seine aktuellen CMP- und kryptografischen Materialien.
Die TTL bestimmt nicht, wie oft eine neue CMP-Version erstellt wird. Sie erstellen neue CMP-Versionen, indem Sie die kryptografischen Materialien [rotieren](#most-recent-provider-rotate).
Ein idealer TTL-Wert hängt von der Anwendung und ihren Latenz- und Verfügbarkeitszielen ab. Eine niedrigere TTL verbessert Ihr Sicherheitsprofil, da sie die Zeit reduziert, in der kryptografisches Material im Speicher gespeichert wird. Eine niedrigere TTL aktualisiert außerdem wichtige Informationen häufiger. Wenn es sich bei Ihrem internen CMP beispielsweise um einen [Direct KMS-Anbieter](direct-kms-provider.md) handelt, überprüft er häufiger, ob der Anrufer weiterhin berechtigt ist, einen zu verwenden. AWS KMS key
Wenn die TTL jedoch zu kurz ist, können die häufigen Anrufe beim Provider-Store Ihre Kosten in die Höhe treiben und dazu führen, dass Ihr Provider-Store Anfragen von Ihrer Anwendung und anderen Anwendungen, die Ihr Dienstkonto gemeinsam nutzen, drosselt. Sie könnten auch davon profitieren, die TTL mit der Geschwindigkeit zu koordinieren, mit der Sie kryptografisches Material wechseln.
Variieren Sie beim Testen die TTL und die Cachegröße je nach Arbeitslast, bis Sie eine Konfiguration gefunden haben, die für Ihre Anwendung und Ihre Sicherheits- und Leistungsstandards geeignet ist.
### Rotieren von kryptografischen Materialien
Wenn ein neuester Anbieter Verschlüsselungsmaterial benötigt, verwendet er immer die neueste Version seiner CMP, die ihm bekannt ist. Die Häufigkeit, mit der nach einer neueren Version gesucht wird, wird durch den [time-to-live](#most-recent-provider-ttl)(TTL) -Wert bestimmt, den Sie bei der Konfiguration des neuesten Anbieters festgelegt haben.
Wenn die TTL abläuft, sucht der neueste Anbieter im Anbieterspeicher nach einer neueren Version der CMP. Wenn eine verfügbar ist, wird sie vom neuesten Anbieter abgerufen und die CMP in seinem Cache ersetzt. Er verwendet dieses CMP und seine kryptografischen Materialien, bis es feststellt, dass es im Provider-Store eine neuere Version gibt.
Um den Provider-Store anzuweisen, eine neue Version eines CMP für einen Most Recent Provider zu erstellen, rufen Sie die Operation „Create New Provider“ (Neuen Provider erstellen) des Provider-Stores mit dem Materialnamen des Most Recent Providers auf. Der Provider-Store erstellt einen neuen CMP und speichert eine verschlüsselte Kopie in seinem internen Speicher mit einer höheren Versionsnummer. (Es gibt auch einen CMP zurück, aber Sie können ihn verwerfen.) Wenn der neueste Anbieter das nächste Mal die maximale Versionsnummer des Provider-Speichers abfragt CMPs, ruft er die neue höhere Versionsnummer ab und verwendet sie in nachfolgenden Anfragen an den Speicher, um festzustellen, ob eine neue Version des CMP erstellt wurde.
Sie können Ihre „Create New Provider“-Aufrufe (Neuen Provider erstellen) abhängig von der Zeit, der Anzahl der verarbeiteten Elemente oder Attribute oder einer anderen für Ihre Anwendung sinnvollen Kennzahl planen.
### Verschlüsselungsmaterialien abrufen
Der Most Recent Provider verwendet den folgenden Prozess, wie in dieser Abbildung gezeigt, um die Verschlüsselungsmaterialien zu erhalten, die er an den Elementverschlüssler zurückgibt. Die Ausgabe hängt vom Typ des CMP ab, den der Provider-Store zurückgibt. Der neueste Anbieter kann jeden kompatiblen Anbieterspeicher verwenden, einschließlich des Speichers MetaStore , der im DynamoDB Encryption Client enthalten ist.
![\[Eingabe, Verarbeitung und Ausgabe des neuesten Anbieters im DynamoDB Encryption Client\]](http://docs.aws.amazon.com/de_de/database-encryption-sdk/latest/devguide/images/most-recent-provider-provider-store.png)
Wenn Sie mithilfe des [`CachingMostRecentProvider`Symbols](#mrp-versions) einen aktuellen Anbieter erstellen, geben Sie einen Anbieterspeicher, einen Namen für den neuesten Anbieter und einen [time-to-live](#most-recent-provider-ttl)(TTL) -Wert an. Sie können optional auch eine Cachegröße angeben, die die maximale Anzahl kryptografischer Materialien bestimmt, die im Cache vorhanden sein können.
Wenn der Elementverschlüssler den Most Recent Provider nach Verschlüsselungsmaterialien fragt, sucht der Most Recent Provider zunächst in seinem Cache nach der neuesten Version seines CMP.
+ Wenn er die neueste Version von CMP in seinem Cache findet und der CMP den TTL-Wert nicht überschritten hat, verwendet der neueste Anbieter den CMP, um Verschlüsselungsmaterial zu generieren. Anschließend gibt er die Verschlüsselungsmaterialien an den Elementverschlüssler zurück. Für diese Operation muss der Provider-Store nicht aufgerufen werden.
+ Wenn sich die neueste Version der CMP nicht in seinem Cache befindet oder wenn sie sich im Cache befindet, aber ihren TTL-Wert überschritten hat, fordert der neueste Anbieter eine CMP aus seinem Provider-Speicher an. Die Anfrage enthält den Materialnamen des Most Recent Providers und die maximale Versionsnummer, die ihm bekannt ist.
1. Der Provider-Store gibt einen CMP aus seinem persistenten Speicher zurück. Wenn es sich bei dem Provider-Speicher um einen handelt MetaStore, ruft er eine verschlüsselte Wrapped CMP aus seiner internen DynamoDB-Tabelle ab, indem er den Materialnamen des neuesten Anbieters als Partitionsschlüssel und die Versionsnummer als Sortierschlüssel verwendet. Der MetaStore verwendet seinen internen Elementverschlüsseler und sein internes CMP, um das Wrapped CMP zu entschlüsseln. Dann gibt er den Klartext-CMP an den Most Recent Provider zurück. Wenn der interne CMP ein [Direct KMS Provider](direct-kms-provider.md) ist, beinhaltet dieser Schritt einen Aufruf von [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/) (AWS KMS).
1. Der CMP fügt das `amzn-ddb-meta-id`-Feld der [aktuellen Materialbeschreibung](DDBEC-legacy-concepts.md#legacy-material-description) hinzu. Sein Wert sind der Materialname und die Version des CMP in seiner internen Tabelle. Der Provider-Store gibt den CMP an den Most Recent Provider zurück.
1. Der Most Recent Provider speichert den CMP im Speicher zwischen.
1. Der Most Recent Provider verwendet den CMP, um Verschlüsselungsmaterialien zu generieren. Anschließend gibt er die Verschlüsselungsmaterialien an den Elementverschlüssler zurück.
### Entschlüsselungsmaterialien abrufen
Wenn der Elementverschlüssler den Most Recent Provider nach Entschlüsselungsmaterialien abfragt, verwendet der Most Recent Provider den folgenden Prozess, um diese abzurufen und zurückzugeben.
1. Der Most Recent Provider fragt den Provider-Store nach der Versionsnummer des kryptographischen Materials, das zur Verschlüsselung des Elements verwendet wurde. Er übergibt die aktuelle Materialbeschreibung aus dem [Materialbeschreibungsattribut](DDBEC-legacy-concepts.md#legacy-material-description) des Elements.
1. Der Provider Store ruft die verschlüsselnde CMP-Versionsnummer aus dem Feld `amzn-ddb-meta-id` in der aktuellen Materialbeschreibung ab und gibt sie an den Most Recent Provider zurück.
1. Der Most Recent Provider durchsucht seinen Cache nach der Version des CMP, mit der das Element verschlüsselt und signiert wurde.
+ Wenn er feststellt, dass sich die passende Version des CMP in seinem Cache befindet und der CMP den [time-to-live (TTL) -Wert](#most-recent-provider-ttl) nicht überschritten hat, verwendet der neueste Anbieter den CMP, um Entschlüsselungsmaterialien zu generieren. Anschließend gibt er die Entschlüsselungsmaterialien an den Elementverschlüssler zurück. Für diese Operation muss der Provider-Store nicht aufgerufen werden, und auch kein anderer CMP.
+ Wenn sich die passende Version der CMP nicht in ihrem Cache befindet oder wenn die zwischengespeicherte Version ihren TTL-Wert überschritten AWS KMS key hat, fordert der neueste Anbieter eine CMP von seinem Provider-Speicher an. Er sendet seinen Materialnamen und die Versionsnummer des verschlüsselnden CMP in der Anfrage.
1. Der Provider-Store durchsucht seinen persistenten Speicher nach dem CMP, indem er den Namen des Most Recent Providers als Partitionsschlüssel und die Versionsnummer als Sortierschlüssel verwendet.
+ Wenn sich der Name und die Versionsnummer nicht in seinem persistenten Speicher befinden, wirft der Provider-Store eine Ausnahme auf. Wenn der Provider-Store zur Generierung des CMP verwendet wurde, sollte der CMP in seinem persistenten Speicher abgelegt sein, es sei denn, er wurde absichtlich gelöscht.
+ Wenn sich der CMP mit dem übereinstimmenden Namen und der Versionsnummer im persistenten Speicher des Provider-Stores befindet, gibt der Provider-Store den angegebenen CMP an den Most Recent Provider zurück.
Wenn es sich bei dem Provider-Speicher um einen handelt MetaStore, ruft er die verschlüsselte CMP aus seiner DynamoDB-Tabelle ab. Dann verwendet er kryptografische Materialien aus seinem internen CMP, um den verschlüsselten CMP zu entschlüsseln, bevor es den CMP an den Most Recent Provider zurückgibt. Wenn der interne CMP ein [Direct KMS Provider](direct-kms-provider.md) ist, beinhaltet dieser Schritt einen Aufruf von [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/) (AWS KMS).
1. Der Most Recent Provider speichert den CMP im Speicher zwischen.
1. Der Most Recent Provider verwendet den CMP, um Entschlüsselungsmaterialien zu generieren. Anschließend gibt er die Entschlüsselungsmaterialien an den Elementverschlüssler zurück.
## Aktualisierungen für den neuesten Anbieter
Das Symbol für den neuesten Anbieter wurde von `MostRecentProvider` zu geändert`CachingMostRecentProvider`.
**Anmerkung**
Das `MostRecentProvider` Symbol, das den neuesten Anbieter darstellt, ist in Version 1.15 des DynamoDB Encryption Client für Java und Version 1.3 des DynamoDB Encryption Client für Python veraltet und wurde aus den Versionen 2.0.0 des DynamoDB Encryption Client in beiden Sprachimplementierungen entfernt. Verwenden Sie stattdessen die. `CachingMostRecentProvider`
Der `CachingMostRecentProvider` implementiert die folgenden Änderungen:
+ Die entfernt in `CachingMostRecentProvider` regelmäßigen Abständen kryptografisches Material aus dem Speicher, wenn ihre Speicherdauer den konfigurierten Wert [time-to-live (TTL)](#most-recent-provider-ttl) überschreitet.
Sie speichern `MostRecentProvider` möglicherweise kryptografisches Material für die gesamte Lebensdauer des Prozesses im Speicher. Dies hat zur Folge, dass der neueste Anbieter von Autorisierungsänderungen möglicherweise nichts weiß. Möglicherweise werden Verschlüsselungsschlüssel verwendet, nachdem dem Anrufer die Berechtigungen zu deren Verwendung entzogen wurden.
Wenn Sie nicht auf diese neue Version aktualisieren können, können Sie einen ähnlichen Effekt erzielen, indem Sie die `clear()` Methode regelmäßig im Cache aufrufen. Diese Methode löscht den Cache-Inhalt manuell und erfordert, dass der neueste Anbieter eine neue CMP und neue kryptografische Materialien anfordert.
+ Dazu gehört `CachingMostRecentProvider` auch eine Einstellung für die Cachegröße, mit der Sie mehr Kontrolle über den Cache haben.
Um auf die zu aktualisieren`CachingMostRecentProvider`, müssen Sie den Symbolnamen in Ihrem Code ändern. In jeder anderen Hinsicht `CachingMostRecentProvider` ist das vollständig abwärtskompatibel mit dem`MostRecentProvider`. Sie müssen keine Tabellenelemente erneut verschlüsseln.
Das `CachingMostRecentProvider` generiert jedoch mehr Aufrufe an die zugrunde liegende Schlüsselinfrastruktur. Es ruft den Provider-Speicher mindestens einmal in jedem time-to-live (TTL-) Intervall auf. Anwendungen mit zahlreichen aktiven Anwendungen CMPs (aufgrund häufiger Rotation) oder Anwendungen mit großen Flotten reagieren höchstwahrscheinlich empfindlich auf diese Änderung.
Bevor Sie Ihren aktualisierten Code veröffentlichen, testen Sie ihn gründlich, um sicherzustellen, dass die häufigeren Aufrufe Ihre Anwendung nicht beeinträchtigen oder zu Drosselungen durch Dienste führen, von denen Ihr Anbieter abhängig ist, wie AWS Key Management Service (AWS KMS) oder Amazon DynamoDB. Um Leistungsprobleme zu vermeiden, passen Sie die Cachegröße und die Größe des Caches an die time-to-live von Ihnen beobachteten `CachingMostRecentProvider` Leistungsmerkmale an. Anleitungen finden Sie unter [Einen Wert setzen time-to-live](#most-recent-provider-ttl).
# Static Materials Provider
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
Der *Static Materials Provider* (Static CMP) ist ein sehr einfacher [Anbieter für kryptografische Materialien](DDBEC-legacy-concepts.md#concept-material-provider) (CMP), der für Tests, proof-of-concept Demonstrationen und zur Kompatibilität mit älteren Versionen vorgesehen ist.
Um mit dem Static CMP ein Tabellenelement zu verschlüsseln, geben Sie einen symmetrischen [Advanced Encryption Standard](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard) (AES)-Verschlüsselungsschlüssel und einen Signierschlüssel oder ein Schlüsselpaar an. Sie müssen die gleichen Schlüssel angeben, um das verschlüsselte Element zu entschlüsseln. Der Static CMP führt keine kryptografischen Vorgänge durch. Stattdessen übergibt es die Verschlüsselungsschlüssel, die Sie dem Elementverschlüssler zur Verfügung stellen, unverändert. Der Elementverschlüsseler verschlüsselt die Elemente direkt unter dem Verschlüsselungsschlüssel. Anschließend verwendet er den Signierschlüssel, um sie direkt zu signieren.
Da der Static CMP keine eindeutigen kryptographischen Materialien erzeugt, werden alle Tabellenelemente, die Sie verarbeiten, mit demselben Verschlüsselungsschlüssel verschlüsselt und mit demselben Signierschlüssel signiert. Wenn Sie den gleichen Schlüssel verwenden, um die Attributwerte in verschiedenen Elementen zu verschlüsseln, oder wenn Sie den gleichen Schlüssel oder das gleiche Schlüsselpaar verwenden, um alle Elemente zu signieren, laufen Sie Gefahr, die kryptographischen Grenzen der Schlüssel zu überschreiten.
**Anmerkung**
Der [Asymmetric Static Provider](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/providers/AsymmetricStaticProvider.html) in der Java-Bibliothek ist kein statischer Anbieter. Er liefert nur alternative Konstruktoren für den [Wrapped CMP](wrapped-provider.md). Er ist sicher für die Produktion, aber Sie sollten den Wrapped CMP nach Möglichkeit direkt verwenden.
Der statische CMP ist einer von mehreren [Anbietern für kryptografisches Material](DDBEC-legacy-concepts.md#concept-material-provider) (CMPs), die der DynamoDB Encryption Client unterstützt. Hinweise zum anderen finden Sie unter. CMPs [Anbieter von kryptografischem Material](crypto-materials-providers.md)
**Beispielcode finden Sie unter:**
+ Java: [SymmetricEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/SymmetricEncryptedItem.java)
**Topics**
+ [Verwendung](#static-cmp-how-to-use)
+ [Funktionsweise](#static-cmp-how-it-works)
## Verwendung
Um einen statischen Anbieter zu erstellen, geben Sie einen Verschlüsselungsschlüssel oder ein Schlüsselpaar und einen Signierschlüssel oder ein Schlüsselpaar an. Sie müssen Schlüsselmaterial zum Ver- und Entschlüsseln von Tabellenelementen bereitstellen.
------
#### [ 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
)
```
------
## Funktionsweise
Der Statische Provider übergibt die von Ihnen gelieferten Verschlüsselungs- und Signierschlüssel an den Elementverschlüssler, wo sie direkt zum Verschlüsseln und Signieren Ihrer Tabellenelemente verwendet werden. Wenn Sie nicht für jedes Element unterschiedliche Schlüssel angeben, werden für jedes Element die gleichen Schlüssel verwendet.
![\[Die Eingabe, Verarbeitung und Ausgabe des Static Materials Provider im DynamoDB Encryption Client\]](http://docs.aws.amazon.com/de_de/database-encryption-sdk/latest/devguide/images/staticCMP.png)
### Verschlüsselungsmaterialien abrufen
Dieser Abschnitt beschreibt detailliert die Ein- und Ausgänge und die Verarbeitung des Static Materials Providers (Static CMP), wenn er eine Anfrage für Verschlüsselungsmaterialien erhält.
**Eingabe** (von der Anwendung)
+ Ein Verschlüsselungsschlüssel — Dies muss ein symmetrischer Schlüssel sein, z. B. ein AES-Schlüssel ([Advanced Encryption Standard](https://tools.ietf.org/html/rfc3394.html)).
+ Ein Signaturschlüssel — Dies kann ein symmetrischer Schlüssel oder ein asymmetrisches key pair sein.
**Eingabe** (vom Elementverschlüssler)
+ [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context)
**Ausgabe** (an den Elementverschlüssler)
+ Der als Eingabe übergebene Verschlüsselungsschlüssel.
+ Der als Eingabe übergebene Signierschlüssel.
+ Tatsächliche Materialbeschreibung: Die [angeforderte Materialbeschreibung](DDBEC-legacy-concepts.md#legacy-material-description), falls vorhanden, unverändert.
### Entschlüsselungsmaterialien abrufen
Dieser Abschnitt beschreibt detailliert die Ein- und Ausgänge und die Verarbeitung des Static Materials Providers (Static CMP), wenn er eine Anfrage für Entschlüsselungsmaterialien erhält.
Obwohl er getrennte Methoden zum Abrufen von Verschlüsselungsmaterialien und Entschlüsselungsmaterialien enthält, ist das Verhalten das gleiche.
**Eingabe** (von der Anwendung)
+ Ein Verschlüsselungsschlüssel — Dies muss ein symmetrischer Schlüssel sein, z. B. ein AES-Schlüssel ([Advanced Encryption Standard](https://tools.ietf.org/html/rfc3394.html)).
+ Ein Signaturschlüssel — Dies kann ein symmetrischer Schlüssel oder ein asymmetrisches key pair sein.
**Eingabe** (vom Elementverschlüssler)
+ [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context) (nicht verwendet)
**Ausgabe** (an den Elementverschlüssler)
+ Der als Eingabe übergebene Verschlüsselungsschlüssel.
+ Der als Eingabe übergebene Signierschlüssel.
# Verfügbare Programmiersprachen für Amazon DynamoDB Encryption Client
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
Der Amazon DynamoDB Encryption Client ist für die folgenden Programmiersprachen verfügbar. Die sprachspezifischen Bibliotheken sind unterschiedlich, aber die daraus resultierenden Implementierungen sind interoperabel. Beispielsweise können Sie ein Element mit dem Java-Client verschlüsseln (und signieren) und das Element mit dem Python-Client entschlüsseln.
Weitere Informationen finden Sie unter den entsprechenden Themen.
**Topics**
+ [Java](java.md)
+ [Python](python.md)
# Amazon DynamoDB DynamoDB-Verschlüsselungsclient für Java
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
In diesem Thema wird erklärt, wie Sie den Amazon DynamoDB Encryption Client für Java installieren und verwenden. Einzelheiten zur Programmierung mit dem DynamoDB Encryption Client finden Sie in den [Java-Beispielen, den [Beispielen](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples)](java-examples.md) im aws-dynamodb-encryption-java Repository auf GitHub und im [Javadoc](https://aws.github.io/aws-dynamodb-encryption-java/) für den DynamoDB Encryption Client.
**Anmerkung**
Versionen 1. *x.* *x* des DynamoDB Encryption Client für Java sind ab Juli 2022 in der [end-of-support Phase](what-is-database-encryption-sdk.md#support). Führen Sie so bald wie möglich ein Upgrade auf eine neuere Version durch.
**Topics**
+ [Voraussetzungen](#java-prerequisites)
+ [Installation](#java-installation)
+ [Verwenden des DynamoDB Encryption Client für Java](java-using.md)
+ [Java-Beispiele](java-examples.md)
## Voraussetzungen
Bevor Sie den Amazon DynamoDB Encryption Client für Java installieren, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen.
**Eine Java-Entwicklungsumgebung**
Sie benötigen Java 8 oder höher. Klicken Sie auf der Oracle-Website auf [Java SE Downloads](https://www.oracle.com/java/technologies/downloads/) und laden und installieren Sie anschließend das Java SE Development Kit (JDK).
Wenn Sie das Oracle JDK verwenden, müssen Sie auch die [Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files](http://www.oracle.com/java/technologies/javase-jce8-downloads.html) herunterladen und installieren.
**AWS SDK für Java**
Der DynamoDB Encryption Client benötigt das DynamoDB-Modul von, AWS SDK für Java auch wenn Ihre Anwendung nicht mit DynamoDB interagiert. Sie können das gesamte SDK oder nur dieses Modul installieren. Wenn Sie Maven verwenden, fügen Sie `aws-java-sdk-dynamodb` Ihrer `pom.xml`-Datei hinzu.
Weitere Informationen zur Installation und Konfiguration von finden Sie unter. AWS SDK für Java[AWS SDK für Java](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/getting-started.html)
## Installation
Sie können den Amazon DynamoDB Encryption Client für Java auf folgende Weise installieren.
**manuell**
Um den Amazon DynamoDB Encryption Client für Java zu installieren, klonen Sie das [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/) GitHub Repository oder laden Sie es herunter.
**Verwenden von Apache Maven**
Der Amazon DynamoDB Encryption Client für Java ist über [Apache Maven](https://maven.apache.org/) mit der folgenden Abhängigkeitsdefinition verfügbar.
```
com.amazonaws
aws-dynamodb-encryption-java
version-number
```
Nachdem Sie das SDK installiert haben, schauen Sie sich zunächst den Beispielcode in diesem Handbuch und den [DynamoDB Encryption Client Javadoc](https://aws.github.io/aws-dynamodb-encryption-java/) an. GitHub
# Verwenden des DynamoDB Encryption Client für Java
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
In diesem Thema werden einige Funktionen des DynamoDB Encryption Client in Java erklärt, die in anderen Programmiersprachenimplementierungen möglicherweise nicht zu finden sind.
Einzelheiten zur Programmierung mit dem DynamoDB Encryption Client finden Sie in den [Java-Beispielen, den [Beispielen](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples)](java-examples.md) im `aws-dynamodb-encryption-java repository` on GitHub und im [Javadoc](https://aws.github.io/aws-dynamodb-encryption-java/) für den DynamoDB Encryption Client.
**Topics**
+ [Elementverschlüssler](#attribute-encryptor)
+ [Konfigurieren des Speicherverhaltens](#save-behavior)
+ [Attributaktionen in Java](#attribute-actions-java)
+ [Überschreiben von Tabellennamen](#override-table-name)
## Elementverschlüsseler: und Dynamo AttributeEncryptor DBEncryptor
[Der DynamoDB Encryption Client in Java hat zwei [Elementverschlüsseler](DDBEC-legacy-concepts.md#item-encryptor): den Dynamo auf niedrigerer Ebene und den. DBEncryptor [AttributeEncryptor](#attribute-encryptor)](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
Das `AttributeEncryptor` ist eine Hilfsklasse, die Ihnen hilft, [Dynamo](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Methods.html) AWS SDK für Java zusammen mit dem DBMapper `DynamoDB Encryptor` im DynamoDB Encryption Client zu verwenden. Wenn Sie den `AttributeEncryptor` mit dem `DynamoDBMapper` verwenden, verschlüsselt und signiert er Ihre Elemente transparent, wenn Sie sie speichern. Außerdem werden Ihre Elemente transparent überprüft und entschlüsselt, wenn Sie sie laden.
## Konfigurieren des Speicherverhaltens
Sie können das `AttributeEncryptor` und verwenden`DynamoDBMapper`, um Tabellenelemente durch Attribute hinzuzufügen oder zu ersetzen, die nur signiert oder verschlüsselt und signiert sind. Für diese Aufgaben wird empfohlen, dass Sie sie so konfigurieren, dass das `PUT`-Speicherverhalten verwendet wird, wie im folgenden Beispiel gezeigt. Andernfalls können Sie Ihre Daten möglicherweise nicht entschlüsseln.
```
DynamoDBMapperConfig mapperConfig = DynamoDBMapperConfig.builder().withSaveBehavior(SaveBehavior.PUT).build();
DynamoDBMapper mapper = new DynamoDBMapper(ddb, mapperConfig, new AttributeEncryptor(encryptor));
```
Wenn Sie das standardmäßige Speicherverhalten verwenden, bei dem nur die Attribute aktualisiert werden, die im Tabellenelement modelliert sind, sind Attribute, die nicht modelliert sind, nicht in der Signatur enthalten und werden auch nicht durch Tabellenschreibvorgänge geändert. Daher wird die Signatur bei späteren Lesevorgängen aller Attribute nicht validiert, da sie keine nicht modellierten Attribute enthält.
Sie können auch das `CLOBBER`-Speicherverhalten verwenden. Dieses Verhalten stimmt mit dem `PUT`-Speicherverhalten überein, mit der Ausnahme, dass es die optimistische Sperre deaktiviert und das Element in der Tabelle überschreibt.
Um Signaturfehler zu vermeiden, löst der DynamoDB Encryption Client eine Laufzeitausnahme aus, wenn ein mit einem verwendet `AttributeEncryptor` wird`DynamoDBMapper`, das nicht mit dem Speicherverhalten oder konfiguriert ist. `CLOBBER` `PUT`
Um zu sehen, wie dieser Code in einem Beispiel verwendet wird, siehe [Verwenden von Dynamo DBMapper](java-examples.md#java-example-dynamodb-mapper) und das [AwsKmsEncryptedObject.java-Beispiel](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java) im Repository unter. `aws-dynamodb-encryption-java` GitHub
## Attributaktionen in Java
[Attribut-Aktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions) bestimmen, welche Attributwerte verschlüsselt und signiert, welche nur signiert und welche ignoriert werden. [Die Methode, mit der Sie Attributaktionen angeben, hängt davon ab`AttributeEncryptor`, ob Sie das `DynamoDBMapper` und oder Dynamo auf niedrigerer Ebene verwenden. DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html)
**Wichtig**
Nachdem Sie die Attributaktionen zum Verschlüsseln der Tabellenelemente verwendet haben, kann das Hinzufügen oder Entfernen von Attributen zu oder aus Ihrem Datenmodell einen Signaturvalidierungsfehler verursachen, der ein Entschlüsseln Ihrer Daten verhindert. Eine detaillierte Beschreibung finden Sie unter [Ändern Ihres Datenmodells](data-model.md).
### Attributaktionen für den Dynamo DBMapper
Bei Einsatz des `DynamoDBMapper` und `AttributeEncryptor` verwenden Sie Annotationen zum Angeben der Attributaktionen. Der DynamoDB Encryption Client verwendet die [standardmäßigen DynamoDB-Attributanmerkungen, die den Attributtyp](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.Annotations.html) definieren, um zu bestimmen, wie ein Attribut geschützt werden soll. Standardmäßig sind alle Attribute verschlüsselt und signiert, mit Ausnahme der Primärschlüssel, die zwar signiert, aber nicht verschlüsselt sind.
**Anmerkung**
Verschlüsseln Sie den Wert von Attributen nicht mit der [@Dynamo DBVersion Attribut-Annotation](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBMapper.OptimisticLocking.html), obwohl Sie sie signieren können (und sollten). Andernfalls haben Bedingungen, die ihren Wert verwenden, unbeabsichtigte Auswirkungen.
```
// 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")
```
Um Ausnahmen anzugeben, verwenden Sie die Verschlüsselungsanmerkungen, die im DynamoDB Encryption Client für Java definiert sind. Wenn Sie sie auf Klassenebene angeben, werden sie zum Standardwert für die Klasse.
```
// Sign only
@DoNotEncrypt
// Do nothing; not encrypted or signed
@DoNotTouch
```
Beispielsweise signieren diese Annotationen das `PublicationYear`-Attribut, verschlüsseln es aber nicht, und sie verschlüsseln und signieren den `ISBN`-Attributwert nicht.
```
// Sign only (override the default)
@DoNotEncrypt
@DynamoDBAttribute(attributeName="PublicationYear")
// Do nothing (override the default)
@DoNotTouch
@DynamoDBAttribute(attributeName="ISBN")
```
### Attributaktionen für den Dynamo DBEncryptor
Um Attributaktionen anzugeben, wenn Sie [Dynamo DBEncryptor](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html) direkt verwenden, erstellen Sie ein `HashMap` Objekt, in dem die Name-Wert-Paare für Attributnamen und die angegebenen Aktionen stehen.
Die gültigen Werte für die Attribut-Aktionen sind unter im Aufzählungstyp `EncryptionFlags` definiert. Sie können `ENCRYPT` und `SIGN` gemeinsam oder `SIGN` alleine verwenden, oder beides weglassen. Wenn Sie den DynamoDB Encryption Client jedoch `ENCRYPT` alleine verwenden, gibt er einen Fehler aus. Ein Attribut, das Sie nicht signieren, können Sie nicht verschlüsseln.
```
ENCRYPT
SIGN
```
**Warnung**
Verschlüsseln Sie die primären Schlüsselattribute nicht. Sie müssen im Klartext bleiben, damit DynamoDB das Element finden kann, ohne einen vollständigen Tabellenscan ausführen zu müssen.
Wenn Sie einen Primärschlüssel im Verschlüsselungskontext angeben und dann `ENCRYPT` in der Attributaktion für eines der Primärschlüsselattribute angeben, löst der DynamoDB Encryption Client eine Ausnahme aus.
Der folgende Java-Code erstellt beispielsweise eine `actions` HashMap , die alle Attribute im Element verschlüsselt und signiert. `record` Ausnahmen sind die Partitionsschlüssel- und Sortierschlüsselattribute, die zwar signiert, aber nicht verschlüsselt sind, sowie das `test`-Attribut, das weder signiert noch verschlüsselt ist.
```
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;
}
}
```
Wenn Sie dann die [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-)-Methode des `DynamoDBEncryptor` aufrufen, geben Sie die Map als Wert des Parameters `attributeFlags` an. Der folgende Aufruf von `encryptRecord` beispielsweise verwendet die `actions`-Map.
```
// Encrypt the plaintext record
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
## Überschreiben von Tabellennamen
Im DynamoDB Encryption Client ist der Name der DynamoDB-Tabelle ein Element des [DynamoDB-Verschlüsselungskontextes, das an die Verschlüsselungs](concepts.md#encryption-context) - und Entschlüsselungsmethoden übergeben wird. Wenn Sie Tabellenelemente verschlüsseln oder signieren, ist der DynamoDB-Verschlüsselungskontext, einschließlich des Tabellennamens, kryptografisch an den Chiffretext gebunden. Wenn der DynamoDB-Verschlüsselungskontext, der an die Entschlüsselungsmethode übergeben wird, nicht mit dem DynamoDB-Verschlüsselungskontext übereinstimmt, der an die Verschlüsselungsmethode übergeben wurde, schlägt der Entschlüsselungsvorgang fehl.
[Gelegentlich ändert sich der Name einer Tabelle, z. B. wenn Sie eine Tabelle sichern oder eine Wiederherstellung durchführen. point-in-time ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/PointInTimeRecovery.html) Wenn Sie die Signatur dieser Elemente entschlüsseln oder überprüfen, müssen Sie denselben DynamoDB-Verschlüsselungskontext übergeben, der zum Verschlüsseln und Signieren der Elemente verwendet wurde, einschließlich des ursprünglichen Tabellennamens. Der aktuelle Tabellenname wird nicht benötigt.
Wenn Sie den verwenden`DynamoDBEncryptor`, stellen Sie den DynamoDB-Verschlüsselungskontext manuell zusammen. Wenn Sie jedoch den verwenden, `AttributeEncryptor` erstellt der den `DynamoDBMapper` DynamoDB-Verschlüsselungskontext für Sie, einschließlich des aktuellen Tabellennamens. Um dem `AttributeEncryptor` mitzuteilen, einen Verschlüsselungskontext mit einem anderen Tabellennamen zu erstellen, verwenden Sie den `EncryptionContextOverrideOperator`.
Der folgende Code erstellt beispielsweise Instances des Anbieters von kryptographischen Materialien (Cryptographic Materials Provider (CMP)) und des `DynamoDBEncryptor`. Dann ruft er die Methode `setEncryptionContextOverrideOperator` des `DynamoDBEncryptor` auf. Er verwendet den Operator `overrideEncryptionContextTableName`, der einen Tabellennamen überschreibt. Wenn es auf diese Weise konfiguriert ist, `AttributeEncryptor` erstellt das einen DynamoDB-Verschlüsselungskontext, der anstelle von Folgendes umfasst`newTableName`. `oldTableName` [Ein vollständiges Beispiel finden Sie unter 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));
```
Wenn Sie die Load-Methode von `DynamoDBMapper` aufrufen, die das Element entschlüsselt und überprüft, geben Sie den ursprünglichen Tabellennamen an.
```
mapper.load(itemClass, DynamoDBMapperConfig.builder()
.withTableNameOverride(DynamoDBMapperConfig.TableNameOverride.withTableNameReplacement(oldTableName))
.build());
```
Sie können auch den Operator `overrideEncryptionContextTableNameUsingMap` verwenden, der mehrere Tabellennamen überschreibt.
Beim Entschlüsseln von Daten und beim Überprüfen von Signaturen werden in der Regel Operatoren zum Überschreiben des Tabellennamens verwendet. Sie können sie jedoch verwenden, um den Tabellennamen im DynamoDB-Verschlüsselungskontext beim Verschlüsseln und Signieren auf einen anderen Wert festzulegen.
Setzen Sie nicht die Operatoren zum Überschreiben des Tabellennamens ein, wenn Sie den `DynamoDBEncryptor` verwenden. Erstellen Sie stattdessen einen Verschlüsselungskontext mit dem ursprünglichen Tabellennamen und senden Sie ihn an die Entschlüsselungsmethode.
# Beispielcode für den DynamoDB Encryption Client für Java
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
Die folgenden Beispiele zeigen Ihnen, wie Sie den DynamoDB Encryption Client für Java verwenden, um DynamoDB-Tabellenelemente in Ihrer Anwendung zu schützen. Weitere Beispiele (und eigene Beispiele) finden Sie im Beispielverzeichnis des [Repositorys](https://github.com/aws/aws-dynamodb-encryption-java/tree/master/examples) unter. [aws-dynamodb-encryption-java](https://github.com/aws/aws-dynamodb-encryption-java/) GitHub
**Topics**
+ [Verwenden von Dynamo DBEncryptor](#java-example-ddb-encryptor)
+ [Verwenden von Dynamo DBMapper](#java-example-dynamodb-mapper)
## Verwenden von Dynamo DBEncryptor
[Dieses Beispiel zeigt, wie [Dynamo](https://aws.github.io/aws-dynamodb-encryption-java/com/amazonaws/services/dynamodbv2/datamodeling/encryption/DynamoDBEncryptor.html) auf niedrigerer Ebene DBEncryptor mit dem Direct KMS Provider verwendet wird.](direct-kms-provider.md) Der Direct KMS-Anbieter generiert und schützt seine kryptografischen Materialien unter einem von Ihnen angegebenen Wert [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in AWS Key Management Service (AWS KMS).
Sie können jeden kompatiblen [Anbieter für kryptografisches Material](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) mit dem verwenden`DynamoDBEncryptor`, und Sie können den Direct KMS-Anbieter mit und verwenden. `DynamoDBMapper` [AttributeEncryptor](java-using.md#attribute-encryptor)
**Sehen Sie sich das vollständige Codebeispiel** [an: .java AwsKmsEncryptedItem](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedItem.java)
Schritt 1: Erstellen Sie den Direct KMS Provider
Erstellen Sie eine Instanz des AWS KMS Clients mit der angegebenen Region. Verwenden Sie dann die Client-Instanz, um eine Instanz des Direct KMS Providers mit Ihrem bevorzugten zu erstellen AWS KMS key.
In diesem Beispiel wird der Amazon-Ressourcenname (ARN) verwendet, um den zu identifizieren AWS KMS key, aber Sie können [jeden gültigen Schlüsselbezeichner](https://docs.aws.amazon.com/kms/latest/developerguide/viewing-keys.html#find-cmk-id-arn) verwenden.
```
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);
```
Schritt 2: Erstellen Sie ein Element
In diesem Beispiel wird a definiert `record` HashMap , das ein Beispieltabellenelement darstellt.
```
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"));
```
Schritt 3: Erstellen Sie einen Dynamo DBEncryptor
Erstellen Sie eine Instance von `DynamoDBEncryptor` mit dem Direct KMS Provider.
```
final DynamoDBEncryptor encryptor = DynamoDBEncryptor.getInstance(cmp);
```
Schritt 4: Erstellen Sie einen DynamoDB-Verschlüsselungskontext
Der [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context) enthält Informationen über die Tabellenstruktur und wie sie verschlüsselt und signiert ist. Wenn Sie den `DynamoDBMapper`verwenden, erstellt der `AttributeEncryptor` den Verschlüsselungskontext für Sie.
```
final String tableName = "testTable";
final EncryptionContext encryptionContext = new EncryptionContext.Builder()
.withTableName(tableName)
.withHashKeyName(partitionKeyName)
.withRangeKeyName(sortKeyName)
.build();
```
Schritt 5: Erstellen Sie das Attribut-Aktionen-Objekt
[Attribut-Aktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions) bestimmen, welche Attribute des Elements verschlüsselt und signiert sind, welche nur signiert und welche nicht verschlüsselt oder signiert sind.
In Java erstellen Sie zur Angabe von Attributaktionen eine Kombination HashMap aus Attributnamen und `EncryptionFlags` Wertepaaren.
Der folgende Java-Code erstellt beispielsweise eine, `actions` HashMap die alle Attribute im `record` Element verschlüsselt und signiert, mit Ausnahme der Partitionsschlüssel- und Sortierschlüsselattribute, die signiert, aber nicht verschlüsselt sind, und des `test` Attributs, das nicht signiert oder verschlüsselt ist.
```
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;
}
}
```
Schritt 6: Verschlüsseln und signieren Sie das Element
Um das Tabellenelement zu verschlüsseln und zu signieren, rufen Sie die Methode `encryptRecord` für die Instance des `DynamoDBEncryptor` auf. Geben Sie das Tabellenelement (`record`), die Attribut-Aktionen (`actions`) und den Verschlüsselungskontext (`encryptionContext`) an.
```
final Map encrypted_record = encryptor.encryptRecord(record, actions, encryptionContext);
```
Schritt 7: Fügen Sie das Element in die DynamoDB-Tabelle ein
Fügen Sie abschließend das verschlüsselte und signierte Element in die DynamoDB-Tabelle ein.
```
final AmazonDynamoDB ddb = AmazonDynamoDBClientBuilder.defaultClient();
ddb.putItem(tableName, encrypted_record);
```
## Verwenden von Dynamo DBMapper
Das folgende Beispiel zeigt Ihnen, wie Sie die DynamoDB-Mapper-Hilfsklasse mit dem [Direct KMS](direct-kms-provider.md) Provider verwenden. Der Direct KMS-Anbieter generiert und schützt seine kryptografischen Materialien unter einem von Ihnen angegebenen Wert [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys)in AWS Key Management Service (AWS KMS).
Sie können jeden kompatiblen [Cryptographic Materials Provider](DDBEC-legacy-concepts.md#concept-material-provider) (CMP) mit dem `DynamoDBMapper` und den Direct KMS Provider mit dem untergeordneten `DynamoDBEncryptor` verwenden.
**[Sehen Sie sich das vollständige Codebeispiel an: .java AwsKmsEncryptedObject](https://github.com/aws/aws-dynamodb-encryption-java/blob/master/examples/src/main/java/com/amazonaws/examples/AwsKmsEncryptedObject.java)**
Schritt 1: Erstellen Sie den Direct KMS Provider
Erstellen Sie eine Instanz des AWS KMS Clients mit der angegebenen Region. Verwenden Sie dann die Client-Instanz, um eine Instanz des Direct KMS Providers mit Ihrem bevorzugten zu erstellen AWS KMS key.
In diesem Beispiel wird der Amazon-Ressourcenname (ARN) verwendet, um den zu identifizieren AWS KMS key, aber Sie können [jeden gültigen Schlüsselbezeichner](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#key-id) verwenden.
```
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);
```
Schritt 2: DynamoDB Encryptor und Dynamo erstellen DBMapper
Verwenden Sie den Direct KMS Provider, den Sie im vorherigen Schritt erstellt haben, um eine Instanz von [DynamoDB](java-using.md#attribute-encryptor) Encryptor zu erstellen. Sie müssen den DynamoDB Encryptor auf niedrigerer Ebene instanziieren, um den DynamoDB Mapper verwenden zu können.
Erstellen Sie als Nächstes eine Instanz Ihrer DynamoDB-Datenbank und eine Mapper-Konfiguration und verwenden Sie diese, um eine Instanz des DynamoDB-Mappers zu erstellen.
Wenn Sie den `DynamoDBMapper` zum Hinzufügen oder Bearbeiten signierter (oder verschlüsselter und signierter) Elemente verwenden, konfigurieren Sie ihn für die [Nutzung eines Speicherverhaltens](java-using.md#save-behavior), z. B. `PUT`, das alle Attribute enthält, wie im folgenden Beispiel gezeigt. Andernfalls können Sie Ihre Daten möglicherweise nicht entschlüsseln.
```
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));
```
Schritt 3: Definieren Sie Ihre DynamoDB-Tabelle
Definieren Sie als Nächstes Ihre DynamoDB-Tabelle. Verwenden Sie Anmerkungen zum Angeben der [Attributaktionen](java-using.md#attribute-actions-java). In diesem Beispiel werden eine DynamoDB-Tabelle und eine `DataPoJo` Klasse erstellt`ExampleTable`, die Tabellenelemente darstellt.
In dieser Beispiel-Tabelle werden die primären Schlüsselattribute signiert, aber nicht verschlüsselt. Dies gilt für das `partition_attribute`, das mit `@DynamoDBHashKey` und dem `sort_attribute` versehen ist, das mit `@DynamoDBRangeKey` versehen ist.
Attribute, die mit `@DynamoDBAttribute` versehen sind, z. B. `some numbers`, werden verschlüsselt und signiert. Ausnahmen sind Attribute, die die vom `@DoNotEncrypt` DynamoDB Encryption Client definierten Verschlüsselungsanmerkungen `@DoNotTouch` (nur signieren) oder (nicht verschlüsseln oder signieren) verwenden. Beispiel: Da das `leave me`-Attribut eine `@DoNotTouch`-Anmerkung hat, wird es nicht verschlüsselt oder signiert.
```
@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 + "]";
}
}
```
Schritt 4: Ein Tabellenelement verschlüsseln und speichern
Wenn Sie jetzt ein Tabellenelement erstellen und es mit dem DynamoDB-Mapper speichern, wird das Element automatisch verschlüsselt und signiert, bevor es der Tabelle hinzugefügt wird.
In diesem Beispiel wird ein Tabellenelement mit der Bezeichnung `record` definiert. Bevor es in der Tabelle gespeichert wird, werden seine Attribute verschlüsselt und basierend auf den Anmerkungen in der `DataPoJo`-Klasse signiert. In diesem Fall werden alle Attribute mit Ausnahme von `PartitionAttribute`, `SortAttribute` und `LeaveMe` verschlüsselt und signiert. `PartitionAttribute` und `SortAttributes` werden nur signiert. Das `LeaveMe`-Attribut ist nicht verschlüsselt oder signiert.
Rufen Sie die `save`-Methode der `DynamoDBMapper`-Klasse auf, um das `record`-Element zu verschlüsseln und zu signieren und es dann zur `ExampleTable` hinzuzufügen. Da Ihr DynamoDB-Mapper für die Verwendung des `PUT` Speicherverhaltens konfiguriert ist, ersetzt das Element jedes Element mit denselben Primärschlüsseln, anstatt es zu aktualisieren. Auf diese Weise wird sichergestellt, dass die Signaturen übereinstimmen, und Sie können das Element entschlüsseln, wenn Sie es aus der Tabelle abrufen.
```
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);
```
# DynamoDB-Verschlüsselungsclient für Python
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
In diesem Thema wird erklärt, wie Sie den DynamoDB Encryption Client für Python installieren und verwenden. Sie finden den Code im [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)Repository unter GitHub, einschließlich des vollständigen und getesteten [Beispielcodes](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples), der Ihnen den Einstieg erleichtert.
**Anmerkung**
Versionen 1. *x.* *x* und 2. *x.* *x* des DynamoDB Encryption Client für Python sind ab Juli 2022 in der [end-of-support Phase](what-is-database-encryption-sdk.md#support). Führen Sie so bald wie möglich ein Upgrade auf eine neuere Version durch.
**Topics**
+ [Voraussetzungen](#python-prerequisites)
+ [Installation](#python-installation)
+ [Den DynamoDB Encryption Client für Python verwenden](python-using.md)
+ [Python-Beispiele](python-examples.md)
## Voraussetzungen
Bevor Sie den Amazon DynamoDB Encryption Client für Python installieren, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen.
**Eine unterstützte Version von Python**
Python 3.8 oder höher ist für den Amazon DynamoDB Encryption Client für Python-Versionen 3.3.0 und höher erforderlich. Weitere Informationen zum Download von Python finden Sie unter [Python-Downloads](https://www.python.org/downloads/).
Frühere Versionen des Amazon DynamoDB Encryption Client für Python unterstützen Python 2.7 und Python 3.4 und höher, wir empfehlen jedoch, die neueste Version des DynamoDB Encryption Client zu verwenden.
**Das pip-Installationstool for Python**
Python 3.6 und höher enthalten **Pip**, obwohl Sie es möglicherweise aktualisieren möchten. Weitere Informationen zum Aktualisieren oder Installieren von pip finden Sie unter [Installation](https://pip.pypa.io/en/latest/installation/) in der Dokumentation zu **pip**.
## Installation
Verwenden Sie **pip**, um den Amazon DynamoDB Encryption Client für Python zu installieren, wie in den folgenden Beispielen gezeigt.
**Installieren der neuesten Version**
```
pip install dynamodb-encryption-sdk
```
Weitere Informationen zur Verwendung von **pip** für die Installation und die Aktualisierung von Paketen finden Sie unter [Pakete installieren](https://packaging.python.org/tutorials/installing-packages/).
Der DynamoDB Encryption Client benötigt die [Kryptografiebibliothek auf allen Plattformen](https://cryptography.io/en/latest/). Alle Versionen von **pip** installieren und erstellen die **Kryptographie**-Bibliothek unter Windows. **pip** 8.1 und höher installiert und erstellt **cryptography** auf Linux. Wenn Sie eine frühere Version von **pip** verwenden und Ihre Linux-Umgebung nicht über die erforderlichen Tools zum Erstellen der **Kryptographie**-Bibliothek verfügt, müssen Sie sie installieren. Weitere Informationen finden Sie unter [Kryptographie unter Linux](https://cryptography.io/en/latest/installation/#building-cryptography-on-linux).
Sie können die neueste Entwicklungsversion des DynamoDB Encryption Client am aus dem [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)Repository herunterladen. GitHub
Nachdem Sie den DynamoDB Encryption Client installiert haben, schauen Sie sich zunächst den Python-Beispielcode in diesem Handbuch an.
# Den DynamoDB Encryption Client für Python verwenden
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
In diesem Thema werden einige Funktionen des DynamoDB Encryption Client für Python erläutert, die in anderen Programmiersprachenimplementierungen möglicherweise nicht zu finden sind. Diese Funktionen sollen es einfacher machen, den DynamoDB Encryption Client auf die sicherste Weise zu verwenden. Wenn Sie keinen ungewöhnlichen Anwendungsfall haben, empfehlen wir Ihnen, sie zu verwenden.
Einzelheiten zur Programmierung mit dem DynamoDB Encryption Client finden Sie in den [Python-Beispielen](python-examples.md) in diesem Handbuch, in den [Beispielen](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) im aws-dynamodb-encryption-python Repository auf GitHub und in der [Python-Dokumentation](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/) für den DynamoDB Encryption Client.
**Topics**
+ [Client-Helferklassen](#python-helpers)
+ [TableInfo Klasse](#table-info)
+ [Attributaktionen in Python](#python-attribute-actions)
## Client-Helferklassen
Der DynamoDB Encryption Client für Python umfasst mehrere Client-Hilfsklassen, die die Boto 3-Klassen für DynamoDB widerspiegeln. Diese Hilfsklassen sollen das Hinzufügen von Verschlüsselung und Signierung zu Ihrer vorhandenen DynamoDB-Anwendung vereinfachen und die häufigsten Probleme wie folgt vermeiden:
+ Verhindern Sie, dass Sie den Primärschlüssel in Ihrem Element verschlüsseln, indem Sie dem [AttributeActions](#python-attribute-actions)Objekt entweder eine Aktion zum Überschreiben des Primärschlüssels hinzufügen oder indem Sie eine Ausnahme auslösen, wenn Ihr `AttributeActions` Objekt den Client ausdrücklich auffordert, den Primärschlüssel zu verschlüsseln. Wenn die Standardaktion in Ihrem `AttributeActions`-Objekt `DO_NOTHING` ist, verwenden die Client-Helferklassen diese Aktion für den Primärschlüssel. Andernfalls verwenden sie `SIGN_ONLY`.
+ Erstellen Sie ein [TableInfo Objekt](#python-helpers) und füllen Sie den [DynamoDB-Verschlüsselungskontext auf der Grundlage eines DynamoDB-Aufrufs](concepts.md#encryption-context) auf. Auf diese Weise können Sie sicherstellen, dass Ihr DynamoDB-Verschlüsselungskontext korrekt ist und der Client den Primärschlüssel identifizieren kann.
+ Support Sie Methoden wie `put_item` und`get_item`, die Ihre Tabellenelemente transparent ver- und entschlüsseln, wenn Sie in eine DynamoDB-Tabelle schreiben oder aus einer DynamoDB-Tabelle lesen. Nur die Methode `update_item` wird nicht unterstützt.
Sie können die Client-Helferklassen verwenden, anstatt direkt mit dem untergeordneten [Elementverschlüssler](DDBEC-legacy-concepts.md#item-encryptor) zu interagieren. Verwenden Sie diese Klassen, es sei denn, Sie müssen erweiterte Optionen im Elementverschlüssler festlegen.
Zu den Client-Helferklassen gehören:
+ [EncryptedTable](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/table.html#module-dynamodb_encryption_sdk.encrypted.table)für Anwendungen, die die [Tabellenressource](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#table) in DynamoDB verwenden, um jeweils eine Tabelle zu verarbeiten.
+ [EncryptedResource](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/resource.html)für Anwendungen, die die [Service Resource-Klasse](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#service-resource) in DynamoDB für die Batchverarbeitung verwenden.
+ [EncryptedClient](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/client.html)für Anwendungen, die den [Lower-Level-Client](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/dynamodb.html#client) in DynamoDB verwenden.
Um die Client-Hilfsklassen verwenden zu können, muss der Aufrufer die Berechtigung haben, den [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB-Vorgang in der Zieltabelle aufzurufen.
## TableInfo Klasse
Die [TableInfo](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/tools/structures.html#dynamodb_encryption_sdk.structures.TableInfo)Klasse ist eine Hilfsklasse, die eine DynamoDB-Tabelle darstellt, komplett mit Feldern für den Primärschlüssel und die Sekundärindizes. Sie hilft Ihnen, genaue Informationen über die Tabelle in Echtzeit zu erhalten.
Wenn Sie eine [Client-Helferklasse](#python-helpers) verwenden, erstellt und verwendet sie ein `TableInfo`-Objekt für Sie. Ansonsten können Sie explizit ein solches anlegen. Ein Beispiel finden Sie unter [Verwendung des Elementverschlüsslers](python-examples.md#python-example-item-encryptor).
Wenn Sie die `refresh_indexed_attributes` Methode für ein `TableInfo` Objekt aufrufen, füllt sie die Eigenschaftswerte des Objekts auf, indem sie den [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB-Vorgang aufruft. Die Abfrage der Tabelle ist wesentlich zuverlässiger als eine feste Codierung von Indexnamen. Die `TableInfo` Klasse enthält auch eine `encryption_context_values` Eigenschaft, die die erforderlichen Werte für den [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context) bereitstellt.
Um die `refresh_indexed_attributes` Methode verwenden zu können, muss der Aufrufer über die Berechtigung verfügen, den [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB-Vorgang in der Zieltabelle aufzurufen.
## Attributaktionen in Python
[Attribut-Aktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions) teilen dem Elementverschlüsseler mit, welche Aktionen er auf jedes Attribut des Elements anwenden soll. Um Attribut-Aktionen in Python anzugeben, legen Sie ein `AttributeActions`-Objekt mit einer Standardaktion und Ausnahmen für bestimmte Attribute an. Die gültigen Werte sind im Aufzählungstyp `CryptoAction` definiert.
**Wichtig**
Nachdem Sie die Attributaktionen zum Verschlüsseln der Tabellenelemente verwendet haben, kann das Hinzufügen oder Entfernen von Attributen zu oder aus Ihrem Datenmodell einen Signaturvalidierungsfehler verursachen, der ein Entschlüsseln Ihrer Daten verhindert. Eine detaillierte Beschreibung finden Sie unter [Ändern Ihres Datenmodells](data-model.md).
```
DO_NOTHING = 0
SIGN_ONLY = 1
ENCRYPT_AND_SIGN = 2
```
Beispielsweise richtet dieses `AttributeActions`-Objekt `ENCRYPT_AND_SIGN` als Standard für alle Attribute ein und gibt Ausnahmen für die Attribute `ISBN` und `PublicationYear` an.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={
'ISBN': CryptoAction.DO_NOTHING,
'PublicationYear': CryptoAction.SIGN_ONLY
}
)
```
Wenn Sie eine [Client-Helferklasse](#python-helpers) verwenden, müssen Sie keine Attribut-Aktion für die Primärschlüsselattribute angeben. Die Client-Helferklassen verhindern, dass Sie Ihren Primärschlüssel verschlüsseln.
Wenn Sie keine Client-Helferklasse verwenden und die Standardaktion `ENCRYPT_AND_SIGN` ist, müssen Sie eine Aktion für den Primärschlüssel angeben. Die empfohlene Aktion für Primärschlüssel ist `SIGN_ONLY`. Um dies zu vereinfachen, verwenden Sie die Methode `set_index_keys`, die SIGN\$1ONLY für Primärschlüssel verwendet, oder DO\$1NOTHING, wenn dies die Standardaktion ist.
**Warnung**
Verschlüsseln Sie die primären Schlüsselattribute nicht. Sie müssen im Klartext bleiben, damit DynamoDB das Element finden kann, ohne einen vollständigen Tabellenscan ausführen zu müssen.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
)
actions.set_index_keys(*table_info.protected_index_keys())
```
# Beispielcode für den DynamoDB Encryption Client für Python
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
Die folgenden Beispiele zeigen Ihnen, wie Sie den DynamoDB Encryption Client für Python verwenden, um DynamoDB-Daten in Ihrer Anwendung zu schützen. Weitere Beispiele (und eigene Beispiele) finden Sie im Beispielverzeichnis des [Repositorys](https://github.com/aws/aws-dynamodb-encryption-python/tree/master/examples) unter. [aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/) GitHub
**Topics**
+ [Verwenden Sie die EncryptedTable Client-Helper-Klasse](#python-example-table)
+ [Verwendung des Elementverschlüsslers](#python-example-item-encryptor)
## Verwenden Sie die EncryptedTable Client-Helper-Klasse
Das folgende Beispiel zeigt Ihnen, wie Sie den [Direct KMS Provider](direct-kms-provider.md) mit der `EncryptedTable`[-Client-Helferklasse](python-using.md#python-helpers) verwenden. Dieses Beispiel verwendet denselben [Anbieter von Verschlüsselungsdaten](DDBEC-legacy-concepts.md#concept-material-provider) wie das nachfolgende Beispiel [Verwendung des Elementverschlüsslers](#python-example-item-encryptor). Es verwendet jedoch die Klasse `EncryptedTable`, statt direkt mit dem untergeordneten [Elementverschlüssler](DDBEC-legacy-concepts.md#item-encryptor) zusammenzuarbeiten.
Durch den Vergleich dieser Beispiele erkennen Sie, was die Client-Helferklasse für Sie erledigt. Dazu gehört die Erstellung des [DynamoDB-Verschlüsselungskontextes](concepts.md#encryption-context) und die Sicherstellung, dass die Primärschlüsselattribute immer signiert, aber niemals verschlüsselt sind. Um den Verschlüsselungskontext zu erstellen und den Primärschlüssel zu ermitteln, rufen die Client-Hilfsklassen den DynamoDB-Vorgang [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)auf. Um diesen Code ausführen zu können, müssen Sie die Berechtigung haben, diese Operation aufzurufen.
**Das vollständige Codebeispiel finden Sie unter**: [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)
Schritt 1: Erstellen der Tabelle
Erstellen Sie zunächst eine Instanz einer DynamoDB-Standardtabelle mit dem Tabellennamen.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Schritt 2: Erstellen Sie einen Anbieter für Verschlüsselungsdaten
Erstellen Sie eine Instance des [Anbieters für Verschlüsselungsdaten (CMP, Cryptographic Materials Provider)](crypto-materials-providers.md), den Sie ausgewählt haben.
Dieses Beispiel verwendet den [Direct KMS Provider](direct-kms-provider.md), Sie können aber jeden beliebigen kompatiblen CMP verwenden. Um einen Direct KMS-Anbieter zu erstellen, geben Sie einen an. [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) In diesem Beispiel wird der Amazon-Ressourcenname (ARN) von verwendet AWS KMS key, Sie können jedoch jeden gültigen Schlüsselbezeichner verwenden.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Schritt 3: Erstellen Sie das Attribut-Aktionen-Objekt
[Attribut-Aktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions) teilen dem Elementverschlüsseler mit, welche Aktionen er auf jedes Attribut des Elements anwenden soll. Das `AttributeActions`-Objekt in diesem Beispiel verschlüsselt und signiert alle Elemente außer dem Attribut `test`, das ignoriert wird.
Geben Sie keine Attribut-Aktionen für die Primärschlüsselattribute an, wenn Sie eine Client-Helferklasse verwenden. Die `EncryptedTable`-Klassen signiert die Primärschlüsselattribute, verschlüsselt sie aber nie.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
```
Schritt 4: Erstellen Sie die verschlüsselte Tabelle
Legen Sie die verschlüsselte Tabelle mit der Standardtabelle, dem Direct KMS Provider und den Attribut-Aktionen an. Dieser Schritt schließt die Konfiguration ab.
```
encrypted_table = EncryptedTable(
table=table,
materials_provider=kms_cmp,
attribute_actions=actions
)
```
Schritt 5: Legen Sie das Klartext-Element in der Tabelle ab
Wenn Sie die `put_item` Methode für aufrufen`encrypted_table`, werden Ihre Tabellenelemente transparent verschlüsselt, signiert und zu Ihrer DynamoDB-Tabelle hinzugefügt.
Definieren Sie zunächst das Tabellenelement.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_attribute': 55
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Anschließend legen Sie es in der Tabelle ab.
```
encrypted_table.put_item(Item=plaintext_item)
```
Um das Element in verschlüsselter Form aus der DynamoDB-Tabelle abzurufen, rufen Sie die `get_item` Methode für das Objekt auf. `table` Um das verschlüsselte Element abzurufen, rufen Sie die Methode `get_item` für das Objekt `encrypted_table` auf.
## Verwendung des Elementverschlüsslers
Dieses Beispiel zeigt Ihnen, wie Sie beim [Verschlüsseln von Tabellenelementen direkt mit dem Elementverschlüsseler](DDBEC-legacy-concepts.md#item-encryptor) im DynamoDB Encryption Client interagieren können, anstatt die [Client-Hilfsklassen](python-using.md#python-helpers) zu verwenden, die für Sie mit dem Elementverschlüsseler interagieren.
Wenn Sie diese Technik verwenden, erstellen Sie den DynamoDB-Verschlüsselungskontext und das Konfigurationsobjekt (`CryptoConfig`) manuell. Außerdem verschlüsseln Sie die Elemente in einem Aufruf und fügen sie in einem separaten Aufruf in Ihre DynamoDB-Tabelle ein. Auf diese Weise können Sie Ihre `put_item` Aufrufe anpassen und den DynamoDB Encryption Client verwenden, um strukturierte Daten zu verschlüsseln und zu signieren, die niemals an DynamoDB gesendet werden.
Dieses Beispiel verwendet den [Direct KMS Provider](direct-kms-provider.md), Sie können aber jeden beliebigen kompatiblen CMP verwenden.
**Das vollständige Codebeispiel finden Sie unter**: [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)
Schritt 1: Erstellen der Tabelle
Erstellen Sie zunächst eine Instanz einer standardmäßigen DynamoDB-Tabellenressource mit dem Tabellennamen.
```
table_name='test-table'
table = boto3.resource('dynamodb').Table(table_name)
```
Schritt 2: Erstellen Sie einen Anbieter für Verschlüsselungsdaten
Erstellen Sie eine Instance des [Anbieters für Verschlüsselungsdaten (CMP, Cryptographic Materials Provider)](crypto-materials-providers.md), den Sie ausgewählt haben.
Dieses Beispiel verwendet den [Direct KMS Provider](direct-kms-provider.md), Sie können aber jeden beliebigen kompatiblen CMP verwenden. Um einen Direct KMS-Anbieter zu erstellen, geben Sie einen an. [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#master_keys) In diesem Beispiel wird der Amazon-Ressourcenname (ARN) von verwendet AWS KMS key, Sie können jedoch jeden gültigen Schlüsselbezeichner verwenden.
```
kms_key_id='arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab'
kms_cmp = AwsKmsCryptographicMaterialsProvider(key_id=kms_key_id)
```
Schritt 3: Verwenden Sie die TableInfo Helper-Klasse
Um Informationen über die Tabelle von DynamoDB zu erhalten, erstellen Sie eine Instanz der [TableInfo](python-using.md#python-helpers)Hilfsklasse. Wenn Sie direkt mit dem Elementverschlüssler arbeiten, müssen Sie eine `TableInfo`-Instance erstellen und deren Methoden aufrufen. Dies erledigt die [Client-Helferklasse](python-using.md#python-helpers) für Sie.
Die `refresh_indexed_attributes` Methode von `TableInfo` verwendet den [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)DynamoDB-Vorgang, um in Echtzeit genaue Informationen über die Tabelle abzurufen. Dazu gehören ihre Primärschlüssel und ihre lokalen und globalen Sekundärindizes. Der Aufrufer benötigt die Berechtigung, `DescribeTable` aufzurufen.
```
table_info = TableInfo(name=table_name)
table_info.refresh_indexed_attributes(table.meta.client)
```
Schritt 4: DynamoDB-Verschlüsselungskontext erstellen
Der [DynamoDB-Verschlüsselungskontext](concepts.md#encryption-context) enthält Informationen über die Tabellenstruktur und wie sie verschlüsselt und signiert ist. In diesem Beispiel wird explizit ein DynamoDB-Verschlüsselungskontext erstellt, da er mit dem Elementverschlüsseler interagiert. Die [Client-Hilfsklassen](python-using.md#python-helpers) erstellen den DynamoDB-Verschlüsselungskontext für Sie.
Um den Partitionsschlüssel und den Sortierschlüssel abzurufen, können Sie die Eigenschaften der [TableInfo](python-using.md#python-helpers)Hilfsklasse verwenden.
```
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)
)
```
Schritt 5: Erstellen Sie das Attribut-Aktionen-Objekt
[Attribut-Aktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions) teilen dem Elementverschlüsseler mit, welche Aktionen er auf jedes Attribut des Elements anwenden soll. Das `AttributeActions`-Objekt in diesem Beispiel verschlüsselt und signiert alle Elemente mit Ausnahme der Primärschlüsselattribute, die signiert, aber nicht verschlüsselt sind, und des Attributs `test`, das ignoriert wird.
Wenn Sie direkt mit dem Elementverschlüsseler interagieren und Ihre Standardaktion `ENCRYPT_AND_SIGN` ist, müssen Sie eine alternative Aktion für den Primärschlüssel angeben. Sie können die `set_index_keys`-Methode verwenden, die `SIGN_ONLY` für den Primärschlüssel verwendet, oder `DO_NOTHING`, wenn es die Standardaktion ist.
Um den Primärschlüssel anzugeben, verwendet dieses Beispiel die Indexschlüssel im [TableInfo](python-using.md#python-helpers)Objekt, das durch einen Aufruf von DynamoDB aufgefüllt wird. Diese Technik ist sicherer als die Verwendung fest codierter Primärschlüsselnamen.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={'test': CryptoAction.DO_NOTHING}
)
actions.set_index_keys(*table_info.protected_index_keys())
```
Schritt 6: Erstellen Sie die Konfiguration für das Element
Um den DynamoDB Encryption Client zu konfigurieren, verwenden Sie die Objekte, die Sie gerade in einer [CryptoConfig](https://aws-dynamodb-encryption-python.readthedocs.io/en/latest/lib/encrypted/config.html)Konfiguration für das Tabellenelement erstellt haben. Die Client-Hilfsklassen erstellen das CryptoConfig für Sie.
```
crypto_config = CryptoConfig(
materials_provider=kms_cmp,
encryption_context=encryption_context,
attribute_actions=actions
)
```
Schritt 7: Verschlüsseln Sie das Element
Dieser Schritt verschlüsselt und signiert das Element, fügt es jedoch nicht in die DynamoDB-Tabelle ein.
Wenn Sie eine Client-Hilfsklasse verwenden, werden Ihre Elemente transparent verschlüsselt und signiert und dann zu Ihrer DynamoDB-Tabelle hinzugefügt, wenn Sie die `put_item` Methode der Hilfsklasse aufrufen. Wenn Sie den Elementverschlüsseler direkt verwenden, sind die Verschlüsselungs- und Put-Aktionen voneinander unabhängig.
Erstellen Sie zunächst ein Klartext-Element.
```
plaintext_item = {
'partition_attribute': 'value1',
'sort_key': 55,
'example': 'data',
'numbers': 99,
'binary': Binary(b'\x00\x01\x02'),
'test': 'test-value'
}
```
Anschließend verschlüsseln und signieren Sie es. Für die `encrypt_python_item`-Methode ist das `CryptoConfig`-Konfigurationsobjekt erforderlich.
```
encrypted_item = encrypt_python_item(plaintext_item, crypto_config)
```
Schritt 8: Legen Sie das Element in der Tabelle ab
In diesem Schritt wird das verschlüsselte und signierte Element in die DynamoDB-Tabelle eingefügt.
```
table.put_item(Item=encrypted_item)
```
Um das verschlüsselte Element anzuzeigen, rufen Sie die `get_item`-Methode für das ursprünglichen `table`-Objekt statt für das `encrypted_table`-Objekt auf. Sie ruft das Element aus der DynamoDB-Tabelle ab, ohne es zu verifizieren und zu entschlüsseln.
```
encrypted_item = table.get_item(Key=partition_key)['Item']
```
Das folgende Bild zeigt einen Teil eines verschlüsselten und signierten Beispiel-Tabellenelements.
Die verschlüsselten Attributwerte sind Binärdaten. Die Namen und Werte der Primärschlüsselattribute (`partition_attribute` und `sort_attribute`) und das `test`-Attribut verbleiben im Klartext. Die Ausgabe zeigt auch das Attribut, das die Signatur (`*amzn-ddb-map-sig*`) und das [Materialbeschreibungsattribut](DDBEC-legacy-concepts.md#legacy-material-description) (`*amzn-ddb-map-desc*`) enthält.
![\[Auszug aus einem verschlüsselten und signierten Element\]](http://docs.aws.amazon.com/de_de/database-encryption-sdk/latest/devguide/images/encrypted-item-closeup.png)
# Ändern Ihres Datenmodells
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
Jedes Mal, wenn Sie ein Element ver- oder entschlüsseln, müssen Sie [Attributaktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions) angeben, die dem DynamoDB Encryption Client mitteilen, welche Attribute verschlüsselt und signiert, welche Attribute signiert (aber nicht verschlüsselt) und welche ignoriert werden sollen. Attributaktionen werden nicht im verschlüsselten Element gespeichert und der DynamoDB Encryption Client aktualisiert Ihre Attributaktionen nicht automatisch.
**Wichtig**
Der DynamoDB Encryption Client unterstützt nicht die Verschlüsselung vorhandener, unverschlüsselter DynamoDB-Tabellendaten.
Wenn Sie Ihr Datenmodell ändern, d. h. wenn Sie Attribute zu Ihren Tabellenelementen hinzufügen oder von ihnen entfernen, riskieren Sie einen Fehler. Wenn die von Ihnen angegebenen Attribut-Aktionen nicht alle Attribute im Element berücksichtigen, wird das Element möglicherweise nicht so verschlüsselt und signiert, wie Sie es beabsichtigen. Wenn die Attributaktionen, die Sie beim Entschlüsseln eines Elements angeben, von den Attributaktionen abweichen, die Sie beim Verschlüsseln des Elements angegeben haben, kann zudem die Signaturprüfung fehlschlagen.
Wenn zum Beispiel die Attribut-Aktionen, die zum Verschlüsseln des Elements verwendet werden, es anweisen, das Attribut `test` zu signieren, wird die Signatur im Element das Attribut `test` enthalten. Aber wenn die Attribut-Aktionen, die zum Entschlüsseln des Elements verwendet werden, das Attribut `test` nicht berücksichtigen, schlägt die Überprüfung fehl, weil der Client versucht, eine Signatur zu verifizieren, die das Attribut `test` nicht enthält.
Dies ist ein besonderes Problem, wenn mehrere Anwendungen dieselben DynamoDB-Elemente lesen und schreiben, da der DynamoDB Encryption Client dieselbe Signatur für Elemente in allen Anwendungen berechnen muss. Dies ist auch ein Problem für jede verteilte Anwendung, da Änderungen an Attributaktionen auf alle Hosts übertragen werden müssen. Selbst wenn ein Host in einem Prozess auf Ihre DynamoDB-Tabellen zugreift, hilft die Einrichtung eines Best-Practice-Prozesses dabei, Fehler zu vermeiden, falls das Projekt einmal komplexer wird.
Verwenden Sie die folgenden Anleitungen, um Signaturvalidierungsfehler zu vermeiden, die das Lesen der Tabellenelemente verhindern.
+ [Hinzufügen eines Attributs](#add-attribute) — Wenn das neue Attribut Ihre Attributaktionen ändert, implementieren Sie die Änderung der Attributaktion vollständig, bevor Sie das neue Attribut in ein Element aufnehmen.
+ [Ein Attribut entfernen](#remove-attribute) — Wenn Sie ein Attribut nicht mehr in Ihren Artikeln verwenden, ändern Sie Ihre Attributaktionen nicht.
+ Aktion ändern — Nachdem Sie eine Konfiguration für Attributaktionen zum Verschlüsseln Ihrer Tabellenelemente verwendet haben, können Sie die Standardaktion oder die Aktion für ein vorhandenes Attribut nicht sicher ändern, ohne jedes Element in Ihrer Tabelle erneut zu verschlüsseln.
Signaturvalidierungsfehler können extrem schwierig zu beheben sein. Daher ist es am besten, diese zu verhindern.
**Topics**
+ [Hinzufügen eines Attributs](#add-attribute)
+ [Entfernen eines Attributs](#remove-attribute)
## Hinzufügen eines Attributs
Wenn Sie ein neues Attribut zu Tabellenelementen hinzufügen, müssen Sie möglicherweise die Attributaktionen ändern. Um Signaturvalidierungsfehler zu vermeiden, empfehlen wir, diese Änderung in einem zweistufigen Prozess zu implementieren. Stellen Sie sicher, dass die erste Stufe abgeschlossen ist, bevor Sie mit der zweiten Stufe beginnen.
1. Ändern Sie die Attributaktionen in allen Anwendungen, die aus der Tabelle lesen oder in sie schreiben. Stellen Sie diese Änderungen bereit und bestätigen Sie, dass das Update an alle Zielhosts weitergegeben wurde.
1. Schreiben Sie Werte in das neue Attribut in Ihren Tabellenelementen.
Dieser zweistufige Ansatz stellt sicher, dass alle Anwendungen und Hosts dieselben Attributaktionen haben, und berechnet die gleiche Signatur, bevor das neue Attribut auftritt. Dies ist auch dann wichtig, wenn die Aktion für das Attribut *Nichts tun* (nicht verschlüsseln oder signieren) lautet, da die Standardeinstellung für einige Verschlüssler das Verschlüsseln und Signieren ist.
Die folgenden Beispiele zeigen den Code für die erste Stufe in diesem Prozess. Sie fügen ein neues Elementattribut, `link`, hinzu, das einen Link zu einem anderen Tabellenelement speichert. Da dieser Link als Klartext verbleiben muss, wird ihm im Beispiel die Aktion nur zum Signieren zugewiesen. Nachdem Sie diese Änderung vollständig bereitgestellt und anschließend überprüft haben, ob alle Anwendungen und Hosts über die neuen Attributaktionen verfügen, können Sie mit der Verwendung des `link`-Attributs in Ihren Tabellenelementen beginnen.
------
#### [ Java DynamoDB Mapper ]
Wenn der `DynamoDB Mapper` und `AttributeEncryptor` verwendet werden, sind standardmäßig alle Attribute verschlüsselt und signiert, mit Ausnahme der Primärschlüssel, die zwar signiert, aber nicht verschlüsselt sind. Verwenden Sie die Annotation `@DoNotEncrypt`, um eine Aktion nur mit Signierung anzugeben.
In diesem Beispiel wird die Annotation `@DoNotEncrypt` für das neue `link`-Attribut verwendet.
```
@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 ]
Im DynamoDB-Verschlüsseler auf niedrigerer Ebene müssen Sie Aktionen für jedes Attribut festlegen. In diesem Beispiel wird eine Switch-Anweisung verwendet, bei der der Standardwert `encryptAndSign` lautet und Ausnahmen für den Partitionsschlüssel, den Sortierschlüssel und das neue `link`-Attribut angegeben werden. Wenn in diesem Beispiel der Linkattributcode nicht vollständig bereitgestellt wurde, bevor er verwendet wird, wird das Linkattribut von einigen Anwendungen verschlüsselt und signiert, von anderen aber nur signiert.
```
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 ]
Im DynamoDB Encryption Client für Python können Sie eine Standardaktion für alle Attribute und dann Ausnahmen angeben.
Wenn Sie eine Python-[Client-Helferklasse](python-using.md#python-helpers) verwenden, müssen Sie keine Attributaktion für die Primärschlüsselattribute angeben. Die Client-Helferklassen verhindern, dass Sie Ihren Primärschlüssel verschlüsseln. Wenn Sie jedoch keine Client-Hilfsklasse verwenden, müssen Sie die Aktion SIGN\$1ONLY für Ihren Partitions- und Sortierschlüssel festlegen. Wenn Sie versehentlich Ihren Partitions- oder Sortierschlüssel verschlüsseln, können Sie Ihre Daten nur mit einem vollständigen Tabellenscan wiederherstellen.
In diesem Beispiel wird eine Ausnahme für das neue `link`-Attribut angegeben, das die Aktion `SIGN_ONLY` abruft.
```
actions = AttributeActions(
default_action=CryptoAction.ENCRYPT_AND_SIGN,
attribute_actions={
'example': CryptoAction.DO_NOTHING,
'link': CryptoAction.SIGN_ONLY
}
)
```
------
## Entfernen eines Attributs
Wenn Sie ein Attribut in Elementen, die mit dem DynamoDB Encryption Client verschlüsselt wurden, nicht mehr benötigen, können Sie die Verwendung des Attributs beenden. Löschen oder ändern Sie die Aktion für dieses Attribut jedoch nicht. Wenn Sie in diesem Fall auf ein Element mit diesem Attribut stoßen, stimmt die für das Element berechnete Signatur nicht mit der ursprünglichen Signatur überein, und die Signaturvalidierung schlägt fehl.
Obwohl Sie möglicherweise versucht sind, alle Spuren des Attributs aus Ihrem Code zu entfernen, fügen Sie einen Kommentar hinzu, dass das Element nicht mehr verwendet wird, anstatt es zu löschen. Selbst wenn Sie einen vollständigen Tabellenscan durchführen, um alle Instances des Attributs zu löschen, wird möglicherweise ein verschlüsseltes Element mit diesem Attribut zwischengespeichert oder befindet sich irgendwo in Ihrer Konfiguration in Bearbeitung.
# Behebung von Problemen in Ihrer DynamoDB Encryption Client-Anwendung
**Anmerkung**
Unsere clientseitige Verschlüsselungsbibliothek wurde in Database Encryption SDK [umbenannt](DDBEC-rename.md). AWS Das folgende Thema enthält Informationen zu Versionen 1. *x* —2. *x* des DynamoDB Encryption Client für Java und Versionen 1. *x —3*. *x* des DynamoDB Encryption Client für Python. Weitere Informationen finden Sie unter [AWS Database Encryption SDK für DynamoDB-Versionsunterstützung](legacy-dynamodb-encryption-client.md#legacy-support).
In diesem Abschnitt werden Probleme beschrieben, die bei der Verwendung des DynamoDB Encryption Client auftreten können, und es werden Lösungsvorschläge gegeben.
Um Feedback zum DynamoDB Encryption Client zu geben, melden Sie ein Problem im [aws-dynamodb-encryption-java[aws-dynamodb-encryption-python](https://github.com/aws/aws-dynamodb-encryption-python/)](https://github.com/aws/aws-dynamodb-encryption-java/) GitHub OR-Repository.
Über den auf jeder Seite angezeigten Feedback-Link können Sie Feedback zu dieser Dokumentation bereitstellen.
**Topics**
+ [Zugriff verweigert](#kms-permissions)
+ [Signaturverifizierung schlägt fehl](#change-data-model)
+ [Probleme mit globalen Tabellen älterer Versionen](#fix-global-tables)
+ [Schlechte Leistung des neuesten Anbieters](#mrp-ttl-delay)
## Zugriff verweigert
**Problem**: Ihrer Anwendung wird der Zugriff auf eine benötigte Ressource verweigert.
**Vorschlag**: Informieren Sie sich über die erforderlichen Berechtigungen und fügen Sie sie dem Sicherheitskontext hinzu, in dem Ihre Anwendung ausgeführt wird.
**Details**
Um eine Anwendung auszuführen, die die DynamoDB Encryption Client-Bibliothek verwendet, muss der Aufrufer berechtigt sein, ihre Komponenten zu verwenden. Andernfalls wird ihnen der Zugriff auf die benötigten Elemente verweigert.
+ Der DynamoDB Encryption Client benötigt kein Amazon Web Services (AWS) -Konto und ist auch nicht von einem Service abhängig. AWS Wenn Ihre Anwendung jedoch verwendet AWS, benötigen Sie [ein AWS-Konto](https://aws.amazon.com/premiumsupport/knowledge-center/create-and-activate-aws-account/) und [Benutzer, die berechtigt sind, das Konto](https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html) zu verwenden.
+ Der DynamoDB Encryption Client benötigt Amazon DynamoDB nicht. Wenn die Anwendung, die den Client verwendet, jedoch DynamoDB-Tabellen erstellt, Elemente in eine Tabelle einfügt oder Elemente aus einer Tabelle abruft, muss der Aufrufer über die Berechtigung verfügen, die erforderlichen DynamoDB-Operationen in Ihrer zu verwenden. AWS-Konto Einzelheiten finden Sie in den [Themen zur Zugriffskontrolle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/access-control-overview.html) im *Amazon DynamoDB Developer Guide*.
+ Wenn Ihre Anwendung eine [Client-Hilfsklasse](python-using.md#python-helpers) im DynamoDB Encryption Client für Python verwendet, muss der Aufrufer berechtigt sein, den DynamoDB-Vorgang aufzurufen. [DescribeTable](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)
+ Der DynamoDB Encryption Client benötigt AWS Key Management Service ()AWS KMS nicht. [Wenn Ihre Anwendung jedoch einen [Direct KMS Materials Provider](direct-kms-provider.md) oder einen [Aktuellsten Anbieter mit einem Provider-Store](most-recent-provider.md) verwendet, der diese verwendet AWS KMS, benötigt der Aufrufer die Erlaubnis, die Operationen AWS KMS[GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)und Decrypt zu verwenden.](https://docs.aws.amazon.com/kms/latest/APIReference/API_Decrypt.html)
## Signaturverifizierung schlägt fehl
**Problem**: Ein Element kann nicht entschlüsselt werden, da die Signaturprüfung fehlschlägt. Das Element ist möglicherweise auch nicht so verschlüsselt und signiert, wie von Ihnen beabsichtigt.
**Vorschlag**: Stellen Sie sicher, dass die Attribut-Aktionen, die Sie zur Verfügung stellen, alle Attribute des Elements berücksichtigen. Wenn Sie ein Element entschlüsseln, stellen Sie sicher, dass die Attributaktionen mit den Aktionen übereinstimmen, die zum Verschlüsseln des Elements verwendet wurden.
**Details**
Die von Ihnen bereitgestellten [Attributaktionen](DDBEC-legacy-concepts.md#legacy-attribute-actions) teilen dem DynamoDB Encryption Client mit, welche Attribute verschlüsselt und signiert, welche Attribute signiert (aber nicht verschlüsselt) und welche ignoriert werden sollen.
Wenn die von Ihnen angegebenen Attribut-Aktionen nicht alle Attribute im Element berücksichtigen, wird das Element möglicherweise nicht so verschlüsselt und signiert, wie Sie es beabsichtigen. Wenn die Attribut-Aktionen, die Sie beim Entschlüsseln eines Elements angeben, von den Attribut-Aktionen abweichen, die Sie beim Verschlüsseln des Elements angegeben haben, kann die Signaturprüfung fehlschlagen. Dies ist speziell ein Problem für verteilte Anwendungen, bei denen sich neue Attribut-Aktionen nicht auf alle Hosts ausgebreitet haben.
Signaturvalidierungsfehler sind schwer zu beheben. Um sie zu verhindern, sollten Sie zusätzliche Vorsichtsmaßnahmen ergreifen, wenn Sie Ihr Datenmodell ändern. Details hierzu finden Sie unter [Ändern Ihres Datenmodells](data-model.md).
## Probleme mit globalen Tabellen älterer Versionen
**Problem**: Elemente in einer älteren Version der globalen Amazon DynamoDB-Tabelle können nicht entschlüsselt werden, da die Signaturüberprüfung fehlschlägt.
**Vorschlag**: Richten Sie Attributaktionen so ein, dass die reservierten Replikationsfelder nicht verschlüsselt oder signiert werden.
**Details**
Sie können den DynamoDB Encryption Client mit globalen [DynamoDB-Tabellen](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GlobalTables.html) verwenden. Wir empfehlen, globale Tabellen mit einem KMS-Schlüssel für [mehrere Regionen zu verwenden und den KMS-Schlüssel](https://docs.aws.amazon.com/kms/latest/developerguide/multi-region-keys-overview.html) in alle Bereiche zu replizieren, in AWS-Regionen denen die globale Tabelle repliziert wird.
Ab [Version 2019.11.21](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html) für globale Tabellen können Sie globale Tabellen mit dem DynamoDB Encryption Client ohne spezielle Konfiguration verwenden. Wenn Sie jedoch die [Version 2017.11.29](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html) für globale Tabellen verwenden, müssen Sie sicherstellen, dass reservierte Replikationsfelder nicht verschlüsselt oder signiert sind.
[Wenn Sie die globale Tabellenversion 2017.11.29 verwenden, müssen Sie die Attributaktionen für die folgenden Attribute `DO_NOTHING` in [Java](java-using.md#attribute-actions-java) oder `@DoNotTouch` Python auf setzen.](python-using.md#python-attribute-actions)
+ `aws:rep:deleting`
+ `aws:rep:updatetime`
+ `aws:rep:updateregion`
Wenn Sie eine andere Version von globalen Tabellen verwenden, ist keine Aktion erforderlich.
## Schlechte Leistung des neuesten Anbieters
**Problem**: Ihre Anwendung reagiert weniger, insbesondere nach einem Update auf eine neuere Version des DynamoDB Encryption Client.
**Vorschlag**: Passen Sie den time-to-live Wert und die Cachegröße an.
**Details**
The Most Recent Provider wurde entwickelt, um die Leistung von Anwendungen zu verbessern, die den DynamoDB Encryption Client verwenden, indem eine eingeschränkte Wiederverwendung von kryptografischem Material ermöglicht wird. Wenn Sie den neuesten Anbieter für Ihre Anwendung konfigurieren, müssen Sie die verbesserte Leistung mit den Sicherheitsbedenken abwägen, die sich aus dem Zwischenspeichern und der Wiederverwendung ergeben.
In neueren Versionen des DynamoDB Encryption Client bestimmt der time-to-live (TTL) -Wert, wie lange Anbieter von zwischengespeichertem kryptografischem Material (CMPs) verwendet werden können. Die TTL bestimmt auch, wie oft der neueste Anbieter nach einer neuen Version der CMP sucht.
Wenn Ihre TTL zu lang ist, verstößt Ihre Anwendung möglicherweise gegen Ihre Geschäftsregeln oder Sicherheitsstandards. Wenn Ihre TTL zu kurz ist, können häufige Anrufe beim Provider Store dazu führen, dass Ihr Provider Store Anfragen von Ihrer Anwendung und anderen Anwendungen, die Ihr Dienstkonto gemeinsam nutzen, drosselt. Um dieses Problem zu beheben, passen Sie TTL und Cachegröße auf einen Wert an, der Ihren Latenz- und Verfügbarkeitszielen entspricht und Ihren Sicherheitsstandards entspricht. Details hierzu finden Sie unter [Einen Wert setzen time-to-live](most-recent-provider.md#most-recent-provider-ttl).