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.
AWS KMS Porte-clés ECDH
Un porte-clés AWS KMS ECDH utilise un accord de clé asymétrique AWS KMS keyspour dériver une clé d'encapsulation symétrique partagée entre deux parties. Tout d'abord, le porte-clés utilise l'algorithme d'accord de clé Elliptic Curve Diffie-Hellman (ECDH) pour dériver un secret partagé à partir de la clé privée contenue dans la paire de clés KMS de l'expéditeur et de la clé publique du destinataire. 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é AWS Encryption SDK utilisée (KDF_CTR_HMAC_SHA384) pour dériver la clé d'encapsulation partagée est conforme aux recommandations du NIST pour la dérivation de clés.
La fonction de dérivation de clés renvoie 64 octets de matériel de saisie. Pour s'assurer que les deux parties utilisent le bon matériel de saisie, elles AWS Encryption SDK utilisent 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 texte chiffré de l'en-tête du message, l'opération échoue. Par exemple, si vous chiffrez des données 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 les données. Si la clé publique de Bob ne provient pas d'une paire de clés KMS, Bob peut créer un jeu de clés ECDH brut pour déchiffrer les données.
Le porte-clés AWS KMS ECDH chiffre les données 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 AWS KMS ECDH ne peut avoir qu'une seule clé d'encapsulation partagée, mais vous pouvez inclure plusieurs porte-clés AWS KMS ECDH, seuls ou avec d'autres porte-clés, dans un porte-clés multiple.
Compatibilité avec les langages de programmation
Le trousseau de clés AWS KMS ECDH est introduit dans la version 1.5.0 de la bibliothèque MPL (Cryptographic Material Providers Library) et est pris en charge par les langages de programmation et versions suivants :
-
Version 3. x du Kit SDK de chiffrement AWS pour Java
-
Version 4. x du AWS Encryption SDK pour .NET
-
Version 4. x de Kit SDK de chiffrement AWS pour Python, lorsqu'il est utilisé avec la dépendance MPL optionnelle.
-
Version 1. x du AWS Encryption SDK pour Rust
-
La version 0.1. x ou version ultérieure du AWS Encryption SDK for Go
Autorisations requises pour les AWS KMS porte-clés ECDH
Il AWS Encryption SDK ne nécessite pas de AWS compte et ne dépend d'aucun AWS
service. Toutefois, pour utiliser un porte-clés AWS KMS ECDH, vous devez disposer d'un AWS compte et des autorisations minimales suivantes sur le porte-clés de votre trousseau AWS KMS keys de clés. Les autorisations varient en fonction du schéma d'accord clé que vous utilisez.
-
Pour chiffrer et déchiffrer des données à l'aide du schéma d'accord de KmsPrivateKeyToStaticPublicKey clés, vous avez besoin de kms : GetPublicKey et kms : DeriveSharedSecret sur la paire de clés KMS asymétrique de l'expéditeur. Si vous fournissez directement la clé publique codée DER de l'expéditeur lorsque vous instanciez votre jeu de clés, vous n'avez besoin que de l'DeriveSharedSecretautorisation kms : sur la paire de clés KMS asymétrique de l'expéditeur.
-
Pour déchiffrer des données à l'aide du schéma d'accord de KmsPublicKeyDiscovery clés, vous devez disposer des GetPublicKey autorisations kms : DeriveSharedSecret et kms : sur la paire de clés KMS asymétriques spécifiée.
Création d'un AWS KMS porte-clés ECDH
Pour créer un jeu de clés AWS KMS ECDH qui chiffre et déchiffre les données, vous devez utiliser le schéma d'accord de clés. KmsPrivateKeyToStaticPublicKey Pour initialiser un trousseau de clés AWS KMS ECDH avec le schéma d'accord de KmsPrivateKeyToStaticPublicKey clés, fournissez les valeurs suivantes :
- C# / .NET
-
L'exemple suivant crée un jeu de clés AWS KMS ECDH avec la clé KMS de l'expéditeur, la clé publique de l'expéditeur et la clé publique du destinataire. Cet exemple utilise le SenderPublicKey paramètre facultatif pour fournir la clé publique de l'expéditeur. Si vous ne fournissez pas la clé publique de l'expéditeur, le keyring appelle AWS KMS pour récupérer la clé publique de l'expéditeur. Les paires de clés de l'expéditeur et du destinataire sont toutes deux en ECC_NIST_P256 évolution.
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Must be DER-encoded X.509 public keys
var BobPublicKey = new MemoryStream(new byte[] { });
var AlicePublicKey = new MemoryStream(new byte[] { });
// Create the AWS KMS ECDH static keyring
var staticConfiguration = new KmsEcdhStaticConfigurations
{
KmsPrivateKeyToStaticPublicKey = new KmsPrivateKeyToStaticPublicKeyInput
{
SenderKmsIdentifier = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
SenderPublicKey = BobPublicKey,
RecipientPublicKey = AlicePublicKey
}
};
var createKeyringInput = new CreateAwsKmsEcdhKeyringInput
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KmsClient = new AmazonKeyManagementServiceClient(),
KeyAgreementScheme = staticConfiguration
};
var keyring = materialProviders.CreateAwsKmsEcdhKeyring(createKeyringInput);
- Java
-
L'exemple suivant crée un jeu de clés AWS KMS ECDH avec la clé KMS de l'expéditeur, la clé publique de l'expéditeur et la clé publique du destinataire. Cet exemple utilise le senderPublicKey paramètre facultatif pour fournir la clé publique de l'expéditeur. Si vous ne fournissez pas la clé publique de l'expéditeur, le keyring appelle AWS KMS pour récupérer la clé publique de l'expéditeur. Les paires de clés de l'expéditeur et du destinataire sont toutes deux en ECC_NIST_P256 évolution.
// Retrieve public keys
// Must be DER-encoded X.509 public keys
ByteBuffer BobPublicKey = getPublicKeyBytes("arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab");
ByteBuffer AlicePublicKey = getPublicKeyBytes("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321");
// Create the AWS KMS ECDH static keyring
final CreateAwsKmsEcdhKeyringInput senderKeyringInput =
CreateAwsKmsEcdhKeyringInput.builder()
.kmsClient(KmsClient.create())
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
KmsEcdhStaticConfigurations.builder()
.KmsPrivateKeyToStaticPublicKey(
KmsPrivateKeyToStaticPublicKeyInput.builder()
.senderKmsIdentifier("arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab")
.senderPublicKey(BobPublicKey)
.recipientPublicKey(AlicePublicKey)
.build()).build()).build();
- Python
-
L'exemple suivant crée un jeu de clés AWS KMS ECDH avec la clé KMS de l'expéditeur, la clé publique de l'expéditeur et la clé publique du destinataire. Cet exemple utilise le senderPublicKey paramètre facultatif pour fournir la clé publique de l'expéditeur. Si vous ne fournissez pas la clé publique de l'expéditeur, le keyring appelle AWS KMS pour récupérer la clé publique de l'expéditeur. Les paires de clés de l'expéditeur et du destinataire sont toutes deux en ECC_NIST_P256 évolution.
import boto3
from aws_cryptographic_materialproviders.mpl.models import (
CreateAwsKmsEcdhKeyringInput,
KmsEcdhStaticConfigurationsKmsPrivateKeyToStaticPublicKey,
KmsPrivateKeyToStaticPublicKeyInput,
)
from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec
# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Retrieve public keys
# Must be DER-encoded X.509 public keys
bob_public_key = get_public_key_bytes("arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab")
alice_public_key = get_public_key_bytes("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321")
# Create the AWS KMS ECDH static keyring
sender_keyring_input = CreateAwsKmsEcdhKeyringInput(
kms_client = boto3.client('kms', region_name="us-west-2"),
curve_spec = ECDHCurveSpec.ECC_NIST_P256,
key_agreement_scheme = KmsEcdhStaticConfigurationsKmsPrivateKeyToStaticPublicKey(
KmsPrivateKeyToStaticPublicKeyInput(
sender_kms_identifier = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
sender_public_key = bob_public_key,
recipient_public_key = alice_public_key,
)
)
)
keyring = mat_prov.create_aws_kms_ecdh_keyring(sender_keyring_input)
- Rust
-
L'exemple suivant crée un jeu de clés AWS KMS ECDH avec la clé KMS de l'expéditeur, la clé publique de l'expéditeur et la clé publique du destinataire. Cet exemple utilise le sender_public_key paramètre facultatif pour fournir la clé publique de l'expéditeur. Si vous ne fournissez pas la clé publique de l'expéditeur, le keyring appelle AWS KMS pour récupérer la clé publique de l'expéditeur.
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Create the AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
// Optional: Create your encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Retrieve public keys
// Must be DER-encoded X.509 keys
let public_key_file_content_sender = std::fs::read_to_string(Path::new(EXAMPLE_KMS_ECC_PUBLIC_KEY_FILENAME_SENDER))?;
let parsed_public_key_file_content_sender = parse(public_key_file_content_sender)?;
let public_key_sender_utf8_bytes = parsed_public_key_file_content_sender.contents();
let public_key_file_content_recipient = std::fs::read_to_string(Path::new(EXAMPLE_KMS_ECC_PUBLIC_KEY_FILENAME_RECIPIENT))?;
let parsed_public_key_file_content_recipient = parse(public_key_file_content_recipient)?;
let public_key_recipient_utf8_bytes = parsed_public_key_file_content_recipient.contents();
// Create KmsPrivateKeyToStaticPublicKeyInput
let kms_ecdh_static_configuration_input =
KmsPrivateKeyToStaticPublicKeyInput::builder()
.sender_kms_identifier(arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab)
// Must be a UTF8 DER-encoded X.509 public key
.sender_public_key(public_key_sender_utf8_bytes)
// Must be a UTF8 DER-encoded X.509 public key
.recipient_public_key(public_key_recipient_utf8_bytes)
.build()?;
let kms_ecdh_static_configuration = KmsEcdhStaticConfigurations::KmsPrivateKeyToStaticPublicKey(kms_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 AWS KMS ECDH keyring
let kms_ecdh_keyring = mpl
.create_aws_kms_ecdh_keyring()
.kms_client(kms_client)
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(kms_ecdh_static_configuration)
.send()
.await?;
- Go
-
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/kms"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
o.Region = KmsKeyRegion
})
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Retrieve public keys
// Must be DER-encoded X.509 keys
publicKeySender, err := utils.LoadPublicKeyFromPEM(kmsEccPublicKeyFileNameSender)
if err != nil {
panic(err)
}
publicKeyRecipient, err := utils.LoadPublicKeyFromPEM(kmsEccPublicKeyFileNameRecipient)
if err != nil {
panic(err)
}
// Create KmsPrivateKeyToStaticPublicKeyInput
kmsEcdhStaticConfigurationInput := mpltypes.KmsPrivateKeyToStaticPublicKeyInput{
RecipientPublicKey: publicKeyRecipient,
SenderKmsIdentifier: arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab,
SenderPublicKey: publicKeySender,
}
kmsEcdhStaticConfiguration := &mpltypes.KmsEcdhStaticConfigurationsMemberKmsPrivateKeyToStaticPublicKey{
Value: kmsEcdhStaticConfigurationInput,
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create AWS KMS ECDH keyring
awsKmsEcdhKeyringInput := mpltypes.CreateAwsKmsEcdhKeyringInput{
CurveSpec: ecdhCurveSpec,
KeyAgreementScheme: kmsEcdhStaticConfiguration,
KmsClient: kmsClient,
}
awsKmsEcdhKeyring, err := matProv.CreateAwsKmsEcdhKeyring(context.Background(), awsKmsEcdhKeyringInput)
if err != nil {
panic(err)
}
Création d'un AWS KMS porte-clés de découverte ECDH
Lors du déchiffrement, il est recommandé de spécifier les clés qu'ils peuvent utiliser. AWS Encryption SDK Pour suivre cette bonne pratique, utilisez un porte-clés AWS KMS ECDH avec le schéma d'accord de KmsPrivateKeyToStaticPublicKey clés. Toutefois, vous pouvez également créer un jeu de clés de découverte AWS KMS ECDH, c'est-à-dire un jeu de clés AWS KMS ECDH capable de déchiffrer tout message dont la clé publique de la paire de clés KMS spécifiée correspond à la clé publique du destinataire enregistrée dans le texte chiffré du message.
Lorsque vous déchiffrez des messages à l'aide du schéma d'accord de KmsPublicKeyDiscovery clés, vous acceptez toutes les clés publiques, quel que soit leur propriétaire.
Pour initialiser un trousseau de clés AWS KMS ECDH avec le schéma d'accord de KmsPublicKeyDiscovery clés, fournissez les valeurs suivantes :
-
AWS KMS key ID du destinataire
Doit identifier une paire de clés KMS à courbe elliptique (ECC) asymétrique recommandée par le NIST avec une valeur de. KeyUsage KEY_AGREEMENT
-
Spécification de la courbe
Identifie la spécification de courbe elliptique dans la paire de clés KMS du destinataire.
Valeurs valides: ECC_NIST_P256, ECC_NIS_P384, ECC_NIST_P512
-
(Facultatif) Une liste de jetons de subvention
Si vous contrôlez l'accès à la clé KMS dans votre trousseau de clés AWS KMS ECDH avec des autorisations, vous devez fournir tous les jetons d'autorisation nécessaires lors de l'initialisation du trousseau de clés.
- C# / .NET
-
L'exemple suivant crée un trousseau de clés de découverte AWS KMS ECDH avec une paire de clés KMS sur la ECC_NIST_P256 courbe. Vous devez disposer des DeriveSharedSecret autorisations kms : GetPublicKey et kms : sur la paire de clés KMS spécifiée. Ce porte-clés peut déchiffrer tout message dont la clé publique de la paire de clés KMS spécifiée correspond à la clé publique du destinataire enregistrée dans le texte chiffré du message.
// Instantiate material providers
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());
// Create the AWS KMS ECDH discovery keyring
var discoveryConfiguration = new KmsEcdhStaticConfigurations
{
KmsPublicKeyDiscovery = new KmsPublicKeyDiscoveryInput
{
RecipientKmsIdentifier = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321"
}
};
var createKeyringInput = new CreateAwsKmsEcdhKeyringInput
{
CurveSpec = ECDHCurveSpec.ECC_NIST_P256,
KmsClient = new AmazonKeyManagementServiceClient(),
KeyAgreementScheme = discoveryConfiguration
};
var keyring = materialProviders.CreateAwsKmsEcdhKeyring(createKeyringInput);
- Java
-
L'exemple suivant crée un trousseau de clés de découverte AWS KMS ECDH avec une paire de clés KMS sur la ECC_NIST_P256 courbe. Vous devez disposer des DeriveSharedSecret autorisations kms : GetPublicKey et kms : sur la paire de clés KMS spécifiée. Ce porte-clés peut déchiffrer tout message dont la clé publique de la paire de clés KMS spécifiée correspond à la clé publique du destinataire enregistrée dans le texte chiffré du message.
// Create the AWS KMS ECDH discovery keyring
final CreateAwsKmsEcdhKeyringInput recipientKeyringInput =
CreateAwsKmsEcdhKeyringInput.builder()
.kmsClient(KmsClient.create())
.curveSpec(ECDHCurveSpec.ECC_NIST_P256)
.KeyAgreementScheme(
KmsEcdhStaticConfigurations.builder()
.KmsPublicKeyDiscovery(
KmsPublicKeyDiscoveryInput.builder()
.recipientKmsIdentifier("arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321").build()
).build())
.build();
- Python
-
L'exemple suivant crée un trousseau de clés de découverte AWS KMS ECDH avec une paire de clés KMS sur la ECC_NIST_P256 courbe. Vous devez disposer des DeriveSharedSecret autorisations kms : GetPublicKey et kms : sur la paire de clés KMS spécifiée. Ce porte-clés peut déchiffrer tout message dont la clé publique de la paire de clés KMS spécifiée correspond à la clé publique du destinataire enregistrée dans le texte chiffré du message.
import boto3
from aws_cryptographic_materialproviders.mpl.models import (
CreateAwsKmsEcdhKeyringInput,
KmsEcdhStaticConfigurationsKmsPublicKeyDiscovery,
KmsPublicKeyDiscoveryInput,
)
from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec
# Instantiate the material providers library
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
config=MaterialProvidersConfig()
)
# Create the AWS KMS ECDH discovery keyring
create_keyring_input = CreateAwsKmsEcdhKeyringInput(
kms_client = boto3.client('kms', region_name="us-west-2"),
curve_spec = ECDHCurveSpec.ECC_NIST_P256,
key_agreement_scheme = KmsEcdhStaticConfigurationsKmsPublicKeyDiscovery(
KmsPublicKeyDiscoveryInput(
recipient_kms_identifier = "arn:aws:kms:us-west-2:111122223333:key/0987dcba-09fe-87dc-65ba-ab0987654321",
)
)
)
keyring = mat_prov.create_aws_kms_ecdh_keyring(create_keyring_input)
- Rust
-
// Instantiate the AWS Encryption SDK client
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
// Create the AWS KMS client
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
// Optional: Create your encryption context
let encryption_context = HashMap::from([
("encryption".to_string(), "context".to_string()),
("is not".to_string(), "secret".to_string()),
("but adds".to_string(), "useful metadata".to_string()),
("that can help you".to_string(), "be confident that".to_string()),
("the data you are handling".to_string(), "is what you think it is".to_string()),
]);
// Create KmsPublicKeyDiscoveryInput
let kms_ecdh_discovery_static_configuration_input =
KmsPublicKeyDiscoveryInput::builder()
.recipient_kms_identifier(ecc_recipient_key_arn)
.build()?;
let kms_ecdh_discovery_static_configuration = KmsEcdhStaticConfigurations::KmsPublicKeyDiscovery(kms_ecdh_discovery_static_configuration_input);
// Instantiate the material providers library
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
// Create AWS KMS ECDH discovery keyring
let kms_ecdh_discovery_keyring = mpl
.create_aws_kms_ecdh_keyring()
.kms_client(kms_client.clone())
.curve_spec(ecdh_curve_spec)
.key_agreement_scheme(kms_ecdh_discovery_static_configuration)
.send()
.await?;
- Go
-
import (
"context"
mpl "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygenerated"
mpltypes "aws/aws-cryptographic-material-providers-library/releases/go/mpl/awscryptographymaterialproviderssmithygeneratedtypes"
client "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygenerated"
esdktypes "github.com/aws/aws-encryption-sdk/awscryptographyencryptionsdksmithygeneratedtypes"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/kms"
)
// Instantiate the AWS Encryption SDK client
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{})
if err != nil {
panic(err)
}
// Create an AWS KMS client
cfg, err := config.LoadDefaultConfig(context.TODO())
if err != nil {
panic(err)
}
kmsClient := kms.NewFromConfig(cfg, func(o *kms.Options) {
o.Region = KmsKeyRegion
})
// Optional: Create an encryption context
encryptionContext := map[string]string{
"encryption": "context",
"is not": "secret",
"but adds": "useful metadata",
"that can help you": "be confident that",
"the data you are handling": "is what you think it is",
}
// Create KmsPublicKeyDiscoveryInput
kmsEcdhDiscoveryStaticConfigurationInput := mpltypes.KmsPublicKeyDiscoveryInput{
RecipientKmsIdentifier: eccRecipientKeyArn,
}
kmsEcdhDiscoveryStaticConfiguration := &mpltypes.KmsEcdhStaticConfigurationsMemberKmsPublicKeyDiscovery{
Value: kmsEcdhDiscoveryStaticConfigurationInput,
}
// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
panic(err)
}
// Create AWS KMS ECDH discovery keyring
awsKmsEcdhDiscoveryKeyringInput := mpltypes.CreateAwsKmsEcdhKeyringInput{
CurveSpec: ecdhCurveSpec,
KeyAgreementScheme: kmsEcdhDiscoveryStaticConfiguration,
KmsClient: kmsClient,
}
awsKmsEcdhDiscoveryKeyring, err := matProv.CreateAwsKmsEcdhKeyring(context.Background(), awsKmsEcdhDiscoveryKeyringInput)
if err != nil {
panic(err)
}
