Definir configurações do nível HTTP no AWS SDK para Rust

O AWS SDK para Rust fornece a funcionalidade HTTP integrada usada pelos clientes do AWS service (Serviço da AWS) que você cria em seu código.

Por padrão, o SDK para Rust usa um cliente HTTPS baseado em hyper, rustls e aws-lc-rs. Esse cliente deve funcionar bem na maioria dos casos de uso sem configuração adicional.

A caixa aws-smithy-http-client fornece algumas opções e configurações adicionais se você quiser escolher um provedor TLS ou criptográfico diferente. Para casos de uso mais avançados, recomendamos que você traga sua própria implementação de cliente HTTP ou envie uma solicitação de recurso para consideração.

Escolher um provedor de TLS alternativo

A caixa aws-smithy-http-client fornece alguns provedores alternativos de TLS.

Os seguintes provedores estão disponíveis:

Pré-requisitos

Usar aws-lc-rs ou s2n-tls exige um compilador C (Clang ou GCC) para compilação. Para algumas plataformas, a compilação também pode exigir o CMake. Compilar com o recurso “fips” em qualquer plataforma requer CMake and Go. Para obter mais informações, consulte o repositório AWS Libcrypto for Rust (aws-lc-rs) e as instruções de compilação.

Como usar um provedor de TLS alternativo

A caixa aws-smithy-http-client fornece opções adicionais de TLS. Para que seus clientes do AWS service (Serviço da AWS) usem um provedor TLS diferente, substitua o http_client usando o carregador da caixa aws_config. O cliente HTTP é usado para provedores de Serviços da AWS e credenciais.

O exemplo a seguir mostra como usar a o provedor TLS s2n-tls. No entanto, uma abordagem semelhante também funciona para outros fornecedores.

Para compilar o código de exemplo, execute o seguinte comando para adicionar dependências ao seu projeto:

cargo add aws-smithy-http-client -F s2n-tls

Código de exemplo:

use aws_smithy_http_client::{tls, Builder};

#[tokio::main]
async fn main() {
    let http_client = Builder::new()
        .tls_provider(tls::Provider::S2nTls)
        .build_https();

    let sdk_config = aws_config::defaults(
        aws_config::BehaviorVersion::latest()
    )
    .http_client(http_client)
    .load()
    .await;

    // create client(s) using sdk_config
    // e.g. aws_sdk_s3::Client::new(&sdk_config);
}

Habilitar o suporte a FIPS

A caixa aws-smithy-http-client oferece uma opção para habilitar uma implementação de criptografia compatível com FIPS. Para que seus clientes do AWS service (Serviço da AWS) usem o provedor compatível com FIPS, substitua o http_client usando o carregador da caixa aws_config. O cliente HTTP é usado para provedores de Serviços da AWS e credenciais.

Para compilar o código de exemplo, execute o seguinte comando para adicionar dependências ao seu projeto:

cargo add aws-smithy-http-client -F rustls-aws-lc-fips

O código de exemplo a seguir habilita o suporte ao FIPS:

// file: main.rs
use aws_smithy_http_client::{
    tls::{self, rustls_provider::CryptoMode},
    Builder,
};

#[tokio::main]
async fn main() {
    let http_client = Builder::new()
        .tls_provider(tls::Provider::Rustls(CryptoMode::AwsLcFips))
        .build_https();

    let sdk_config = aws_config::defaults(
        aws_config::BehaviorVersion::latest()
    )
    .http_client(http_client)
    .load()
    .await;

    // create client(s) using sdk_config
    // e.g. aws_sdk_s3::Client::new(&sdk_config);
}

Priorizar a troca de chaves pós-quântica

O provedor TLS padrão é baseado no rustls usando aws-lc-rs, o que oferece suporte ao algoritmo de troca de chaves pós-quântica X25519MLKEM768. Para fazer do X25519MLKEM768 o algoritmo de maior prioridade, você precisa adicionar o pacote rustls à sua caixa e ativar o sinalizador de recursos prefer-post-quantum. Caso contrário, ele está disponível, mas não com a prioridade mais alta. Consulte a Documentação do rustls para obter mais informações.

Substituir o resolvedor de DNS

O resolvedor de DNS padrão pode ser substituído configurando o cliente HTTP manualmente.

Para compilar o código de exemplo, execute os seguintes comandos para adicionar dependências ao seu projeto:

cargo add aws-smithy-http-client -F rustls-aws-lc
cargo add aws-smithy-runtime-api -F client

O código de exemplo a seguir substitui o resolvedor de DNS:

use aws_smithy_http_client::{
    tls::{self, rustls_provider::CryptoMode},
    Builder
};
use aws_smithy_runtime_api::client::dns::{DnsFuture, ResolveDns};
use std::net::{IpAddr, Ipv4Addr};

/// A DNS resolver that returns a static IP address (127.0.0.1)
#[derive(Debug, Clone)]
struct StaticResolver;

impl ResolveDns for StaticResolver {
    fn resolve_dns<'a>(&'a self, _name: &'a str) -> DnsFuture<'a> {
        DnsFuture::ready(Ok(vec![IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1))]))
    }
}

#[tokio::main]
async fn main() {
    let http_client = Builder::new()
        .tls_provider(tls::Provider::Rustls(CryptoMode::AwsLc))
        .build_with_resolver(StaticResolver);
    
    let sdk_config = aws_config::defaults(
        aws_config::BehaviorVersion::latest()
    )
    .http_client(http_client)
    .load()
    .await;
    
    // create client(s) using sdk_config
    // e.g. aws_sdk_s3::Client::new(&sdk_config);
}

Personalizar certificados CA raiz

Por padrão, o provedor TLS carrega os certificados raiz nativos do sistema para a plataforma em questão. Para personalizar esse comportamento para carregar um pacote de CA personalizado, você pode configurar um TlsContext com o seu próprio TrustStore.

Para compilar o código de exemplo, execute os seguintes comandos para adicionar dependências ao seu projeto:

cargo add aws-smithy-http-client -F rustls-aws-lc

O exemplo a seguir usa rustls com aws-lc, mas funcionará para qualquer provedor de TLS compatível:

use aws_smithy_http_client::{
    tls::{self, rustls_provider::CryptoMode},
    Builder
};
use std::fs;

/// read the PEM encoded root CA (bundle) and return a custom TLS context
fn tls_context_from_pem(filename: &str) -> tls::TlsContext {
    let pem_contents = fs::read(filename).unwrap();
    
    // Create a new empty trust store (this will not load platform native certificates)
    let trust_store = tls::TrustStore::empty()
        .with_pem_certificate(pem_contents.as_slice());
        
    tls::TlsContext::builder()
        .with_trust_store(trust_store)
        .build()
        .expect("valid TLS config")
}

#[tokio::main]
async fn main() {
    let http_client = Builder::new()
        .tls_provider(tls::Provider::Rustls(CryptoMode::AwsLc))
        .tls_context(tls_context_from_pem("my-custom-ca.pem"))
        .build_https();
    
    let sdk_config = aws_config::defaults(
        aws_config::BehaviorVersion::latest()
    )
    .http_client(http_client)
    .load()
    .await;
    
    // create client(s) using sdk_config
    // e.g. aws_sdk_s3::Client::new(&sdk_config);
}