Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Porte-clés ECDH bruts
****
| |
| --- |
| Notre bibliothèque de chiffrement côté client a été renommée SDK de chiffrement de AWS base de données. Ce guide du développeur fournit toujours des informations sur le client de [chiffrement DynamoDB](legacy-dynamodb-encryption-client.md). |
**Important**
Le porte-clés Raw ECDH n'est disponible qu'avec la version 1.5.0 de la bibliothèque Material Providers.
Le porte-clés ECDH brut utilise les paires de clés publique-privée à courbe elliptique que vous fournissez pour dériver une clé d'encapsulation partagée entre deux parties. Tout d'abord, le trousseau de clés déduit un secret partagé à l'aide de la clé privée de l'expéditeur, de la clé publique du destinataire et de l'algorithme d'accord de clé Elliptic Curve Diffie-Hellman (ECDH). Le trousseau de clés utilise ensuite le secret partagé pour dériver la clé d'encapsulation partagée qui protège vos clés de chiffrement des données. La fonction de dérivation de clé utilisée par le SDK AWS de chiffrement de base de données (`KDF_CTR_HMAC_SHA384`) pour dériver la clé d'encapsulation partagée est conforme aux [recommandations du NIST](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1-upd1.pdf) pour la dérivation de clés.
La fonction de dérivation de clés renvoie 64 octets de matériel de saisie. Pour garantir que les deux parties utilisent le bon matériel de saisie, le SDK de chiffrement de AWS base de données utilise les 32 premiers octets comme clé d'engagement et les 32 derniers octets comme clé d'encapsulation partagée. Lors du déchiffrement, si le trousseau de clés ne peut pas reproduire la même clé d'engagement et la même clé d'encapsulation partagée que celles stockées dans le champ de description du matériel de l'enregistrement crypté, l'opération échoue. Par exemple, si vous chiffrez un enregistrement avec un trousseau de clés configuré avec la clé privée d'**Alice** et la clé publique **de Bob**, un trousseau de clés configuré avec la clé privée **de Bob** et la clé publique d'**Alice** reproduira la même clé d'engagement et la même clé d'encapsulation partagée et pourra déchiffrer l'enregistrement. Si la clé publique de Bob provient d'une AWS KMS key paire, Bob peut créer un jeu de [clés AWS KMS ECDH](use-kms-ecdh-keyring.md) pour déchiffrer l'enregistrement.
Le trousseau de clés ECDH brut chiffre les enregistrements avec une clé symétrique à l'aide de l'AES-GCM. La clé de données est ensuite cryptée par enveloppe avec la clé d'encapsulation partagée dérivée à l'aide d'AES-GCM. [Chaque porte-clés Raw ECDH ne peut avoir qu'une seule clé d'encapsulation partagée, mais vous pouvez inclure plusieurs porte-clés Raw ECDH, seuls ou avec d'autres porte-clés, dans un porte-clés multiple.](use-multi-keyring.md)
Vous êtes responsable de la génération, du stockage et de la protection de vos clés privées, de préférence dans un module de sécurité matériel (HSM) ou un système de gestion des clés. Les paires de clés de l'expéditeur et du destinataire doivent se trouver sur la même courbe elliptique. Le SDK AWS Database Encryption prend en charge les spécifications de courbe elliptique suivantes :
+ `ECC_NIST_P256`
+ `ECC_NIST_P384`
+ `ECC_NIST_P512`
## Création d'un porte-clés ECDH brut
Le trousseau de clés Raw ECDH prend en charge trois schémas d'accord clés :`RawPrivateKeyToStaticPublicKey`,, et`EphemeralPrivateKeyToStaticPublicKey`. `PublicKeyDiscovery` Le schéma d'accord de clé que vous sélectionnez détermine les opérations cryptographiques que vous pouvez effectuer et la manière dont les matériaux de clé sont assemblés.
**Topics**
+ [RawPrivateKeyToStaticPublicKey](#raw-ecdh-RawPrivateKeyToStaticPublicKey)
+ [EphemeralPrivateKeyToStaticPublicKey](#raw-ecdh-EphemeralPrivateKeyToStaticPublicKey)
+ [PublicKeyDiscovery](#raw-ecdh-PublicKeyDiscovery)
### RawPrivateKeyToStaticPublicKey
Utilisez le schéma d'accord des `RawPrivateKeyToStaticPublicKey` clés pour configurer de manière statique la clé privée de l'expéditeur et la clé publique du destinataire dans le trousseau de clés. Ce schéma d'accord clé permet de chiffrer et de déchiffrer des enregistrements.
Pour initialiser un jeu de clés ECDH brut avec le schéma d'accord de `RawPrivateKeyToStaticPublicKey` clés, fournissez les valeurs suivantes :
+ **Clé privée de l'expéditeur**
[Vous devez fournir la clé privée codée PEM de l'expéditeur ( PrivateKeyInfo structures PKCS \$18), telle que définie dans la RFC 5958.](https://tools.ietf.org/html/rfc5958#section-2)
+ **Clé publique du destinataire**
[Vous devez fournir la clé publique X.509 codée DER du destinataire, également connue sous le nom de `SubjectPublicKeyInfo` (SPKI), telle que définie dans la RFC 5280.](https://tools.ietf.org/html/rfc5280)
Vous pouvez spécifier la clé publique d'une paire de clés KMS à accord de clé asymétrique ou la clé publique à partir d'une paire de clés générée en dehors de AWS.
+ **Spécification de la courbe**
Identifie la spécification de la courbe elliptique dans les paires de clés spécifiées. Les paires de clés de l'expéditeur et du destinataire doivent avoir la même spécification de courbe.
Valeurs valides : `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 ]
L'exemple Java suivant utilise le schéma d'accord de `RawPrivateKeyToStaticPublicKey` clé pour configurer de manière statique la clé privée de l'expéditeur et la clé publique du destinataire. Les deux paires de clés sont sur la `ECC_NIST_P256` courbe.
```
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 ]
L'exemple Python suivant utilise le schéma d'accord de `raw_ecdh_static_configuration` clé pour configurer de manière statique la clé privée de l'expéditeur et la clé publique du destinataire. Les deux paires de clés doivent se trouver sur la même courbe.
```
// 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
Les porte-clés configurés avec le schéma d'accord de `EphemeralPrivateKeyToStaticPublicKey` clés créent une nouvelle paire de clés localement et dérivent une clé d'encapsulation partagée unique pour chaque appel de chiffrement.
Ce schéma d'accord clé ne peut chiffrer que des enregistrements. Pour déchiffrer les enregistrements chiffrés avec le schéma d'accord de `EphemeralPrivateKeyToStaticPublicKey` clé, vous devez utiliser un schéma d'accord de clé de découverte configuré avec la clé publique du même destinataire. Pour le déchiffrer, vous pouvez utiliser un jeu de clés ECDH brut avec l'algorithme d'accord de [`PublicKeyDiscovery`](#raw-ecdh-PublicKeyDiscovery)clés ou, si la clé publique du destinataire provient d'une paire de clés KMS à accord de clé asymétrique, vous pouvez utiliser un porte-clés AWS KMS ECDH avec le schéma d'accord de clés. [KmsPublicKeyDiscovery](use-kms-ecdh-keyring.md#kms-ecdh-discovery)
Pour initialiser un jeu de clés ECDH brut avec le schéma d'accord de `EphemeralPrivateKeyToStaticPublicKey` clés, fournissez les valeurs suivantes :
+ **Clé publique du destinataire**
[Vous devez fournir la clé publique X.509 codée DER du destinataire, également connue sous le nom de `SubjectPublicKeyInfo` (SPKI), telle que définie dans la RFC 5280.](https://tools.ietf.org/html/rfc5280)
Vous pouvez spécifier la clé publique d'une paire de clés KMS à accord de clé asymétrique ou la clé publique à partir d'une paire de clés générée en dehors de AWS.
+ **Spécification de la courbe**
Identifie la spécification de la courbe elliptique dans la clé publique spécifiée.
Lors du chiffrement, le trousseau de clés crée une nouvelle paire de clés sur la courbe spécifiée et utilise la nouvelle clé privée et la clé publique spécifiée pour dériver une clé d'encapsulation partagée.
Valeurs valides : `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
L'exemple suivant crée un trousseau de clés ECDH brut avec le schéma d'accord de `EphemeralPrivateKeyToStaticPublicKey` clés. Lors du chiffrement, le trousseau de clés créera une nouvelle paire de clés localement sur la courbe spécifiée`ECC_NIST_P256`.
```
// 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 ]
L'exemple suivant crée un trousseau de clés ECDH brut avec le schéma d'accord de `EphemeralPrivateKeyToStaticPublicKey` clés. Lors du chiffrement, le trousseau de clés créera une nouvelle paire de clés localement sur la courbe spécifiée`ECC_NIST_P256`.
```
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 ]
L'exemple suivant crée un trousseau de clés ECDH brut avec le schéma d'accord de `ephemeral_raw_ecdh_static_configuration` clés. Lors du chiffrement, le trousseau de clés créera une nouvelle paire de clés localement sur la courbe spécifiée.
```
// 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
Lors du déchiffrement, il est recommandé de spécifier les clés d'encapsulation que le SDK de chiffrement de AWS base de données peut utiliser. Pour suivre cette bonne pratique, utilisez un trousseau de clés ECDH qui spécifie à la fois la clé privée de l'expéditeur et la clé publique du destinataire. Cependant, vous pouvez également créer un jeu de clés de découverte ECDH brut, c'est-à-dire un jeu de clés ECDH brut capable de déchiffrer tout enregistrement dont la clé publique spécifiée correspond à la clé publique du destinataire stockée dans le champ de description matérielle de l'enregistrement crypté. Ce schéma d'accord clé ne peut déchiffrer que les enregistrements.
**Important**
Lorsque vous déchiffrez des enregistrements à l'aide du schéma d'accord de `PublicKeyDiscovery` clés, vous acceptez toutes les clés publiques, quel que soit leur propriétaire.
Pour initialiser un jeu de clés ECDH brut avec le schéma d'accord de `PublicKeyDiscovery` clés, fournissez les valeurs suivantes :
+ **Clé privée statique du destinataire**
[Vous devez fournir la clé privée codée PEM du destinataire ( PrivateKeyInfo structures PKCS \$18), telle que définie dans la RFC 5958.](https://tools.ietf.org/html/rfc5958#section-2)
+ **Spécification de la courbe**
Identifie la spécification de la courbe elliptique dans la clé privée spécifiée. Les paires de clés de l'expéditeur et du destinataire doivent avoir la même spécification de courbe.
Valeurs valides : `ECC_NIST_P256`, `ECC_NIS_P384`, `ECC_NIST_P512`
------
#### [ C\$1 / .NET ]
L'exemple suivant crée un trousseau de clés ECDH brut avec le schéma d'accord de `PublicKeyDiscovery` clés. Ce porte-clés peut déchiffrer tout enregistrement dont la clé publique de la clé privée spécifiée correspond à la clé publique du destinataire stockée dans le champ de description du matériel de l'enregistrement crypté.
```
// 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 ]
L'exemple suivant crée un trousseau de clés ECDH brut avec le schéma d'accord de `PublicKeyDiscovery` clés. Ce porte-clés peut déchiffrer tout enregistrement dont la clé publique de la clé privée spécifiée correspond à la clé publique du destinataire stockée dans le champ de description du matériel de l'enregistrement crypté.
```
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 ]
L'exemple suivant crée un trousseau de clés ECDH brut avec le schéma d'accord de `discovery_raw_ecdh_static_configuration` clés. Ce porte-clés peut déchiffrer tout message dont la clé publique de la clé privée spécifiée correspond à la clé publique du destinataire enregistrée dans le texte chiffré du message.
```
// 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?;
```
------