As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# AWS Encryption SDK para Rust
<a name="rust"></a>

Este tópico explica como instalar e usar o AWS Encryption SDK for Rust. Para obter detalhes sobre a programação com o AWS Encryption SDK for Rust, consulte o diretório [Rust](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/) do aws-encryption-sdk repositório em. GitHub

O AWS Encryption SDK for Rust difere de algumas das outras implementações de linguagem de programação do das seguintes AWS Encryption SDK maneiras:
+ Não há suporte para armazenamento em [cache de chaves de dados](data-key-caching.md). No entanto, o AWS Encryption SDK for Rust suporta o [AWS KMS chaveiro hierárquico](use-hierarchical-keyring.md), uma solução alternativa de cache de materiais criptográficos.
+ Não há suporte para streaming de dados

O AWS Encryption SDK for Rust inclui todos os recursos de segurança introduzidos nas versões 2.0. *x* e posteriores de outras implementações de linguagem do AWS Encryption SDK. No entanto, se você estiver usando o for Rust AWS Encryption SDK para descriptografar dados que foram criptografados por um pré-2.0. versão *x* outra implementação de linguagem do AWS Encryption SDK, talvez seja necessário ajustar sua [política de compromisso](concepts.md#commitment-policy). Para obter detalhes, consulte [Como definir sua política de compromisso](migrate-commitment-policy.md#migrate-commitment-step1).

O AWS Encryption SDK for Rust é um produto do AWS Encryption SDK in [Dafny](https://github.com/dafny-lang/dafny/blob/master/README.md), uma linguagem de verificação formal na qual você escreve especificações, o código para implementá-las e as provas para testá-las. O resultado é uma biblioteca que implementa os atributos do AWS Encryption SDK em uma estrutura que garante a correção funcional.

**Saiba mais**
+ Para ver exemplos que mostram como configurar opções no AWS Encryption SDK, como especificar um conjunto alternativo de algoritmos, limitar chaves de dados criptografadas e usar chaves AWS KMS multirregionais, consulte. [Configurando o AWS Encryption SDK](configure.md)
+ Para exemplos que mostram como configurar e usar o AWS Encryption SDK for Rust, consulte os [exemplos do Rust](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/examples) no aws-encryption-sdk repositório em. GitHub

**Topics**
+ [

## Pré-requisitos
](#prerequisites-rust)
+ [

## Instalação
](#rust-installation)
+ [Exemplos](rust-examples.md)

## Pré-requisitos
<a name="prerequisites-rust"></a>

Antes de instalar o AWS Encryption SDK for Rust, verifique se você tem os seguintes pré-requisitos.

**Instale Rust and Cargo**  
Instale a versão estável atual do [Rust](https://www.rust-lang.org/) usando o [rustup](https://rustup.rs/).  
Para obter mais informações sobre como baixar e instalar o rustup, consulte os [procedimentos de instalação](https://doc.rust-lang.org/cargo/getting-started/installation.html) no The Cargo Book.

## Instalação
<a name="rust-installation"></a>

O AWS Encryption SDK for Rust está disponível como caixa em [https://crates.io/crates/aws-esdk](https://crates.io/crates/aws-esdk)Crates.io. Para obter detalhes sobre como instalar e construir o AWS Encryption SDK para Rust, consulte o [README.md no repositório](https://github.com/aws/aws-encryption-sdk/tree/mainline) em. aws-encryption-sdk GitHub

Você pode instalar o AWS Encryption SDK for Rust das seguintes maneiras.

**Manualmente**  
Para instalar o AWS Encryption SDK for Rust, clone ou baixe o [aws-encryption-sdk](https://github.com/aws/aws-encryption-sdk/tree/mainline) GitHub repositório.

**Usando Crates.io**  
Execute o seguinte comando Cargo no diretório do seu projeto:  

```
cargo add aws-esdk
```
Ou adicione a seguinte linha ao seu Cargo.toml:  

```
aws-esdk = "<version>"
```

# AWS Encryption SDK para código de exemplo de Rust
<a name="rust-examples"></a>

Os exemplos a seguir mostram os padrões básicos de codificação que você usa ao programar com o AWS Encryption SDK for Rust. Especificamente, você instancia a biblioteca AWS Encryption SDK e os fornecedores de materiais. Em seguida, antes de chamar cada método, você instancia o objeto que define a entrada para o método.

Para exemplos que mostram como configurar opções no AWS Encryption SDK, como especificar um conjunto alternativo de algoritmos e limitar chaves de dados criptografadas, consulte os [exemplos de Rust no aws-encryption-sdk repositório](https://github.com/aws/aws-encryption-sdk-dafny/tree/mainline/AwsEncryptionSDK/runtimes/rust/examples/) em. GitHub

## Criptografando e descriptografando dados no for Rust AWS Encryption SDK
<a name="rust-example-encrypt"></a>

Este exemplo mostra o padrão básico para criptografar e descriptografar dados. Ele criptografa um pequeno arquivo com chaves de dados protegidas por uma chave de AWS KMS empacotamento.

**Etapa 1: Instancie o. AWS Encryption SDK**  
Você usará os métodos do AWS Encryption SDK para criptografar e descriptografar dados.  

```
let esdk_config = AwsEncryptionSdkConfig::builder().build()?;
let esdk_client = esdk_client::Client::from_conf(esdk_config)?;
```

**Etapa 2: Crie um 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: crie seu contexto de criptografia.**  

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

**Etapa 3: Instanciar a biblioteca de fornecedores de materiais.**  
Você usará os métodos na biblioteca de fornecedores de materiais para criar os tokens de autenticação que especificam quais chaves protegem seus dados.  

```
let mpl_config = MaterialProvidersConfig::builder().build()?;
let mpl = mpl_client::Client::from_conf(mpl_config)?;
```

**Etapa 4: Crie um AWS KMS chaveiro.**  
Para criar o token de autenticação, chame o método do token de autenticação com o objeto de entrada do token de autenticação. Este exemplo usa o `create_aws_kms_keyring()` método e especifica uma chave KMS.  

```
let kms_keyring = mpl
    .create_aws_kms_keyring()
    .kms_key_id(kms_key_id)
    .kms_client(kms_client)
    .send()
    .await?;
```

**Etapa 5: criptografar o texto sem formatação.**  

```
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");
```

**Etapa 6: descriptografe seus dados criptografados usando o mesmo chaveiro que você usou na criptografia.**  

```
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");
```