Configuración de los ajustes por HTTP en AWS SDK para Rust

El AWS SDK para Rust proporciona una funcionalidad HTTP integrada que utilizan los clientes de Servicio de AWS que cree en su código.

De forma predeterminada, el SDK para Rust usa un cliente HTTPS basado en hyper, rustls y aws-lc-rs. Este cliente debería funcionar bien en la mayoría de los casos de uso sin necesidad de configuración adicional.

La caja aws-smithy-http-client proporciona algunas opciones y configuraciones adicionales si desea elegir un proveedor de TLS o criptográfico diferente. Para casos de uso más avanzados, le recomendamos utilizar su propia implementación de cliente HTTP o enviar una solicitud de característica para tenerla en cuenta.

Elección de un proveedor de TLS alternativo

La caja aws-smithy-http-client proporciona algunos proveedores de TLS alternativos.

Están disponibles los siguientes proveedores:

Requisitos previos

El uso de aws-lc-rs o s2n-tls requiere un compilador C (Clang o GCC) para su compilación. En algunas plataformas, la compilación también puede requerir CMake. La compilación con la característica «fips» en cualquier plataforma requiere CMake y Go. Para obtener más información, consulte el repositorio y las instrucciones de compilación de AWS Libcrypto para Rust (aws-lc-rs).

Cómo utilizar un proveedor de TLS alternativo

La caja aws-smithy-http-client proporciona opciones de TLS adicionales. Para que los clientes de Servicio de AWS usen un proveedor de TLS diferente, anule http_client mediante del cargador dela caja aws_config. El cliente HTTP se utiliza tanto para los proveedores de credenciales como de Servicios de AWS.

El siguiente ejemplo muestra cómo utilizar el proveedor de TLS s2n-tls. Sin embargo, un enfoque similar funciona también para otros proveedores.

Para compilar el código de ejemplo, ejecute el siguiente comando para añadir dependencias al proyecto:

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

Código de ejemplo:

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);
}

Habilitación de la compatibilidad FIPS

La caja aws-smithy-http-client ofrece una opción para habilitar una implementación criptográfica compatible con FIPS. Para que los clientes Servicio de AWS utilicen un proveedor compatible con FIPS, anule http_client con el cargador de la caja aws_config. El cliente HTTP se utiliza tanto para los proveedores de credenciales como de Servicios de AWS.

Para compilar el código de ejemplo, ejecute el siguiente comando para añadir dependencias al proyecto:

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

El siguiente código de ejemplo habilita la compatibilidad con 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);
}

Prioridad del intercambio de claves poscuánticas

El proveedor de TLS predeterminado se basa en rustls que utiliza aws-lc-rs compatible con el algoritmo de intercambio de claves poscuánticas X25519MLKEM768. Para que X25519MLKEM768 sea el algoritmo de mayor prioridad, debe añadir el paquete rustls a la caja y activar el indicador de característica prefer-post-quantum. De lo contrario, estará disponible pero no será el de mayor prioridad. Para obtener más información, consulte la rustlsdocumentación de .

Anulación del solucionador de DNS

El solucionador de DNS predeterminado se puede anular configurando manualmente el cliente HTTP.

Para compilar el código de ejemplo, ejecute los siguientes comandos para añadir dependencias al proyecto:

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

El siguiente código de ejemplo anula el solucionador 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);
}

Personalización de los certificados CA raíz

De forma predeterminada, el proveedor de TLS carga los certificados raíz nativos del sistema para la plataforma en cuestión. Para personalizar este comportamiento y cargar un paquete de CA personalizado, puede configurar un TlsContext con su propio TrustStore.

Para compilar el código de ejemplo, ejecute los siguientes comandos para añadir dependencias al proyecto:

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

En el siguiente ejemplo, se utiliza rustls con aws-lc si bien funcionará con cualquier proveedor de TLS compatible:

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);
}