Menetapkan kebijakan komitmen Anda

Dimulai pada versi 1.7. x dari AWS Encryption SDK for C, Anda menggunakan aws_cryptosdk_session_set_commitment_policy fungsi untuk mengatur kebijakan komitmen pada sesi enkripsi dan dekripsi Anda. Kebijakan komitmen yang Anda tetapkan berlaku untuk semua operasi enkripsi dan dekripsi yang dipanggil pada sesi tersebut.

aws_cryptosdk_session_new_from_cmmFungsi aws_cryptosdk_session_new_from_keyring dan tidak digunakan lagi di versi 1.7. x dan dihapus dalam versi 2.0. x. Fungsi-fungsi ini digantikan oleh aws_cryptosdk_session_new_from_keyring_2 dan aws_cryptosdk_session_new_from_cmm_2 fungsi yang mengembalikan sesi.

Saat Anda menggunakan aws_cryptosdk_session_new_from_keyring_2 dan aws_cryptosdk_session_new_from_cmm_2 yang terbaru 1. x versi, Anda diminta untuk memanggil aws_cryptosdk_session_set_commitment_policy fungsi dengan nilai kebijakan COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT komitmen. Dalam versi 2.0. x dan yang lebih baru, memanggil fungsi ini adalah opsional dan dibutuhkan semua nilai yang valid. Kebijakan komitmen default untuk versi 2.0. x dan yang lebih COMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT baru

Untuk contoh lengkap, lihat string.cpp.

/* Load error strings for debugging */
aws_cryptosdk_load_error_strings();

/* Create an AWS KMS keyring */
const char * key_arn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";
struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);

/* Create an encrypt session with a CommitmentPolicy setting */
struct aws_cryptosdk_session *encrypt_session = aws_cryptosdk_session_new_from_keyring_2(
    alloc, AWS_CRYPTOSDK_ENCRYPT, kms_keyring);

aws_cryptosdk_keyring_release(kms_keyring);
aws_cryptosdk_session_set_commitment_policy(encrypt_session,
    COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT);

...
/* Encrypt your data */

size_t plaintext_consumed_output;
aws_cryptosdk_session_process(encrypt_session,
                              ciphertext_output,
                              ciphertext_buf_sz_output,
                              ciphertext_len_output,
                              plaintext_input,
                              plaintext_len_input,
                              &plaintext_consumed_output)
...

/* Create a decrypt session with a CommitmentPolicy setting */

struct aws_cryptosdk_keyring *kms_keyring = Aws::Cryptosdk::KmsKeyring::Builder().Build(key_arn);
struct aws_cryptosdk_session *decrypt_session = *aws_cryptosdk_session_new_from_keyring_2(
        alloc, AWS_CRYPTOSDK_DECRYPT, kms_keyring);
aws_cryptosdk_keyring_release(kms_keyring);
aws_cryptosdk_session_set_commitment_policy(decrypt_session,
        COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT);

/* Decrypt your ciphertext */
size_t ciphertext_consumed_output;
aws_cryptosdk_session_process(decrypt_session,
                              plaintext_output,
                              plaintext_buf_sz_output,
                              plaintext_len_output,
                              ciphertext_input,
                              ciphertext_len_input,
                              &ciphertext_consumed_output)

require-encrypt-require-decryptNilai adalah kebijakan komitmen default di semua versi AWS Encryption SDK untuk .NET. Anda dapat mengaturnya secara eksplisit sebagai praktik terbaik, tetapi itu tidak diperlukan. Namun, jika Anda menggunakan AWS Encryption SDK untuk.NET untuk mendekripsi ciphertext yang dienkripsi oleh implementasi bahasa lain dari komitmen AWS Encryption SDK tanpa kunci, Anda perlu mengubah nilai kebijakan komitmen menjadi atau. REQUIRE_ENCRYPT_ALLOW_DECRYPT FORBID_ENCRYPT_ALLOW_DECRYPT Jika tidak, upaya untuk mendekripsi ciphertext akan gagal.

Dalam AWS Encryption SDK untuk .NET, Anda menetapkan kebijakan komitmen pada instance AWS Encryption SDK. Buat instance AwsEncryptionSdkConfig objek dengan CommitmentPolicy parameter, dan gunakan objek konfigurasi untuk membuat instance. AWS Encryption SDK Kemudian, panggil Encrypt() dan Decrypt() metode dari AWS Encryption SDK instance yang dikonfigurasi.

Contoh ini menetapkan kebijakan komitmen untukrequire-encrypt-allow-decrypt.

// Instantiate the material providers
var materialProviders =
    AwsCryptographicMaterialProvidersFactory.CreateDefaultAwsCryptographicMaterialProviders();

// Configure the commitment policy on the AWS Encryption SDK instance
var config = new AwsEncryptionSdkConfig
{
    CommitmentPolicy = CommitmentPolicy.REQUIRE_ENCRYPT_ALLOW_DECRYPT
};
var encryptionSdk = AwsEncryptionSdkFactory.CreateAwsEncryptionSdk(config);

string keyArn = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";

var encryptionContext = new Dictionary<string, string>()
{
    {"purpose", "test"}encryptionSdk
};

var createKeyringInput = new CreateAwsKmsKeyringInput
{
    KmsClient = new AmazonKeyManagementServiceClient(),
    KmsKeyId = keyArn
};
var keyring = materialProviders.CreateAwsKmsKeyring(createKeyringInput);

// Encrypt your plaintext data
var encryptInput = new EncryptInput
{
    Plaintext = plaintext,
    Keyring = keyring,
    EncryptionContext = encryptionContext
};
var encryptOutput = encryptionSdk.Encrypt(encryptInput);

// Decrypt your ciphertext
var decryptInput = new DecryptInput
{
    Ciphertext = ciphertext,
    Keyring = keyring
};
var decryptOutput = encryptionSdk.Decrypt(decryptInput);

Untuk menetapkan kebijakan komitmen dalam CLI AWS Enkripsi, gunakan parameter. --commitment-policy Parameter ini diperkenalkan dalam versi 1.8. x.

Yang terbaru 1. versi x, ketika Anda menggunakan --wrapping-keys parameter dalam --decrypt perintah --encrypt atau, --commitment-policy parameter dengan forbid-encrypt-allow-decrypt nilai diperlukan. Jika tidak, --commitment-policy parameternya tidak valid.

Dalam versi 2.1. x dan yang lebih baru, --commitment-policy parameternya opsional dan default ke require-encrypt-require-decrypt nilai, yang tidak akan mengenkripsi atau mendekripsi ciphertext apa pun yang dienkripsi tanpa komitmen kunci. Namun, kami menyarankan agar Anda menetapkan kebijakan komitmen secara eksplisit di semua panggilan enkripsi dan dekripsi untuk membantu pemeliharaan dan pemecahan masalah.

Contoh ini menetapkan kebijakan komitmen. Ini juga menggunakan --wrapping-keys parameter yang menggantikan --master-keys parameter yang dimulai pada versi 1.8. x. Untuk detailnya, lihat Memperbarui penyedia kunci AWS KMS utama. Untuk contoh lengkap, lihatContoh CLI AWS Enkripsi.

\\ To run this example, replace the fictitious key ARN with a valid value. 
$ keyArn=arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab

\\ Encrypt your plaintext data - no change to algorithm suite used
$ aws-encryption-cli --encrypt \
                     --input hello.txt \
                     --wrapping-keys key=$keyArn \
                     --commitment-policy forbid-encrypt-allow-decrypt \
                     --metadata-output ~/metadata \
                     --encryption-context purpose=test \
                     --output .

\\ Decrypt your ciphertext - supports key commitment on 1.7 and later
$ aws-encryption-cli --decrypt \
                     --input hello.txt.encrypted \
                     --wrapping-keys key=$keyArn \
                     --commitment-policy forbid-encrypt-allow-decrypt \
                     --encryption-context purpose=test \
                     --metadata-output ~/metadata \
                     --output .

Dimulai pada versi 1.7. x dari AWS Encryption SDK for Java, Anda menetapkan kebijakan komitmen pada instance AndaAwsCrypto, objek yang mewakili AWS Encryption SDK klien. Pengaturan kebijakan komitmen ini berlaku untuk semua operasi enkripsi dan dekripsi yang dipanggil pada klien tersebut.

AwsCrypto()Konstruktor tidak digunakan lagi di 1 terbaru. x versi AWS Encryption SDK for Java dan dihapus dalam versi 2.0. x. Ini digantikan oleh Builder kelas baru, Builder.withCommitmentPolicy() metode, dan tipe CommitmentPolicy enumerasi.

Yang terbaru 1. x versi, Builder kelas membutuhkan Builder.withCommitmentPolicy() metode dan CommitmentPolicy.ForbidEncryptAllowDecrypt argumen. Dimulai pada versi 2.0. x, Builder.withCommitmentPolicy() metode ini opsional; nilai defaultnya adalahCommitmentPolicy.RequireEncryptRequireDecrypt.

Untuk contoh lengkap, lihat SetCommitmentPolicyExample.java.

// Instantiate the client
final AwsCrypto crypto = AwsCrypto.builder()
    .withCommitmentPolicy(CommitmentPolicy.ForbidEncryptAllowDecrypt)
    .build();

// Create a master key provider in strict mode
String awsKmsKey = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab";

KmsMasterKeyProvider masterKeyProvider = KmsMasterKeyProvider.builder()
    .buildStrict(awsKmsKey);

// Encrypt your plaintext data
CryptoResult<byte[], KmsMasterKey> encryptResult = crypto.encryptData(
    masterKeyProvider,
    sourcePlaintext,
    encryptionContext);
byte[] ciphertext = encryptResult.getResult();

// Decrypt your ciphertext
CryptoResult<byte[], KmsMasterKey> decryptResult = crypto.decryptData(
        masterKeyProvider,
        ciphertext);
byte[] decrypted = decryptResult.getResult();

Dimulai pada versi 1.7. x dari AWS Encryption SDK for JavaScript, Anda dapat mengatur kebijakan komitmen ketika Anda memanggil buildClient fungsi baru yang membuat instance AWS Encryption SDK klien. buildClientFungsi ini mengambil nilai yang disebutkan yang mewakili kebijakan komitmen Anda. Ini mengembalikan decrypt fungsi yang diperbarui encrypt dan yang menegakkan kebijakan komitmen Anda saat Anda mengenkripsi dan mendekripsi.

Yang terbaru 1. x versi, buildClient fungsi membutuhkan CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT argumen. Dimulai pada versi 2.0. x, argumen kebijakan komitmen adalah opsional dan nilai defaultnya adalahCommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT.

Kode untuk Node.js dan browser identik untuk tujuan ini, kecuali bahwa browser membutuhkan pernyataan untuk mengatur kredensialnya.

Contoh berikut mengenkripsi data dengan keyring. AWS KMS buildClientFungsi baru menetapkan kebijakan komitmen keFORBID_ENCRYPT_ALLOW_DECRYPT, nilai default di 1 terbaru. x versin. Upgrade encrypt dan decrypt fungsi yang buildClient dikembalikan menegakkan kebijakan komitmen yang Anda tetapkan.

import { buildClient } from '@aws-crypto/client-node'
const { encrypt, decrypt } = buildClient(CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT)

// Create an AWS KMS keyring
const generatorKeyId = 'arn:aws:kms:us-west-2:111122223333:alias/ExampleAlias'
const keyIds = ['arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab']
const keyring = new KmsKeyringNode({ generatorKeyId, keyIds })

// Encrypt your plaintext data
const { ciphertext } = await encrypt(keyring, plaintext, { encryptionContext: context })

// Decrypt your ciphertext
const { decrypted, messageHeader } = await decrypt(keyring, ciphertext)

Dimulai pada versi 1.7. x dari AWS Encryption SDK for Python, Anda menetapkan kebijakan komitmen pada instance AndaEncryptionSDKClient, objek baru yang mewakili AWS Encryption SDK klien. Kebijakan komitmen yang Anda tetapkan berlaku untuk semua encrypt dan decrypt panggilan yang menggunakan instance klien tersebut.

Yang terbaru 1. x versi, EncryptionSDKClient konstruktor membutuhkan nilai yang CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT disebutkan. Dimulai pada versi 2.0. x, argumen kebijakan komitmen adalah opsional dan nilai defaultnya adalahCommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT.

Contoh ini menggunakan EncryptionSDKClient konstruktor baru dan menetapkan kebijakan komitmen ke 1.7. x nilai default. Konstruktor membuat instance klien yang mewakili. AWS Encryption SDK Ketika Anda memanggilencrypt,decrypt, atau stream metode pada klien ini, mereka menegakkan kebijakan komitmen yang Anda tetapkan. Contoh ini juga menggunakan konstruktor baru untuk StrictAwsKmsMasterKeyProvider kelas, yang menentukan AWS KMS keys saat mengenkripsi dan mendekripsi.

Untuk contoh lengkap, lihat set_commitment.py.

# Instantiate the client
client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT)

// Create a master key provider in strict mode
aws_kms_key = "arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
aws_kms_strict_master_key_provider = StrictAwsKmsMasterKeyProvider(
        key_ids=[aws_kms_key]
)

# Encrypt your plaintext data
ciphertext, encrypt_header = client.encrypt(
        source=source_plaintext,
        encryption_context=encryption_context,
        master_key_provider=aws_kms_strict_master_key_provider
)

# Decrypt your ciphertext
decrypted, decrypt_header = client.decrypt(
        source=ciphertext,
        master_key_provider=aws_kms_strict_master_key_provider
)

require-encrypt-require-decryptNilainya adalah kebijakan komitmen default di semua versi AWS Encryption SDK untuk Rust. Anda dapat mengaturnya secara eksplisit sebagai praktik terbaik, tetapi itu tidak diperlukan. Namun, jika Anda menggunakan AWS Encryption SDK for Rust untuk mendekripsi ciphertext yang dienkripsi oleh implementasi bahasa lain dari komitmen AWS Encryption SDK tanpa kunci, Anda perlu mengubah nilai kebijakan komitmen menjadi atau. REQUIRE_ENCRYPT_ALLOW_DECRYPT FORBID_ENCRYPT_ALLOW_DECRYPT Jika tidak, upaya untuk mendekripsi ciphertext akan gagal.

Dalam AWS Encryption SDK for Rust, Anda menetapkan kebijakan komitmen pada instance AWS Encryption SDK. Buat instance AwsEncryptionSdkConfig objek dengan comitment_policy parameter, dan gunakan objek konfigurasi untuk membuat instance. AWS Encryption SDK Kemudian, panggil Encrypt() dan Decrypt() metode dari AWS Encryption SDK instance yang dikonfigurasi.

Contoh ini menetapkan kebijakan komitmen untukforbid-encrypt-allow-decrypt.

// Configure the commitment policy on the AWS Encryption SDK instance
let esdk_config = AwsEncryptionSdkConfig::builder()
                    .commitment_policy(ForbidEncryptAllowDecrypt)
                    .build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;

// Create an 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);

// 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()),
]);

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

// Create an AWS KMS keyring
let kms_keyring = mpl
    .create_aws_kms_keyring()
    .kms_key_id(kms_key_id)
    .kms_client(kms_client)
    .send()
    .await?;

// Encrypt your plaintext data
let plaintext = example_data.as_bytes();

let encryption_response = esdk_client.encrypt()
    .plaintext(plaintext)
    .keyring(kms_keyring.clone())
    .encryption_context(encryption_context.clone())
    .send()
    .await?;

// Decrypt your ciphertext
let decryption_response = esdk_client.decrypt()
    .ciphertext(ciphertext)
    .keyring(kms_keyring)
    // Provide the encryption context that was supplied to the encrypt method
    .encryption_context(encryption_context)
    .send()
    .await?;

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
commitPolicyForbidEncryptAllowDecrypt := mpltypes.ESDKCommitmentPolicyForbidEncryptAllowDecrypt
encryptionClient, err := client.NewClient(esdktypes.AwsEncryptionSdkConfig{CommitmentPolicy: &commitPolicyForbidEncryptAllowDecrypt})
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",
}

// Instantiate the material providers library
matProv, err := mpl.NewClient(mpltypes.MaterialProvidersConfig{})
if err != nil {
    panic(err)
}

// Create an AWS KMS keyring
awsKmsKeyringInput := mpltypes.CreateAwsKmsKeyringInput{
    KmsClient: kmsClient,
    KmsKeyId:  kmsKeyId,
}
awsKmsKeyring, err := matProv.CreateAwsKmsKeyring(context.Background(), awsKmsKeyringInput)
if err != nil {
    panic(err)
}

// Encrypt your plaintext data
res, err := forbidEncryptClient.Encrypt(context.Background(), esdktypes.EncryptInput{
    Plaintext:         []byte(exampleText),
    EncryptionContext: encryptionContext,
    Keyring:           awsKmsKeyring,
})
if err != nil {
    panic(err)
}

// Decrypt your ciphertext
decryptOutput, err := forbidEncryptClient.Decrypt(context.Background(), esdktypes.DecryptInput{
    Ciphertext:        res.Ciphertext,
    EncryptionContext: encryptionContext,
    Keyring:           awsKmsKeyring,
})
if err != nil {
    panic(err)
}