Gantungan kunci ECDH mentah - AWS Encryption SDK

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Gantungan kunci ECDH mentah

Raw ECDH keyring menggunakan kurva elips pasangan kunci publik-pribadi yang Anda berikan untuk mendapatkan kunci pembungkus bersama antara dua pihak. Pertama, keyring memperoleh rahasia bersama menggunakan kunci pribadi pengirim, kunci publik penerima, dan algoritma perjanjian kunci Elliptic Curve Diffie-Hellman (ECDH). Kemudian, keyring menggunakan rahasia bersama untuk mendapatkan kunci pembungkus bersama yang melindungi kunci enkripsi data Anda. Fungsi derivasi kunci yang AWS Encryption SDK digunakan (KDF_CTR_HMAC_SHA384) untuk menurunkan kunci pembungkus bersama sesuai dengan rekomendasi NIST untuk derivasi kunci.

Fungsi derivasi kunci mengembalikan 64 byte bahan kunci. Untuk memastikan bahwa kedua belah pihak menggunakan materi kunci yang benar, AWS Encryption SDK menggunakan 32 byte pertama sebagai kunci komitmen dan 32 byte terakhir sebagai kunci pembungkus bersama. Saat mendekripsi, jika keyring tidak dapat mereproduksi kunci komitmen yang sama dan kunci pembungkus bersama yang disimpan di ciphertext header pesan, operasi gagal. Misalnya, jika Anda mengenkripsi data dengan keyring yang dikonfigurasi dengan kunci pribadi Alice dan kunci publik Bob, keyring yang dikonfigurasi dengan kunci pribadi Bob dan kunci publik Alice akan mereproduksi kunci komitmen yang sama dan kunci pembungkus bersama dan dapat mendekripsi data. Jika kunci publik Bob berasal dari AWS KMS key pasangan, maka Bob dapat membuat keyring AWS KMS ECDH untuk mendekripsi data.

Raw ECDH keyring mengenkripsi data dengan kunci simetris menggunakan AES-GCM. Kunci data kemudian dienkripsi dengan kunci pembungkus bersama turunan menggunakan AES-GCM. Setiap keyring ECDH mentah hanya dapat memiliki satu kunci pembungkus bersama, tetapi Anda dapat menyertakan beberapa gantungan kunci ECDH mentah, sendiri atau dengan gantungan kunci lainnya, dalam multi-keyring.

Anda bertanggung jawab untuk membuat, menyimpan, dan melindungi kunci pribadi Anda, sebaiknya dalam modul keamanan perangkat keras (HSM) atau sistem manajemen kunci. Pasangan kunci pengirim dan penerima banyak berada pada kurva elips yang sama. AWS Encryption SDK Mendukung spesifikasi kurva elips berikut:

  • ECC_NIST_P256

  • ECC_NIST_P384

  • ECC_NIST_P512

Kompatibilitas bahasa pemrograman

Raw ECDH keyring diperkenalkan dalam versi 1.5.0 dari Cryptographic Material Providers Library (MPL) dan didukung oleh bahasa dan versi pemrograman berikut:

  • Versi 3. x dari AWS Encryption SDK for Java

  • Versi 4. x dari AWS Encryption SDK untuk .NET

  • Versi 4. x dari AWS Encryption SDK for Python, bila digunakan dengan dependensi MPL opsional.

  • Versi 1. x dari AWS Encryption SDK untuk Rust

  • Versi 0.1. x atau yang lebih baru AWS Encryption SDK untuk Go

Membuat keyring ECDH mentah

Raw ECDH keyring mendukung tiga skema perjanjian utama:RawPrivateKeyToStaticPublicKey,, dan. EphemeralPrivateKeyToStaticPublicKey PublicKeyDiscovery Skema perjanjian utama yang Anda pilih menentukan operasi kriptografi mana yang dapat Anda lakukan dan bagaimana bahan kunci dirakit.

RawPrivateKeyToStaticPublicKey

Gunakan skema perjanjian RawPrivateKeyToStaticPublicKey kunci untuk mengonfigurasi kunci pribadi pengirim dan kunci publik penerima secara statis di keyring. Skema perjanjian kunci ini dapat mengenkripsi dan mendekripsi data.

Untuk menginisialisasi keyring ECDH mentah dengan skema perjanjian RawPrivateKeyToStaticPublicKey kunci, berikan nilai-nilai berikut:

C# / .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

Contoh Java berikut menggunakan skema perjanjian RawPrivateKeyToStaticPublicKey kunci untuk secara statis mengkonfigurasi kunci pribadi pengirim dan kunci publik penerima. Kedua pasangan kunci berada di ECC_NIST_P256 kurva.

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); }
Python

Contoh Python berikut menggunakan skema perjanjian RawEcdhStaticConfigurationsRawPrivateKeyToStaticPublicKey kunci untuk secara statis mengkonfigurasi kunci pribadi pengirim dan kunci publik penerima. Kedua pasangan kunci berada di ECC_NIST_P256 kurva.

import boto3 from aws_cryptographic_materialproviders.mpl.models import ( CreateRawEcdhKeyringInput, RawEcdhStaticConfigurationsRawPrivateKeyToStaticPublicKey, RawPrivateKeyToStaticPublicKeyInput, ) from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec # Instantiate the material providers library mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders( config=MaterialProvidersConfig() ) # Must be a PEM-encoded private key bob_private_key = get_private_key_bytes() # Must be a DER-encoded X.509 public key alice_public_key = get_public_key_bytes() # Create the raw ECDH static keyring raw_keyring_input = CreateRawEcdhKeyringInput( curve_spec = ECDHCurveSpec.ECC_NIST_P256, key_agreement_scheme = RawEcdhStaticConfigurationsRawPrivateKeyToStaticPublicKey( RawPrivateKeyToStaticPublicKeyInput( sender_static_private_key = bob_private_key, recipient_public_key = alice_public_key, ) ) ) keyring = mat_prov.create_raw_ecdh_keyring(raw_keyring_input)
Rust

Contoh Python berikut menggunakan skema perjanjian raw_ecdh_static_configuration kunci untuk secara statis mengkonfigurasi kunci pribadi pengirim dan kunci publik penerima. Kedua pasangan kunci harus berada pada kurva yang sama.

// Instantiate the AWS Encryption SDK client let esdk_config = AwsEncryptionSdkConfig::builder().build()?; let esdk_client = esdk_client::Client::from_conf(esdk_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 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?;
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" ) // Instantiate the AWS Encryption SDK client encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{}) if err != nil { panic(err) } // Optional: Create your 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 keyring input rawEcdhStaticConfigurationInput := mpltypes.RawPrivateKeyToStaticPublicKeyInput{ SenderStaticPrivateKey: privateKeySender, RecipientPublicKey: publicKeyRecipient, } rawECDHStaticConfiguration := &mpltypes.RawEcdhStaticConfigurationsMemberRawPrivateKeyToStaticPublicKey{ Value: rawEcdhStaticConfigurationInput, } rawEcdhKeyRingInput := mpltypes.CreateRawEcdhKeyringInput{ CurveSpec: ecdhCurveSpec, KeyAgreementScheme: rawECDHStaticConfiguration, } // Instantiate the material providers library matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{}) if err != nil { panic(err) } // Create raw ECDH static keyring rawEcdhKeyring, err := matProv.CreateRawEcdhKeyring(context.Background(), rawEcdhKeyRingInput) if err != nil { panic(err) }

EphemeralPrivateKeyToStaticPublicKey

Keyrings yang dikonfigurasi dengan skema perjanjian EphemeralPrivateKeyToStaticPublicKey kunci membuat key pair baru secara lokal dan mendapatkan kunci pembungkus bersama yang unik untuk setiap panggilan enkripsi.

Skema perjanjian kunci ini hanya dapat mengenkripsi pesan. Untuk mendekripsi pesan yang dienkripsi dengan skema perjanjian EphemeralPrivateKeyToStaticPublicKey kunci, Anda harus menggunakan skema perjanjian kunci penemuan yang dikonfigurasi dengan kunci publik penerima yang sama. Untuk mendekripsi, Anda dapat menggunakan keyring ECDH mentah dengan algoritma perjanjian PublicKeyDiscoverykunci, atau, jika kunci publik penerima berasal dari key pair KMS perjanjian kunci asimetris, Anda dapat menggunakan keyring AWS KMS ECDH dengan skema perjanjian kunci. KmsPublicKeyDiscovery

Untuk menginisialisasi keyring ECDH mentah dengan skema perjanjian EphemeralPrivateKeyToStaticPublicKey kunci, berikan nilai-nilai berikut:

C# / .NET

Contoh berikut membuat keyring ECDH mentah dengan skema perjanjian EphemeralPrivateKeyToStaticPublicKey kunci. Pada enkripsi, keyring akan membuat key pair baru secara lokal pada kurva yang ditentukan. 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

Contoh berikut membuat keyring ECDH mentah dengan skema perjanjian EphemeralPrivateKeyToStaticPublicKey kunci. Pada enkripsi, keyring akan membuat key pair baru secara lokal pada kurva yang ditentukan. 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); }
Python

Contoh berikut membuat keyring ECDH mentah dengan skema perjanjian RawEcdhStaticConfigurationsEphemeralPrivateKeyToStaticPublicKey kunci. Pada enkripsi, keyring akan membuat key pair baru secara lokal pada kurva yang ditentukan. ECC_NIST_P256

import boto3 from aws_cryptographic_materialproviders.mpl.models import ( CreateRawEcdhKeyringInput, RawEcdhStaticConfigurationsEphemeralPrivateKeyToStaticPublicKey, EphemeralPrivateKeyToStaticPublicKeyInput, ) from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec # Instantiate the material providers library mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders( config=MaterialProvidersConfig() ) # Your get_public_key_bytes must return a DER-encoded X.509 public key recipient_public_key = get_public_key_bytes() # Create the raw ECDH ephemeral private key keyring ephemeral_input = CreateRawEcdhKeyringInput( curve_spec = ECDHCurveSpec.ECC_NIST_P256, key_agreement_scheme = RawEcdhStaticConfigurationsEphemeralPrivateKeyToStaticPublicKey( EphemeralPrivateKeyToStaticPublicKeyInput( recipient_public_key = recipient_public_key, ) ) ) keyring = mat_prov.create_raw_ecdh_keyring(ephemeral_input)
Rust

Contoh berikut membuat keyring ECDH mentah dengan skema perjanjian ephemeral_raw_ecdh_static_configuration kunci. Pada enkripsi, keyring akan membuat key pair baru secara lokal pada kurva yang ditentukan.

// Instantiate the AWS Encryption SDK client let esdk_config = AwsEncryptionSdkConfig::builder().build()?; let esdk_client = esdk_client::Client::from_conf(esdk_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()), ]); // Load public key from UTF-8 encoded PEM files into a DER encoded public key. let public_key_file_content = std::fs::read_to_string(Path::new(EXAMPLE_ECC_PUBLIC_KEY_FILENAME_RECIPIENT))?; let parsed_public_key_file_content = parse(public_key_file_content)?; let public_key_recipient_utf8_bytes = parsed_public_key_file_content.contents(); // 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?;
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" ) // Instantiate the AWS Encryption SDK client encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{}) if err != nil { panic(err) } // Optional: Create your 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", } // Load public key from UTF-8 encoded PEM files into a DER encoded public key publicKeyRecipient, err := LoadPublicKeyFromPEM(eccPublicKeyFileNameRecipient) if err != nil { panic(err) } // Create EphemeralPrivateKeyToStaticPublicKeyInput ephemeralRawEcdhStaticConfigurationInput := mpltypes.EphemeralPrivateKeyToStaticPublicKeyInput{ RecipientPublicKey: publicKeyRecipient, } ephemeralRawECDHStaticConfiguration := mpltypes.RawEcdhStaticConfigurationsMemberEphemeralPrivateKeyToStaticPublicKey{ Value: ephemeralRawEcdhStaticConfigurationInput, } // Instantiate the material providers library matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{}) if err != nil { panic(err) } // Create raw ECDH ephemeral private key keyring rawEcdhKeyRingInput := mpltypes.CreateRawEcdhKeyringInput{ CurveSpec: ecdhCurveSpec, KeyAgreementScheme: &ephemeralRawECDHStaticConfiguration, } ecdhKeyring, err := matProv.CreateRawEcdhKeyring(context.Background(), rawEcdhKeyRingInput) if err != nil { panic(err) }

PublicKeyDiscovery

Saat mendekripsi, ini adalah praktik terbaik untuk menentukan kunci pembungkus yang dapat digunakan. AWS Encryption SDK Untuk mengikuti praktik terbaik ini, gunakan keyring ECDH yang menentukan kunci pribadi pengirim dan kunci publik penerima. Namun, Anda juga dapat membuat keyring penemuan ECDH mentah, yaitu keyring ECDH mentah yang dapat mendekripsi pesan apa pun di mana kunci publik kunci yang ditentukan cocok dengan kunci publik penerima yang disimpan pada ciphertext pesan. Skema perjanjian kunci ini hanya dapat mendekripsi pesan.

penting

Ketika Anda mendekripsi pesan menggunakan skema perjanjian PublicKeyDiscovery kunci, Anda menerima semua kunci publik, terlepas dari siapa yang memilikinya.

Untuk menginisialisasi keyring ECDH mentah dengan skema perjanjian PublicKeyDiscovery kunci, berikan nilai-nilai berikut:

C# / .NET

Contoh berikut membuat keyring ECDH mentah dengan skema perjanjian PublicKeyDiscovery kunci. Keyring ini dapat mendekripsi pesan apa pun di mana kunci publik dari kunci pribadi yang ditentukan cocok dengan kunci publik penerima yang disimpan pada ciphertext pesan.

// 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

Contoh berikut membuat keyring ECDH mentah dengan skema perjanjian PublicKeyDiscovery kunci. Keyring ini dapat mendekripsi pesan apa pun di mana kunci publik dari kunci pribadi yang ditentukan cocok dengan kunci publik penerima yang disimpan pada ciphertext pesan.

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); }
Python

Contoh berikut membuat keyring ECDH mentah dengan skema perjanjian RawEcdhStaticConfigurationsPublicKeyDiscovery kunci. Keyring ini dapat mendekripsi pesan apa pun di mana kunci publik dari kunci pribadi yang ditentukan cocok dengan kunci publik penerima yang disimpan pada ciphertext pesan.

import boto3 from aws_cryptographic_materialproviders.mpl.models import ( CreateRawEcdhKeyringInput, RawEcdhStaticConfigurationsPublicKeyDiscovery, PublicKeyDiscoveryInput, ) from aws_cryptography_primitives.smithygenerated.aws_cryptography_primitives.models import ECDHCurveSpec # Instantiate the material providers library mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders( config=MaterialProvidersConfig() ) # Your get_private_key_bytes must return a PEM-encoded private key recipient_private_key = get_private_key_bytes() # Create the raw ECDH discovery keyring raw_keyring_input = CreateRawEcdhKeyringInput( curve_spec = ECDHCurveSpec.ECC_NIST_P256, key_agreement_scheme = RawEcdhStaticConfigurationsPublicKeyDiscovery( PublicKeyDiscoveryInput( recipient_static_private_key = recipient_private_key, ) ) ) keyring = mat_prov.create_raw_ecdh_keyring(raw_keyring_input)
Rust

Contoh berikut membuat keyring ECDH mentah dengan skema perjanjian discovery_raw_ecdh_static_configuration kunci. Keyring ini dapat mendekripsi pesan apa pun di mana kunci publik dari kunci pribadi yang ditentukan cocok dengan kunci publik penerima yang disimpan pada ciphertext pesan.

// Instantiate the AWS Encryption SDK client and material providers library let esdk_config = AwsEncryptionSdkConfig::builder().build()?; let esdk_client = esdk_client::Client::from_conf(esdk_config)?; let mpl_config = MaterialProvidersConfig::builder().build()?; let mpl = mpl_client::Client::from_conf(mpl_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()), ]); // Load keys from UTF-8 encoded PEM files. let mut file = File::open(Path::new(EXAMPLE_ECC_PRIVATE_KEY_FILENAME_RECIPIENT))?; let mut private_key_recipient_utf8_bytes = Vec::new(); file.read_to_end(&mut private_key_recipient_utf8_bytes)?; // 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?;
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" ) // Instantiate the AWS Encryption SDK client encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{}) if err != nil { panic(err) } // Optional: Create your 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", } // Load keys from UTF-8 encoded PEM files. privateKeyRecipient, err := os.ReadFile(eccPrivateKeyFileNameRecipient) if err != nil { panic(err) } // Instantiate the material providers library matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{}) if err != nil { panic(err) } // Create PublicKeyDiscoveryInput discoveryRawEcdhStaticConfigurationInput := mpltypes.PublicKeyDiscoveryInput{ RecipientStaticPrivateKey: privateKeyRecipient, } discoveryRawEcdhStaticConfiguration := &mpltypes.RawEcdhStaticConfigurationsMemberPublicKeyDiscovery{ Value: discoveryRawEcdhStaticConfigurationInput, } // Create raw ECDH discovery private key keyring discoveryRawEcdhKeyringInput := mpltypes.CreateRawEcdhKeyringInput{ CurveSpec: ecdhCurveSpec, KeyAgreementScheme: discoveryRawEcdhStaticConfiguration, } discoveryRawEcdhKeyring, err := matProv.CreateRawEcdhKeyring(context.Background(), discoveryRawEcdhKeyringInput) if err != nil { panic(err) }