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.

# Raw ECDH Schlüsselanhänger
<a name="use-raw-ecdh-keyring"></a>


****  

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

**Wichtig**  
Der Raw ECDH-Schlüsselbund ist nur mit Version 1.5.0 der Material Providers Library verfügbar.

Der Raw ECDH-Schlüsselbund verwendet die öffentlich-privaten Schlüsselpaare mit elliptischer Kurve, die Sie angeben, um einen gemeinsamen Wrapping-Schlüssel zwischen zwei Parteien abzuleiten. Zunächst leitet der Schlüsselbund mithilfe des privaten Schlüssels des Absenders, des öffentlichen Schlüssels des Empfängers und des Schlüsselvereinbarungsalgorithmus Elliptic Curve Diffie-Hellman (ECDH) ein gemeinsames Geheimnis ab. Anschließend leitet der Schlüsselbund anhand des gemeinsamen geheimen Schlüssels den gemeinsamen Wrapping-Schlüssel ab, der Ihre Datenverschlüsselungsschlüssel schützt. Die Schlüsselableitungsfunktion, mit der das AWS Database Encryption SDK (`KDF_CTR_HMAC_SHA384`) den gemeinsamen Wrapping-Schlüssel ableitet, entspricht den [NIST-Empfehlungen](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1-upd1.pdf) für die Schlüsselableitung.

Die Funktion zur Schlüsselableitung gibt 64 Byte an Schlüsselmaterial zurück. Um sicherzustellen, dass beide Parteien das richtige Schlüsselmaterial verwenden, verwendet das AWS Database Encryption SDK die ersten 32 Byte als Commitment-Schlüssel und die letzten 32 Byte als gemeinsamen Wrapping-Schlüssel. Wenn der Schlüsselbund beim Entschlüsseln nicht denselben Commitment-Schlüssel und denselben gemeinsamen Wrapping-Schlüssel reproduzieren kann, die im Materialbeschreibungsfeld des verschlüsselten Datensatzes gespeichert sind, schlägt der Vorgang fehl. Wenn Sie beispielsweise einen Datensatz mit einem Schlüsselbund verschlüsseln, der mit **Alices** privatem Schlüssel und **Bobs öffentlichem Schlüssel konfiguriert ist**, reproduziert ein Schlüsselbund, der mit **Bobs privatem Schlüssel und Alices** **öffentlichem Schlüssel konfiguriert ist**, denselben Commitment-Schlüssel und gemeinsamen Wrapping-Schlüssel und kann den Datensatz entschlüsseln. Wenn Bobs öffentlicher Schlüssel aus einem AWS KMS key Paar stammt, kann Bob einen [AWS KMS ECDH-Schlüsselbund](use-kms-ecdh-keyring.md) erstellen, um den Datensatz zu entschlüsseln.

Der Raw ECDH-Schlüsselbund verschlüsselt Datensätze mit einem symmetrischen Schlüssel mithilfe von AES-GCM. Der Datenschlüssel wird dann mit dem abgeleiteten gemeinsamen Wrapping-Schlüssel unter Verwendung von AES-GCM umhüllt. [Jeder Raw ECDH-Schlüsselbund kann nur einen gemeinsamen Wrap-Schlüssel haben, aber Sie können mehrere Raw ECDH-Schlüsselanhänger, einzeln oder zusammen mit anderen Schlüsselbunden, in einen Mehrfachschlüsselbund aufnehmen.](use-multi-keyring.md)

Sie sind dafür verantwortlich, Ihre privaten Schlüssel zu generieren, zu speichern und zu schützen, vorzugsweise in einem Hardware-Sicherheitsmodul (HSM) oder einem Schlüsselverwaltungssystem. Die Schlüsselpaare des Absenders und des Empfängers müssen sich auf derselben elliptischen Kurve befinden. Das AWS Database Encryption SDK unterstützt die folgenden Spezifikationen für elliptische Kurven:
+ `ECC_NIST_P256`
+ `ECC_NIST_P384`
+ `ECC_NIST_P512`

## Einen RAW-ECDH-Schlüsselbund erstellen
<a name="raw-ecdh-create"></a>

Der Raw ECDH-Schlüsselbund unterstützt drei wichtige Vereinbarungsschemata:, und. `RawPrivateKeyToStaticPublicKey` `EphemeralPrivateKeyToStaticPublicKey` `PublicKeyDiscovery` Das von Ihnen gewählte Schlüsselvereinbarungsschema bestimmt, welche kryptografischen Operationen Sie ausführen können und wie die Schlüsselmaterialien zusammengestellt werden.

**Topics**
+ [RawPrivateKeyToStaticPublicKey](#raw-ecdh-RawPrivateKeyToStaticPublicKey)
+ [EphemeralPrivateKeyToStaticPublicKey](#raw-ecdh-EphemeralPrivateKeyToStaticPublicKey)
+ [PublicKeyDiscovery](#raw-ecdh-PublicKeyDiscovery)

### RawPrivateKeyToStaticPublicKey
<a name="raw-ecdh-RawPrivateKeyToStaticPublicKey"></a>

Verwenden Sie das `RawPrivateKeyToStaticPublicKey` Schlüsselvereinbarungsschema, um den privaten Schlüssel des Absenders und den öffentlichen Schlüssel des Empfängers im Schlüsselbund statisch zu konfigurieren. Dieses Schlüsselvereinbarungsschema kann Datensätze ver- und entschlüsseln.

Um einen RAW-ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema zu initialisieren, `RawPrivateKeyToStaticPublicKey` geben Sie die folgenden Werte an:
+ **Der private Schlüssel des Absenders**

  [Sie müssen den PEM-codierten privaten Schlüssel des Absenders (PKCS \$18 PrivateKeyInfo -Strukturen) gemäß der Definition in RFC 5958 angeben.](https://tools.ietf.org/html/rfc5958#section-2)
+ **Der öffentliche Schlüssel des Empfängers**

  [Sie müssen den DER-codierten öffentlichen X.509-Schlüssel des Empfängers, auch bekannt als `SubjectPublicKeyInfo` (SPKI), wie in RFC 5280 definiert, angeben.](https://tools.ietf.org/html/rfc5280)

  Sie können den öffentlichen Schlüssel eines KMS-Schlüsselpaars mit asymmetrischer Schlüsselvereinbarung oder den öffentlichen Schlüssel eines außerhalb von AWS generierten key pair angeben.
+ **Spezifikation der Kurve**

  Identifiziert die Spezifikation für elliptische Kurven in den angegebenen Schlüsselpaaren. Sowohl die Schlüsselpaare des Absenders als auch des Empfängers müssen dieselbe Kurvenspezifikation haben.

  Zulässige Werte: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`

------
#### [ C\$1 / .NET ]

```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
	    var BobPrivateKey = new MemoryStream(new byte[] { });
	    var AlicePublicKey = new MemoryStream(new byte[] { });

	    // Create the Raw ECDH static keyring
	    var staticConfiguration = new RawEcdhStaticConfigurations()
	    {
		    RawPrivateKeyToStaticPublicKey = new RawPrivateKeyToStaticPublicKeyInput
		    {
			    SenderStaticPrivateKey = BobPrivateKey,
			    RecipientPublicKey = AlicePublicKey
		    }
	    };
	    
	    var createKeyringInput = new CreateRawEcdhKeyringInput() 
	    {
		    CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
		    KeyAgreementScheme = staticConfiguration 
	    };

	    var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```

------
#### [ Java ]

Das folgende Java-Beispiel verwendet das `RawPrivateKeyToStaticPublicKey` Schlüsselvereinbarungsschema, um den privaten Schlüssel des Absenders und den öffentlichen Schlüssel des Empfängers statisch zu konfigurieren. Beide Schlüsselpaare befinden sich auf der `ECC_NIST_P256` Kurve.

```
private static void StaticRawKeyring() {
    // Instantiate material providers
    final MaterialProviders materialProviders =
      MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();

    KeyPair senderKeys = GetRawEccKey();
    KeyPair recipient = GetRawEccKey();

    // Create the Raw ECDH static keyring
    final CreateRawEcdhKeyringInput rawKeyringInput =
      CreateRawEcdhKeyringInput.builder()
        .curveSpec(ECDHCurveSpec.ECC_NIST_P256)
        .KeyAgreementScheme(
          RawEcdhStaticConfigurations.builder()
            .RawPrivateKeyToStaticPublicKey(
                RawPrivateKeyToStaticPublicKeyInput.builder()
                  // Must be a PEM-encoded private key
                  .senderStaticPrivateKey(ByteBuffer.wrap(senderKeys.getPrivate().getEncoded()))
                  // Must be a DER-encoded X.509 public key
                  .recipientPublicKey(ByteBuffer.wrap(recipient.getPublic().getEncoded()))
                  .build()
            )
            .build()
        ).build();

    final IKeyring staticKeyring = materialProviders.CreateRawEcdhKeyring(rawKeyringInput);
}
```

------
#### [ Rust ]

Das folgende Python-Beispiel verwendet das `raw_ecdh_static_configuration` Schlüsselvereinbarungsschema, um den privaten Schlüssel des Absenders und den öffentlichen Schlüssel des Empfängers statisch zu konfigurieren. Beide Schlüsselpaare müssen sich auf derselben Kurve befinden.

```
// Create keyring input
let raw_ecdh_static_configuration_input =
    RawPrivateKeyToStaticPublicKeyInput::builder()
        // Must be a UTF8 PEM-encoded private key
        .sender_static_private_key(private_key_sender_utf8_bytes)
        // Must be a UTF8 DER-encoded X.509 public key
        .recipient_public_key(public_key_recipient_utf8_bytes)
        .build()?;

let raw_ecdh_static_configuration = RawEcdhStaticConfigurations::RawPrivateKeyToStaticPublicKey(raw_ecdh_static_configuration_input);

// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;

// Create raw ECDH static keyring
let raw_ecdh_keyring = mpl
    .create_raw_ecdh_keyring()
    .curve_spec(ecdh_curve_spec)
    .key_agreement_scheme(raw_ecdh_static_configuration)
    .send()
    .await?;
```

------

### EphemeralPrivateKeyToStaticPublicKey
<a name="raw-ecdh-EphemeralPrivateKeyToStaticPublicKey"></a>

Mit dem Schlüsselvereinbarungsschema konfigurierte `EphemeralPrivateKeyToStaticPublicKey` Schlüsselringe erstellen lokal ein neues key pair und leiten für jeden Verschlüsselungsaufruf einen eindeutigen gemeinsamen Wrapping-Schlüssel ab.

Dieses Schlüsselvereinbarungsschema kann nur Datensätze verschlüsseln. Um mit dem `EphemeralPrivateKeyToStaticPublicKey` Schlüsselvereinbarungsschema verschlüsselte Datensätze zu entschlüsseln, müssen Sie ein Discovery-Schlüsselvereinbarungsschema verwenden, das mit dem öffentlichen Schlüssel desselben Empfängers konfiguriert ist. Zum Entschlüsseln können Sie einen RAW-ECDH-Schlüsselbund mit dem [`PublicKeyDiscovery`](#raw-ecdh-PublicKeyDiscovery)Schlüsselvereinbarungsalgorithmus verwenden, oder, falls der öffentliche Schlüssel des Empfängers aus einem KMS-Schlüsselpaar mit asymmetrischer Schlüsselvereinbarung stammt, können Sie einen AWS KMS ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema verwenden. [KmsPublicKeyDiscovery](use-kms-ecdh-keyring.md#kms-ecdh-discovery) 

Um einen Raw-ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema zu initialisieren, geben Sie die folgenden Werte an`EphemeralPrivateKeyToStaticPublicKey`:
+ **Der öffentliche Schlüssel des Empfängers**

  [Sie müssen den DER-codierten öffentlichen X.509-Schlüssel des Empfängers, auch bekannt als `SubjectPublicKeyInfo` (SPKI), wie in RFC 5280 definiert, angeben.](https://tools.ietf.org/html/rfc5280)

  Sie können den öffentlichen Schlüssel eines KMS-Schlüsselpaars mit asymmetrischer Schlüsselvereinbarung oder den öffentlichen Schlüssel eines außerhalb von AWS generierten key pair angeben.
+ **Spezifikation der Kurve**

  Identifiziert die Spezifikation für elliptische Kurven im angegebenen öffentlichen Schlüssel.

  Beim Verschlüsseln erstellt der Schlüsselbund ein neues key pair auf der angegebenen Kurve und verwendet den neuen privaten Schlüssel und den angegebenen öffentlichen Schlüssel, um einen gemeinsamen Wrapping-Schlüssel abzuleiten.

  Zulässige Werte: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`

------
#### [ C\$1 / .NET ]

Im folgenden Beispiel wird ein RAW-ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema erstellt. `EphemeralPrivateKeyToStaticPublicKey` Beim Verschlüsseln erstellt der Schlüsselbund lokal auf der angegebenen `ECC_NIST_P256` Kurve ein neues key pair. 

```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
	    var AlicePublicKey = new MemoryStream(new byte[] { });

	    // Create the Raw ECDH ephemeral keyring
	    var ephemeralConfiguration = new RawEcdhStaticConfigurations()
	    {
		    EphemeralPrivateKeyToStaticPublicKey = new EphemeralPrivateKeyToStaticPublicKeyInput
		    {
			    RecipientPublicKey = AlicePublicKey
		    }
	    };
	    
	    var createKeyringInput = new CreateRawEcdhKeyringInput() 
	    {
		    CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
		    KeyAgreementScheme = ephemeralConfiguration
	    };

	    var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```

------
#### [ Java ]

Im folgenden Beispiel wird ein RAW-ECDH-Schlüsselbund mit dem `EphemeralPrivateKeyToStaticPublicKey` Schlüsselvereinbarungsschema erstellt. Beim Verschlüsseln erstellt der Schlüsselbund lokal auf der angegebenen `ECC_NIST_P256` Kurve ein neues key pair.

```
private static void EphemeralRawEcdhKeyring() {
    // Instantiate material providers
    final MaterialProviders materialProviders =
      MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();

    ByteBuffer recipientPublicKey = getPublicKeyBytes();

    // Create the Raw ECDH ephemeral keyring
    final CreateRawEcdhKeyringInput ephemeralInput =
      CreateRawEcdhKeyringInput.builder()
        .curveSpec(ECDHCurveSpec.ECC_NIST_P256)
        .KeyAgreementScheme(
          RawEcdhStaticConfigurations.builder()
            .EphemeralPrivateKeyToStaticPublicKey(
              EphemeralPrivateKeyToStaticPublicKeyInput.builder()
                .recipientPublicKey(recipientPublicKey)
                .build()
            )
            .build()
        ).build();

    final IKeyring ephemeralKeyring = materialProviders.CreateRawEcdhKeyring(ephemeralInput);
}
```

------
#### [ Rust ]

Im folgenden Beispiel wird ein RAW-ECDH-Schlüsselbund mit dem `ephemeral_raw_ecdh_static_configuration` Schlüsselvereinbarungsschema erstellt. Beim Verschlüsseln erstellt der Schlüsselbund lokal auf der angegebenen Kurve ein neues key pair.

```
// Create EphemeralPrivateKeyToStaticPublicKeyInput
let ephemeral_raw_ecdh_static_configuration_input =
    EphemeralPrivateKeyToStaticPublicKeyInput::builder()
        // Must be a UTF8 DER-encoded X.509 public key
        .recipient_public_key(public_key_recipient_utf8_bytes)
        .build()?;

let ephemeral_raw_ecdh_static_configuration =
    RawEcdhStaticConfigurations::EphemeralPrivateKeyToStaticPublicKey(ephemeral_raw_ecdh_static_configuration_input);

// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;

// Create raw ECDH ephemeral private key keyring
let ephemeral_raw_ecdh_keyring = mpl
    .create_raw_ecdh_keyring()
    .curve_spec(ecdh_curve_spec)
    .key_agreement_scheme(ephemeral_raw_ecdh_static_configuration)
    .send()
    .await?;
```

------

### PublicKeyDiscovery
<a name="raw-ecdh-PublicKeyDiscovery"></a>

Beim Entschlüsseln empfiehlt es sich, die Umschließungsschlüssel anzugeben, die das AWS Database Encryption SDK verwenden kann. Um dieser bewährten Methode zu folgen, verwenden Sie einen ECDH-Schlüsselbund, der sowohl den privaten Schlüssel eines Absenders als auch den öffentlichen Schlüssel des Empfängers angibt. Sie können jedoch auch einen Raw ECDH Discovery-Schlüsselbund erstellen, d. h. einen Raw ECDH-Schlüsselbund, der jeden Datensatz entschlüsseln kann, bei dem der öffentliche Schlüssel des angegebenen Schlüssels mit dem öffentlichen Schlüssel des Empfängers übereinstimmt, der im Materialbeschreibungsfeld des verschlüsselten Datensatzes gespeichert ist. Dieses Schlüsselvereinbarungsschema kann nur Datensätze entschlüsseln.

**Wichtig**  
Wenn Sie Datensätze mithilfe des `PublicKeyDiscovery` Schlüsselvereinbarungsschemas entschlüsseln, akzeptieren Sie alle öffentlichen Schlüssel, unabhängig davon, wem sie gehören.

Um einen RAW-ECDH-Schlüsselbund mit dem Schlüsselvereinbarungsschema zu initialisieren, geben Sie die `PublicKeyDiscovery` folgenden Werte an:
+ **Statischer privater Schlüssel des Empfängers**

  [Sie müssen den PEM-codierten privaten Schlüssel des Empfängers (PKCS \$18 PrivateKeyInfo -Strukturen) gemäß der Definition in RFC 5958 angeben.](https://tools.ietf.org/html/rfc5958#section-2)
+ **Spezifikation der Kurve**

  Identifiziert die Spezifikation für elliptische Kurven im angegebenen privaten Schlüssel. Sowohl die Schlüsselpaare des Absenders als auch des Empfängers müssen dieselbe Kurvenspezifikation haben.

  Zulässige Werte: `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`

------
#### [ C\$1 / .NET ]

Im folgenden Beispiel wird ein Raw ECDH-Schlüsselbund mit dem `PublicKeyDiscovery` Schlüsselvereinbarungsschema erstellt. Dieser Schlüsselbund kann jeden Datensatz entschlüsseln, bei dem der öffentliche Schlüssel des angegebenen privaten Schlüssels mit dem öffentlichen Schlüssel des Empfängers übereinstimmt, der im Materialbeschreibungsfeld des verschlüsselten Datensatzes gespeichert ist.

```
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
	    var AlicePrivateKey = new MemoryStream(new byte[] { });

	    // Create the Raw ECDH discovery keyring
	    var discoveryConfiguration = new RawEcdhStaticConfigurations()
	    {
		    PublicKeyDiscovery = new PublicKeyDiscoveryInput
		    {
			    RecipientStaticPrivateKey = AlicePrivateKey
		    }
	    };
	    
	    var createKeyringInput = new CreateRawEcdhKeyringInput() 
	    {
		    CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
		    KeyAgreementScheme = discoveryConfiguration 
	    };

	    var keyring = materialProviders.CreateRawEcdhKeyring(createKeyringInput);
```

------
#### [ Java ]

Im folgenden Beispiel wird ein RAW-ECDH-Schlüsselbund mit dem `PublicKeyDiscovery` Schlüsselvereinbarungsschema erstellt. Dieser Schlüsselbund kann jeden Datensatz entschlüsseln, bei dem der öffentliche Schlüssel des angegebenen privaten Schlüssels mit dem öffentlichen Schlüssel des Empfängers übereinstimmt, der im Materialbeschreibungsfeld des verschlüsselten Datensatzes gespeichert ist.

```
private static void RawEcdhDiscovery() {
    // Instantiate material providers
    final MaterialProviders materialProviders =
      MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();

    KeyPair recipient = GetRawEccKey();

    // Create the Raw ECDH discovery keyring
    final CreateRawEcdhKeyringInput rawKeyringInput =
      CreateRawEcdhKeyringInput.builder()
        .curveSpec(ECDHCurveSpec.ECC_NIST_P256)
        .KeyAgreementScheme(
          RawEcdhStaticConfigurations.builder()
            .PublicKeyDiscovery(
              PublicKeyDiscoveryInput.builder()
                // Must be a PEM-encoded private key
                .recipientStaticPrivateKey(ByteBuffer.wrap(sender.getPrivate().getEncoded()))
                .build()
            )
            .build()
        ).build();

    final IKeyring publicKeyDiscovery  = materialProviders.CreateRawEcdhKeyring(rawKeyringInput);
}
```

------
#### [ Rust ]

Im folgenden Beispiel wird ein RAW-ECDH-Schlüsselbund mit dem `discovery_raw_ecdh_static_configuration` Schlüsselvereinbarungsschema erstellt. Dieser Schlüsselbund kann jede Nachricht entschlüsseln, bei der der öffentliche Schlüssel des angegebenen privaten Schlüssels mit dem öffentlichen Schlüssel des Empfängers übereinstimmt, der im Chiffretext der Nachricht gespeichert ist.

```
// Create PublicKeyDiscoveryInput
let discovery_raw_ecdh_static_configuration_input =
    PublicKeyDiscoveryInput::builder()
        // Must be a UTF8 PEM-encoded private key
        .recipient_static_private_key(private_key_recipient_utf8_bytes)
        .build()?;

let discovery_raw_ecdh_static_configuration =
    RawEcdhStaticConfigurations::PublicKeyDiscovery(discovery_raw_ecdh_static_configuration_input);

// Create raw ECDH discovery private key keyring
let discovery_raw_ecdh_keyring = mpl
    .create_raw_ecdh_keyring()
    .curve_spec(ecdh_curve_spec)
    .key_agreement_scheme(discovery_raw_ecdh_static_configuration)
    .send()
    .await?;
```

------