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.
# AWS Encryption SDK para Rust
En este tema se explica cómo instalar y usar AWS Encryption SDK for Rust. Para obtener más información sobre la programación AWS Encryption SDK para Rust, consulte el directorio [Rust](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/) del aws-encryption-sdk repositorio en GitHub.
La AWS Encryption SDK versión para Rust se diferencia de algunas de las implementaciones de otros lenguajes de programación AWS Encryption SDK en los siguientes aspectos:
+ No hay soporte para el almacenamiento en [caché de claves de datos](data-key-caching.md). Sin embargo, AWS Encryption SDK para Rust es compatible con el [anillo de claves AWS KMS jerárquico](use-hierarchical-keyring.md), una solución alternativa de almacenamiento en caché de materiales criptográficos.
+ No es compatible con el streaming de datos
La versión AWS Encryption SDK para Rust incluye todas las funciones de seguridad introducidas en las versiones 2.0. *x* y versiones posteriores de las implementaciones en otros idiomas del AWS Encryption SDK. Sin embargo, si está utilizando Rust AWS Encryption SDK para descifrar datos cifrados con una versión anterior a la 2.0. *x* versión de la implementación en otro idioma de la AWS Encryption SDK, es posible que deba ajustar su política de [compromisos](concepts.md#commitment-policy). Para obtener más información, consulte [¿Cómo establecer su política de compromiso?](migrate-commitment-policy.md#migrate-commitment-step1).
El AWS Encryption SDK de Rust es un producto de [Dafny](https://github.com/dafny-lang/dafny/blob/master/README.md), un lenguaje de verificación formal en el que se escriben las especificaciones, el código para implementarlas y las pruebas para probarlas. AWS Encryption SDK El resultado es una biblioteca que implementa las características del AWS Encryption SDK en una trama que garantiza la corrección funcional.
**Más información**
+ Para ver ejemplos que muestran cómo configurar las opciones del AWS Encryption SDK, como especificar un conjunto de algoritmos alternativo, limitar las claves de datos cifrados y utilizar claves AWS KMS multirregionales, consulte. [Configuración del AWS Encryption SDK](configure.md)
+ Para ver ejemplos que muestran cómo configurar y usar AWS Encryption SDK para Rust, consulta los [ejemplos de Rust](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/examples) en el aws-encryption-sdk repositorio de Rust. GitHub
**Topics**
+ [Requisitos previos](#prerequisites-rust)
+ [Instalación](#rust-installation)
+ [Ejemplos](rust-examples.md)
## Requisitos previos
Antes de instalar el AWS Encryption SDK para Rust, asegúrate de cumplir los siguientes requisitos previos.
**Instale Rust y Cargo**
Instala la versión estable actual de [Rust](https://www.rust-lang.org/) usando [rustup.](https://rustup.rs/)
Para obtener más información sobre la descarga e instalación de rustup, consulta los [procedimientos de instalación](https://doc.rust-lang.org/cargo/getting-started/installation.html) en The Cargo Book.
## Instalación
El AWS Encryption SDK de Rust está disponible en forma de [https://crates.io/crates/aws-esdk](https://crates.io/crates/aws-esdk)caja en Crates.io. Para obtener más información sobre cómo instalar y compilar AWS Encryption SDK para Rust, consulta el [archivo README.md](https://github.com/aws/aws-encryption-sdk/tree/mainline) en el repositorio de Rust. aws-encryption-sdk GitHub
Puedes instalar el AWS Encryption SDK para Rust de las siguientes maneras.
**Manualmente**
Para instalar el repositorio AWS Encryption SDK para Rust, clona o descarga el [aws-encryption-sdk](https://github.com/aws/aws-encryption-sdk/tree/mainline) GitHub repositorio.
**Usando Crates.io**
Ejecute el siguiente comando Cargo en el directorio de su proyecto:
```
cargo add aws-esdk
```
O añade la siguiente línea a tu Cargo.toml:
```
aws-esdk = ""
```
# AWS Encryption SDK para el código de ejemplo de Rust
Los siguientes ejemplos muestran los patrones de codificación básicos que se utilizan al programar con Rust. AWS Encryption SDK En concreto, se crea una instancia de la biblioteca AWS Encryption SDK y de proveedores de materiales. A continuación, antes de llamar a cada método, se crea una instancia del objeto que define la entrada del método.
Para ver ejemplos que muestran cómo configurar las opciones del AWS Encryption SDK, como especificar un conjunto de algoritmos alternativo y limitar las claves de datos cifrados, consulta los [ejemplos de Rust](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/examples/) en el aws-encryption-sdk repositorio de. GitHub
## Cifrar y descifrar datos en el caso de Rust AWS Encryption SDK
Este ejemplo muestra el patrón básico para cifrar y descifrar datos. Cifra un archivo pequeño con claves de datos que están protegidas por una AWS KMS clave de empaquetado.
**Paso 1: Instanciar el. AWS Encryption SDK**
Utilizará los métodos descritos en AWS Encryption SDK para cifrar y descifrar los datos.
```
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
```
**Paso 2: Crea un AWS KMS cliente.**
```
let sdk_config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
let kms_client = aws_sdk_kms::Client::new(&sdk_config);
```
**Opcional: cree su contexto de cifrado.**
```
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()),
]);
```
**Paso 3: Cree una instancia de la biblioteca de proveedores de materiales.**
Utilizará los métodos de la biblioteca de proveedores de materiales para crear los conjuntos de claves que especifican qué claves protegen sus datos.
```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
```
**Paso 4: Crea un AWS KMS llavero.**
Para crear el conjunto de claves, llame al método de conjunto de claves con el objeto de entrada del conjunto de claves. En este ejemplo, se utiliza el `create_aws_kms_keyring()` método y se especifica una clave KMS.
```
let kms_keyring = mpl
.create_aws_kms_keyring()
.kms_key_id(kms_key_id)
.kms_client(kms_client)
.send()
.await?;
```
**Paso 5: Cifra el texto sin formato.**
```
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?;
let ciphertext = encryption_response
.ciphertext
.expect("Unable to unwrap ciphertext from encryption response");
```
**Paso 6: Descifra tus datos cifrados con el mismo conjunto de claves que utilizaste para cifrar.**
```
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?;
let decrypted_plaintext = decryption_response
.plaintext
.expect("Unable to unwrap plaintext from decryption response");
```