Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Establecer su política de compromiso
El [compromiso clave](concepts.md#key-commitment) garantiza que sus datos cifrados siempre se descifren en el mismo texto no cifrado. Para proporcionar esta propiedad de seguridad, a partir de la versión 1.7. *x*, AWS Encryption SDK utiliza nuevos [conjuntos de algoritmos](supported-algorithms.md) con un compromiso clave. Para determinar si sus datos están cifrados y descifrados con un compromiso clave, utilice la opción de configuración de la [política de compromiso](concepts.md#commitment-policy). [Cifrar y descifrar los datos con un compromiso clave es una AWS Encryption SDK práctica recomendada.](best-practices.md)
Establecer una política de compromiso es una parte importante del segundo paso del proceso de migración: migrar desde la última versión. *x* versiones de las dos AWS Encryption SDK versiones 2.0. *x* y versiones posteriores. Tras configurar y cambiar la política de compromiso, asegúrese de probar minuciosamente la aplicación antes de implementarla en producción. Para obtener orientación sobre la migración, consulte[¿Cómo migrar e implementar el AWS Encryption SDK](migration-guide.md).
La configuración de la política de compromiso tiene tres valores válidos en las versiones 2.0.*x* y versiones posteriores. En las últimas versiones 1.*x* (empezando por la versión 1.7.*x*), solo `ForbidEncryptAllowDecrypt` es válida.
+ `ForbidEncryptAllowDecrypt`— AWS Encryption SDK No se puede cifrar con un compromiso de clave. Puede descifrar textos cifrados, cifrados con o sin compromiso clave.
En las últimas versiones 1.*x*, este es el único valor válido. Garantiza que no se cifre con compromiso clave hasta que esté totalmente preparado para descifrar con compromiso clave. Si se establece este valor de forma explícita, se evita que la política de compromiso se modifique automáticamente a `require-encrypt-require-decrypt` cuando actualice su versión a la versión 2.0.*x* o posterior. En su lugar, puede [migrar su política de compromisos](#migrate-commitment-policy) por etapas.
+ `RequireEncryptAllowDecrypt`— AWS Encryption SDK Siempre cifra con un compromiso de clave. Puede descifrar textos cifrados, cifrados con o sin compromiso clave. Este valor se añade en la versión 2.0.*x*.
+ `RequireEncryptRequireDecrypt`— AWS Encryption SDK Siempre cifra y descifra con compromiso de clave. Este valor se añade en la versión 2.0.*x*. Es el valor predeterminado en las versiones 2.0.*x* y posteriores.
En las últimas versiones 1.*x*, el único valor válido de la política de compromiso es `ForbidEncryptAllowDecrypt`. Después de migrar hasta la versión 2.0.*x* o una versión posterior, puede [cambiar su política de compromisos por etapas](migration-guide.md) a medida que esté preparado. No actualice su política de compromisos a `RequireEncryptRequireDecrypt` hasta que esté seguro de que no tiene ningún mensaje cifrado sin un compromiso clave.
Estos ejemplos le muestran cómo establecer su política de compromiso en la última versión 1.*x* y en las versiones 2.0.*x* y versiones posteriores. La técnica depende del lenguaje de programación.
**Más información sobre la migración**
Para SDK de cifrado de AWS para Java SDK de cifrado de AWS para Python, y la CLI de AWS cifrado, obtenga información sobre los cambios necesarios en los proveedores de claves maestras en[Actualización de los proveedores de claves AWS KMS maestras](migrate-mkps-v2.md).
Para SDK de cifrado de AWS para C y SDK de cifrado de AWS para JavaScript, infórmese sobre una actualización opcional de los llaveros. [Actualización de los AWS KMS llaveros](migrate-keyrings-v2.md)
## ¿Cómo establecer su política de compromiso?
La técnica que se utiliza para establecer la política de compromiso varía ligeramente en función de la implementación en cada lenguaje. En estos ejemplos de .NET puede ver cómo: Antes de cambiar su política de compromiso, revise el enfoque de varias etapas que se incluye en [Cómo migrar e implementar](migration-guide.md).
------
#### [ C ]
A partir de la versión 1.7. *x* SDK de cifrado de AWS para C, utiliza la `aws_cryptosdk_session_set_commitment_policy` función para establecer la política de compromiso en sus sesiones de cifrado y descifrado. La política de compromiso que establezca se aplica a todas las operaciones de cifrado y descifrado realizadas en esa sesión.
Las funciones `aws_cryptosdk_session_new_from_keyring` y `aws_cryptosdk_session_new_from_cmm` están en desuso en la versión 1.7.*x* y se eliminaron en la versión 2.0.*x*. Estas funciones se sustituyen por funciones `aws_cryptosdk_session_new_from_keyring_2` y `aws_cryptosdk_session_new_from_cmm_2` que devuelven una sesión.
Cuando usa `aws_cryptosdk_session_new_from_keyring_2` y `aws_cryptosdk_session_new_from_cmm_2` en las últimas versiones 1.*x*, debe llamar a la función `aws_cryptosdk_session_set_commitment_policy` con el valor de la política de compromiso `COMMITMENT_POLICY_FORBID_ENCRYPT_ALLOW_DECRYPT`. En versiones 2.0.*x* y versiones posteriores, llamar a esta función es opcional y toma todos los valores válidos. La política de compromiso predeterminada para las versiones 2.0.*x* y versiones posteriores es `COMMITMENT_POLICY_REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
Para obtener un ejemplo completo, consulte [string.cpp](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/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)
```
------
#### [ C\$1 / .NET ]
El `require-encrypt-require-decrypt` valor es la política de compromiso predeterminada en todas las versiones de AWS Encryption SDK para .NET. Puede configurarlo de forma explícita como práctica recomendada, pero no es necesario establecerlo. Sin embargo, si utiliza para.NET AWS Encryption SDK para descifrar el texto cifrado en otro idioma de la implementación AWS Encryption SDK sin compromiso clave, debe cambiar el valor de la política de compromiso a o. `REQUIRE_ENCRYPT_ALLOW_DECRYPT` `FORBID_ENCRYPT_ALLOW_DECRYPT` De lo contrario, el intento de descifrar el texto cifrado devolverá un error.
En el AWS Encryption SDK caso de.NET, se establece la política de compromiso en una instancia de. AWS Encryption SDK Cree una instancia de un `AwsEncryptionSdkConfig` objeto con un `CommitmentPolicy` parámetro y utilice el objeto de configuración para crear la AWS Encryption SDK instancia. A continuación, llama a los `Decrypt()` métodos `Encrypt()` y de la instancia configurada AWS Encryption SDK .
En este ejemplo, se establece la política de compromiso en `require-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()
{
{"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);
```
------
#### [ AWS Encryption CLI ]
Para establecer una política de compromiso en la CLI de AWS cifrado, utilice el `--commitment-policy` parámetro. Este parámetro se introduce en la versión 1.8.*x*.
En la última versión 1.*x*, cuando se utiliza el parámetro `--wrapping-keys` en un comando `--encrypt` o `--decrypt`, se requiere un parámetro `--commitment-policy` con el valor `forbid-encrypt-allow-decrypt`. De lo contrario, el parámetro `--commitment-policy` no es válido.
En las versiones 2.1.*x* y versiones posteriores, el parámetro `--commitment-policy` es opcional y tiene el valor predeterminado `require-encrypt-require-decrypt`, que no cifrará ni descifrará ningún texto cifrado sin el compromiso clave. Sin embargo, recomendamos establecer la política de compromiso de forma explícita en todas las llamadas de cifrado y descifrado para facilitar el mantenimiento y la solución de problemas.
En este ejemplo se establece la política de compromiso. También usa el parámetro `--wrapping-keys` que reemplaza al parámetro `--master-keys` que comienza en la versión 1.8.*x*. Para obtener más información, consulte [Actualización de los proveedores de claves AWS KMS maestras](migrate-mkps-v2.md). Para ver ejemplos completos, consulte [Ejemplos de la CLI AWS de cifrado](crypto-cli-examples.md).
```
\\ 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 .
```
------
#### [ Java ]
A partir de la versión 1.7. *x* SDK de cifrado de AWS para Java, estableces la política de compromiso en tu instancia del `AwsCrypto` objeto que representa al AWS Encryption SDK cliente. Esta configuración de política de compromiso se aplica a todas las operaciones de cifrado y descifrado realizadas en ese cliente.
El `AwsCrypto()` constructor está en desuso en la última versión. *x* versiones de SDK de cifrado de AWS para Java y se elimina en la versión 2.0. *x*. Se sustituye por una nueva clase `Builder`, un método `Builder.withCommitmentPolicy()` y el tipo `CommitmentPolicy` enumerado.
En las últimas versiones 1.*x*, la clase `Builder` requiere el método `Builder.withCommitmentPolicy()` y el argumento `CommitmentPolicy.ForbidEncryptAllowDecrypt`. A partir de la versión 2.0.*x*, el método `Builder.withCommitmentPolicy()` es opcional; el valor predeterminado es `CommitmentPolicy.RequireEncryptRequireDecrypt`.
Para ver un ejemplo completo, consulte [SetCommitmentPolicyExample.java.](https://github.com/aws/aws-encryption-sdk-java/blob/master/src/examples/java/com/amazonaws/crypto/examples/v2/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 encryptResult = crypto.encryptData(
masterKeyProvider,
sourcePlaintext,
encryptionContext);
byte[] ciphertext = encryptResult.getResult();
// Decrypt your ciphertext
CryptoResult decryptResult = crypto.decryptData(
masterKeyProvider,
ciphertext);
byte[] decrypted = decryptResult.getResult();
```
------
#### [ JavaScript ]
A partir de la versión 1.7. *x* del SDK de cifrado de AWS para JavaScript, puede establecer la política de compromiso al llamar a la nueva `buildClient` función que crea una instancia de un AWS Encryption SDK cliente. La función `buildClient` toma un valor enumerado que representa su política de compromiso. Devuelve funciones actualizadas `encrypt` y `decrypt` que hacen cumplir su política de compromiso al cifrar y descifrar.
En las últimas versiones 1.*x*, la función `buildClient` requiere el argumento `CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT`. A partir de la versión 2.0.*x*, el argumento de la política de compromiso es opcional y el valor predeterminado es `CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
El código de Node.js y el navegador son idénticos para este propósito, excepto que el navegador necesita una declaración para establecer las credenciales.
En el siguiente ejemplo, se cifran los datos con un anillo de claves. AWS KMS La nueva función `buildClient` establece la política de compromiso en `FORBID_ENCRYPT_ALLOW_DECRYPT`, el valor predeterminado en las últimas versiones 1.*x*. Las funciones actualizadas `encrypt` y `decrypt` que `buildClient` devuelve hacen cumplir la política de compromiso que haya establecido.
```
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)
```
------
#### [ Python ]
A partir de la versión 1.7. *x* SDK de cifrado de AWS para Python, estableces la política de compromiso en tu instancia de`EncryptionSDKClient`, un nuevo objeto que representa al AWS Encryption SDK cliente. La política de compromiso que establezca se aplica a todas las llamadas a `encrypt` y `decrypt` que usen esa instancia del cliente.
En las últimas versiones 1*x*, el constructor `EncryptionSDKClient` requiere el valor `CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT` enumerado. A partir de la versión 2.0.*x*, el argumento de la política de compromiso es opcional y el valor predeterminado es `CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT`.
En este ejemplo, se utiliza el nuevo constructor `EncryptionSDKClient` y se establece la política de compromiso en 1.7.*x* valor predeterminado. El constructor crea una instancia de un cliente que representa el AWS Encryption SDK. Cuando llama a los métodos `encrypt`, `decrypt` o `stream` de este cliente, estos aplican la política de compromiso que haya establecido. En este ejemplo también se utiliza el nuevo constructor de la `StrictAwsKmsMasterKeyProvider` clase, que especifica AWS KMS keys cuándo se cifra y se descifra.
Para ver un ejemplo completo, consulte [set\$1commitment.py.](https://github.com/aws/aws-encryption-sdk-python/blob/master/examples/src/legacy/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
)
```
------
#### [ Rust ]
El `require-encrypt-require-decrypt` valor es la política de compromiso predeterminada en todas las versiones de Rust AWS Encryption SDK . Puede configurarlo de forma explícita como práctica recomendada, pero no es necesario establecerlo. Sin embargo, si utiliza la implementación AWS Encryption SDK de Rust AWS Encryption SDK sin compromiso de clave cifrada cifrada en otro idioma, tendrá que cambiar el valor de la política de compromiso a o. `REQUIRE_ENCRYPT_ALLOW_DECRYPT` `FORBID_ENCRYPT_ALLOW_DECRYPT` De lo contrario, el intento de descifrar el texto cifrado devolverá un error.
En el caso AWS Encryption SDK de Rust, se establece la política de compromiso en una instancia de. AWS Encryption SDK Cree una instancia de un `AwsEncryptionSdkConfig` objeto con un `comitment_policy` parámetro y utilice el objeto de configuración para crear la AWS Encryption SDK instancia. A continuación, llama a los `Decrypt()` métodos `Encrypt()` y de la instancia configurada AWS Encryption SDK .
En este ejemplo, se establece la política de compromiso en `forbid-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?;
```
------
#### [ 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
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)
}
```
------