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.

# Conjunto de claves de AES sin formato
<a name="use-raw-aes-keyring"></a>

 AWS Encryption SDK Le permite usar una clave simétrica AES que proporciona como clave de empaquetado que protege su clave de datos. Debe generar, almacenar y proteger el material clave, preferiblemente en un módulo de seguridad de hardware (HSM) o en un sistema de administración de claves. Utilice un conjunto de claves de AES sin procesar cuando necesite proporcionar la clave de encapsulamiento y cifre las claves de datos de forma local o fuera de línea.

El conjunto de claves de AES sin formato usa el algoritmo AES-GCM y una clave de encapsulamiento que especifique como matriz de bytes para cifrar claves de datos. Puede especificar una sola clave de encapsulamiento en cada conjunto de claves de AES sin formato, pero puede incluir varios conjuntos de claves de AES sin formato en cada [conjunto de claves múltiple](use-multi-keyring.md). 

El conjunto de claves AES sin procesar es equivalente e interactúa con la [JceMasterKey](https://aws.github.io/aws-encryption-sdk-java/com/amazonaws/encryptionsdk/jce/JceMasterKey.html)clase de SDK de cifrado de AWS para Java y la [RawMasterKey](https://aws-encryption-sdk-python.readthedocs.io/en/latest/generated/aws_encryption_sdk.key_providers.raw.html#aws_encryption_sdk.key_providers.raw.RawMasterKey)clase del SDK de cifrado de AWS para Python cuando se utiliza con claves de cifrado AES. Puede cifrar los datos con una implementación y descifrarlos con cualquier otra implementación mediante la misma clave de encapsulamiento. Para obtener más información, consulte [Compatibilidad de conjuntos de claves](choose-keyring.md#keyring-compatibility).

**Nombres y espacios de nombres clave**

Para identificar la clave de AES, el conjunto de claves de AES sin formato utiliza un *espacio de nombres de claves* y *nombre de clave* que usted facilite. Estos valores no son secretos. Aparecen en texto no cifrado en el encabezado del [mensaje cifrado](concepts.md#message) que devuelve la operación de cifrado. Recomendamos utilizar un espacio de nombres clave en su HSM o sistema de administración de claves y un nombre de clave que identifique la clave AES en ese sistema.

**nota**  
El espacio de nombres de clave y el nombre de clave son equivalentes a los campos *ID de proveedor* (o *proveedor*) e *ID de clave* en la `JceMasterKey` y la `RawMasterKey`.  
El SDK de cifrado de AWS para C y AWS Encryption SDK para .NET reservan el valor del espacio de nombres de la `aws-kms` clave para las claves de KMS. No utilice este valor de espacio de nombres en un conjunto de claves de AES sin procesar o en un conjunto de claves de RSA sin procesar con estas bibliotecas.

Si crea diferentes conjuntos de claves para cifrar y descifrar un mensaje determinado, el espacio de nombres y los valores de los nombres son fundamentales. Si el espacio de nombres y el nombre de la clave del conjunto de claves de descifrado no coinciden exactamente y distinguen mayúsculas de minúsculas entre el espacio de nombres de la clave y el nombre de la clave del conjunto de claves de cifrado, no se utiliza el conjunto de claves de descifrado, incluso si los bytes del material de la clave son idénticos.

Por ejemplo, puede definir un conjunto de claves de AES sin procesar con el espacio de nombres `HSM_01` y el nombre de la clave `AES_256_012`. A continuación, utilice ese conjunto de claves para cifrar algunos datos. Para descifrar esos datos, cree un conjunto de claves de AES sin procesar con el mismo espacio de nombres, nombre de clave y material de clave.

Los siguientes ejemplos muestran cómo crear un conjunto de claves de AES sin formato. La `AESWrappingKey` variable representa el material clave que proporciona.

------
#### [ C ]

Para crear una instancia de un conjunto de claves AES sin procesar en, utilice. SDK de cifrado de AWS para C`aws_cryptosdk_raw_aes_keyring_new()` Para ver un ejemplo completo, consulte [raw\$1aes\$1keyring.c](https://github.com/aws/aws-encryption-sdk-c/blob/master/examples/raw_aes_keyring.c).

```
struct aws_allocator *alloc = aws_default_allocator();

AWS_STATIC_STRING_FROM_LITERAL(wrapping_key_namespace, "HSM_01");
AWS_STATIC_STRING_FROM_LITERAL(wrapping_key_name, "AES_256_012");

struct aws_cryptosdk_keyring *raw_aes_keyring = aws_cryptosdk_raw_aes_keyring_new(
        alloc, wrapping_key_namespace, wrapping_key_name, aes_wrapping_key, wrapping_key_len);
```

------
#### [ C\$1 / .NET ]

Para crear un conjunto de claves AES sin procesar AWS Encryption SDK para .NET, utilice el método. `materialProviders.CreateRawAesKeyring()` Para ver un ejemplo completo, consulte [Raw AESKeyring Example.cs](https://github.com/aws/aws-encryption-sdk/tree/mainline/AwsEncryptionSDK/runtimes/net/Examples/Keyring/RawAESKeyringExample.cs).

El siguiente ejemplo usa la versión 4. *x* y versiones posteriores de AWS Encryption SDK para .NET.

```
// Instantiate the AWS Encryption SDK and material providers
var esdk =  new ESDK(new AwsEncryptionSdkConfig());
var mpl = new MaterialProviders(new MaterialProvidersConfig());

var keyNamespace = "HSM_01";
var keyName = "AES_256_012";

// This example uses the key generator in Bouncy Castle to generate the key material.
// In production, use key material from a secure source.
var aesWrappingKey = new MemoryStream(GeneratorUtilities.GetKeyGenerator("AES256").GenerateKey());

// Create the keyring that determines how your data keys are protected.
var createKeyringInput = new CreateRawAesKeyringInput
{
    KeyNamespace = keyNamespace,
    KeyName = keyName,
    WrappingKey = aesWrappingKey,
    WrappingAlg = AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
};

var keyring = materialProviders.CreateRawAesKeyring(createKeyringInput);
```

------
#### [ JavaScript Browser ]

El SDK de cifrado de AWS para JavaScript del navegador obtiene sus primitivas criptográficas de la [WebCrypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)API. Antes de construir el conjunto de claves, debes importar el material clave sin procesar `RawAesKeyringWebCrypto.importCryptoKey()` al backend. WebCrypto Esto garantiza que el conjunto de claves esté completo aunque todas las llamadas sean asíncronas. WebCrypto 

A continuación, para crear una instancia de un conjunto de claves de AES sin procesar, utilice el método `RawAesKeyringWebCrypto()`. Debe especificar el algoritmo de encapsulamiento AES ("conjunto de encapsulamiento") en función de la longitud del material clave. [Para ver un ejemplo completo, consulte aes\$1simple.ts (Browser). JavaScript ](https://github.com/aws/aws-encryption-sdk-javascript/blob/master/modules/example-browser/src/aes_simple.ts)

[En el siguiente ejemplo, se utiliza la `buildClient` función para especificar la política de compromiso predeterminada,.](migrate-commitment-policy.md) `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` También puede utilizarla `buildClient` para limitar el número de claves de datos cifradas en un mensaje cifrado. Para obtener más información, consulte [Limitar las claves de datos cifrados](configure.md#config-limit-keys).

```
import {
  RawAesWrappingSuiteIdentifier,
  RawAesKeyringWebCrypto,
  synchronousRandomValues,
  buildClient,
  CommitmentPolicy,
} from '@aws-crypto/client-browser'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const keyNamespace = 'HSM_01'
const keyName = 'AES_256_012'

const wrappingSuite =
  RawAesWrappingSuiteIdentifier.AES256_GCM_IV12_TAG16_NO_PADDING

/* Import the plaintext AES key into the WebCrypto backend. */
const aesWrappingKey = await RawAesKeyringWebCrypto.importCryptoKey(
  rawAesKey,
  wrappingSuite
)

const rawAesKeyring = new RawAesKeyringWebCrypto({
  keyName,
  keyNamespace,
  wrappingSuite,
  aesWrappingKey
})
```

------
#### [ JavaScript Node.js ]

Para crear una instancia de un conjunto de claves AES sin procesar en el SDK de cifrado de AWS para JavaScript archivo Node.js, cree una instancia de la clase. ` RawAesKeyringNode` Debe especificar el algoritmo de encapsulamiento AES ("conjunto de encapsulamiento") en función de la longitud del material clave. Para ver un ejemplo completo, consulte [aes\$1simple.ts](https://github.com/aws/aws-encryption-sdk-javascript//blob/master/modules/example-node/src/aes_simple.ts) (Node.js). JavaScript 

[En el siguiente ejemplo, se utiliza la `buildClient` función para especificar la política de compromiso predeterminada,.](migrate-commitment-policy.md) `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` También puede utilizarla `buildClient` para limitar el número de claves de datos cifradas en un mensaje cifrado. Para obtener más información, consulte [Limitar las claves de datos cifrados](configure.md#config-limit-keys).

```
import {
  RawAesKeyringNode,
  buildClient,
  CommitmentPolicy,
  RawAesWrappingSuiteIdentifier,
} from '@aws-crypto/client-node'

const { encrypt, decrypt } = buildClient(
  CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

const keyName = 'AES_256_012'
const keyNamespace = 'HSM_01'

const wrappingSuite =
  RawAesWrappingSuiteIdentifier.AES256_GCM_IV12_TAG16_NO_PADDING

const rawAesKeyring = new RawAesKeyringNode({
  keyName,
  keyNamespace,
  aesWrappingKey,
  wrappingSuite,
})
```

------
#### [ Java ]

Para crear una instancia de un conjunto de claves AES sin procesar en el SDK de cifrado de AWS para Java, utilice. `matProv.CreateRawAesKeyring()`

```
final CreateRawAesKeyringInput keyringInput = CreateRawAesKeyringInput.builder()
        .keyName("AES_256_012")
        .keyNamespace("HSM_01")
        .wrappingKey(AESWrappingKey)
        .wrappingAlg(AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16)
        .build();
final MaterialProviders matProv = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();
IKeyring rawAesKeyring = matProv.CreateRawAesKeyring(keyringInput);
```

------
#### [ Python ]

[El siguiente ejemplo crea una instancia del AWS Encryption SDK cliente con la política de compromiso predeterminada,.](migrate-commitment-policy.md) `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Para ver un ejemplo completo, consulte [raw\$1aes\$1keyring\$1example.py](https://github.com/aws/aws-encryption-sdk-python/tree/master/examples/src/raw_aes_keyring_example.py) en el SDK de cifrado de AWS para Python repositorio de. GitHub

```
# Instantiate the AWS Encryption SDK client
client = aws_encryption_sdk.EncryptionSDKClient(
    commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
)

# Define the key namespace and key name
key_name_space = "HSM_01"
key_name = "AES_256_012"
                            
# Optional: Create an encryption context
encryption_context: Dict[str, str] = {
    "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
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create Raw AES keyring
keyring_input: CreateRawAesKeyringInput = CreateRawAesKeyringInput(
    key_namespace=key_name_space,
    key_name=key_name,
    wrapping_key=AESWrappingKey,
    wrapping_alg=AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
)

raw_aes_keyring: IKeyring = mat_prov.create_raw_aes_keyring(
    input=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)?;

// Define the key namespace and key name
let key_namespace: &str = "HSM_01";
let key_name: &str = "AES_256_012";

// Optional: Create an 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 Raw AES keyring
let raw_aes_keyring = mpl
    .create_raw_aes_keyring()
    .key_name(key_name)
    .key_namespace(key_namespace)
    .wrapping_key(aws_smithy_types::Blob::new(AESWrappingKey))
    .wrapping_alg(AesWrappingAlg::AlgAes256GcmIv12Tag16)
    .send()
    .await?;
```

------
#### [ Go ]

```
import (
    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)
}
// Define the key namespace and key name
var keyNamespace = "A managed aes keys"
var keyName = "My 256-bit AES wrapping key"

// 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 Raw AES keyring
aesKeyRingInput := mpltypes.CreateRawAesKeyringInput{
    KeyName:      keyName,
    KeyNamespace: keyNamespace,
    WrappingKey:  aesWrappingKey,
    WrappingAlg:  mpltypes.AesWrappingAlgAlgAes256GcmIv12Tag16,
}
aesKeyring, err := matProv.CreateRawAesKeyring(context.Background(), aesKeyRingInput)
if err != nil {
    panic(err)
}
```

------