AWS SDK

    let tag = mac.finalize_fixed();

    // sign request

    let mut mac = Hmac::<Sha256>::new_from_slice(&tag).expect("HMAC can take key of any size");

    mac.update("aws4_request".as_bytes());

    mac.finalize_fixed()

}

/// Parameters to use when signing.

#[derive(Debug)]

#[non_exhaustive]

pub struct SigningParams<'a, S> {

    /// The identity to use when signing a request

    pub(crate) identity: &'a Identity,

    /// Region to sign for.

    pub(crate) region: &'a str,

    /// Service Name to sign for.

    ///

    /// NOTE: Endpoint resolution rules may specify a name that differs from the typical service name.

    /// Return the name of the algorithm used to sign requests

    pub fn algorithm(&self) -> &'static str {

        HMAC_256

    }

}

impl<'a, S: Default> SigningParams<'a, S> {

    /// Returns a builder that can create new `SigningParams`.

    pub fn builder() -> signing_params::Builder<'a, S> {

        Default::default()

    }

}

/// Builder and error for creating [`SigningParams`]

pub mod signing_params {

    use super::SigningParams;

    use aws_smithy_runtime_api::client::identity::Identity;

    use std::error::Error;

    use std::fmt;

    use std::time::SystemTime;

# Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

        let timestamp_tag = minicbor::data::Tag::from(minicbor::data::IanaTag::Timestamp);

        if tag != timestamp_tag {

            Err(DeserializeError::new(Error::message(

                "expected timestamp tag",

            )))

        } else {

            // Values that are more granular than millisecond precision SHOULD be truncated to fit

            // millisecond precision for epoch-seconds:

            // https://smithy.io/2.0/spec/protocol-traits.html#timestamp-formats

            //

            // Without truncation, the `RpcV2CborDateTimeWithFractionalSeconds` protocol test would

            // fail since the upstream test expect `123000000` in subsec but the decoded actual

            // subsec would be `123000025`.

            // https://github.com/smithy-lang/smithy/blob/6466fe77c65b8a17b219f0b0a60c767915205f95/smithy-protocol-tests/model/rpcv2Cbor/fractional-seconds.smithy#L17

            let epoch_seconds = self.decoder.f64().map_err(DeserializeError::new)?;

            let mut result = DateTime::from_secs_f64(epoch_seconds);

            let subsec_nanos = result.subsec_nanos();

            result.set_subsec_nanos((subsec_nanos / 1_000_000) * 1_000_000);

            Ok(result)

    }

}

pub fn set_optional<B, F>(builder: B, decoder: &mut Decoder, f: F) -> Result<B, DeserializeError>

where

    F: Fn(B, &mut Decoder) -> Result<B, DeserializeError>,

{

    match decoder.datatype()? {

        crate::data::Type::Null => {

            decoder.null()?;

            Ok(builder)

        }

        _ => f(builder, decoder),

    }

}

#[cfg(test)]

mod tests {

    use crate::Decoder;

    use aws_smithy_types::date_time::Format;

        assert_eq!(member, "thisIsAKey");

        assert!(matches!(member, std::borrow::Cow::Borrowed(_)));

    }

    #[test]

    fn test_indefinite_str_is_cow_owned() {

        // Indefinite length key `this`, `Is`, `A` and `Key`.

        let indefinite_bytes = [

            0x7f, 0x64, 0x74, 0x68, 0x69, 0x73, 0x62, 0x49, 0x73, 0x61, 0x41, 0x63, 0x4b, 0x65,

            0x79, 0xff,

        ];

        let mut decoder = Decoder::new(&indefinite_bytes);

        let member = decoder.str().expect("could not decode str");

        assert_eq!(member, "thisIsAKey");

        assert!(matches!(member, std::borrow::Cow::Owned(_)));

    }

    #[test]

    fn test_empty_str_works() {

        let bytes = [0x60];

            0x61, 0xff,

        ];

        let mut decoder = Decoder::new(&indefinite_bytes);

        let member = decoder.blob().expect("could not decode blob");

        assert_eq!(

            member,

            aws_smithy_types::Blob::new("indefinite-byte, chunked, on each comma".as_bytes())

        );

    }

    #[test]

    fn test_timestamp_should_be_truncated_to_fit_millisecond_precision() {

        // Input bytes are derived from the `RpcV2CborDateTimeWithFractionalSeconds` protocol test,

        // extracting portion representing a timestamp value.

        let bytes = [

            0xc1, 0xfb, 0x41, 0xcc, 0x37, 0xdb, 0x38, 0x0f, 0xbe, 0x77, 0xff,

        ];

        let mut decoder = Decoder::new(&bytes);

        let timestamp = decoder.timestamp().expect("should decode timestamp");

        assert_eq!(

name = "aws-smithy-checksums"

version = "0.63.3"

authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Zelda Hessler <zhessler@amazon.com>"]

description = "Checksum calculation and verification callbacks"

edition = "2021"

license = "Apache-2.0"

repository = "https://github.com/smithy-lang/smithy-rs"

[package.metadata.docs.rs]

all-features = true

targets = ["x86_64-unknown-linux-gnu"]

cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]

rustdoc-args = ["--cfg", "docsrs"]

[dependencies]

bytes = "1.10.0"

hex = "0.4.3"

http = "0.2.9"

http-body = "0.4.5"

md-5 = "0.10"

pin-project-lite = "0.2.14"

version = "1.23.1"

features = ["macros", "rt"]

[dependencies.http-body-0-4]

package = "http-body"

version = "0.4.5"

optional = true

[dependencies.http-body-1-0]

package = "http-body"

version = "1"

optional = true

[dependencies.http-body-util]

version = "0.1.2"

optional = true

[dev-dependencies]

bytes-utils = "0.1.2"

pretty_assertions = "1.3"

[dev-dependencies.tokio]

/*

 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

 * SPDX-License-Identifier: Apache-2.0

 */

use crate::{Compress, CompressionOptions};

use aws_smithy_runtime_api::box_error::BoxError;

use flate2::write::GzEncoder;

use std::io::prelude::*;

#[derive(Debug, Default, Clone, PartialEq, Eq)]

pub(crate) struct Gzip {

    compression: flate2::Compression,

}

impl Gzip {

    fn compress_bytes(&self, bytes: &[u8], writer: impl Write) -> Result<(), BoxError> {

        }

    }

}

#[cfg(feature = "http-body-1-x")]

mod http_body_1_x {

    use crate::http::http_body_1_x::CompressRequest;

    impl CompressRequest for super::Gzip {

        fn header_value(&self) -> http_1_0::HeaderValue {

            http_1_0::HeaderValue::from_static("gzip")

        }

    }

}

impl From<&CompressionOptions> for Gzip {

    fn from(options: &CompressionOptions) -> Self {

        Gzip {

            compression: flate2::Compression::new(options.level),

        }

name = "mutated_headers"

path = "fuzz_targets/mutated_headers.rs"

test = false

doc = false

[[bin]]

name = "prelude"

path = "fuzz_targets/prelude.rs"

test = false

doc = false

[package]

name = "aws-smithy-eventstream-fuzz"

version = "0.1.0"

authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "John DiSanti <jdisanti@amazon.com>"]

publish = false

edition = "2021"

[package.metadata]

cargo-fuzz = true

 */

//! A [`Buf`] implementation that counts bytes read.

use bytes::Buf;

/// A [`Buf`] implementation that counts bytes read.

pub(crate) struct CountBuf<'a, B>

where

    B: Buf,

{

    buffer: &'a mut B,

    count: usize,

}

impl<'a, B> CountBuf<'a, B>

where

    B: Buf,

{

    /// Creates a new `CountBuf` by wrapping the given `buffer`.

    fn advance(&mut self, cnt: usize) {

        self.count += cnt;

        self.buffer.advance(cnt);

    }

}

#[cfg(test)]

mod tests {

    use super::CountBuf;

    use bytes::Buf;

    #[test]

    fn count_no_data_read() {

        let mut data: &[u8] = &[];

        let buf = CountBuf::new(&mut data);

        assert_eq!(0, buf.into_count());

    }

    #[test]

use crc32fast::Hasher;

/// Implementation of [`Buf`] that calculates a CRC-32 checksum of the data

/// being read from an underlying `Buf` instance.

pub(crate) struct CrcBuf<'a, B>

where

    B: Buf,

{

    buffer: &'a mut B,

    crc: Hasher,

}

impl<'a, B> CrcBuf<'a, B>

where

    B: Buf,

{

    /// Creates a new `CrcBuf` by wrapping the given `buffer`.

    pub(crate) fn new(buffer: &'a mut B) -> Self {

        CrcBuf {

            buffer,

    fn advance(&mut self, cnt: usize) {

        let chunk = self.buffer.chunk();

        self.crc.update(&chunk[0..cnt]);

        self.buffer.advance(cnt);

    }

}

#[cfg(test)]

mod crc_buf_tests {

    use super::CrcBuf;

    use bytes::Buf;

    #[test]

    fn crc_no_data_read() {

        let mut data: &[u8] = &[];

        let buf = CrcBuf::new(&mut data);

        assert_eq!(0, buf.into_crc());

    }

        assert_eq!(10, buf.get_i16());

        assert_eq!(0x57DC8A56, buf.into_crc());

    }

}

/// Implementation of [`BufMut`] that calculates a CRC-32 checksum of the data

/// being written to an underlying `Buf` instance, with a function to then write

/// the calculated CRC-32 to the buffer.

pub(crate) struct CrcBufMut<'a> {

    buffer: &'a mut dyn BufMut,

    crc: Hasher,

}

impl<'a> CrcBufMut<'a> {

    /// Creates a new `CrcBufMut` by wrapping the given `buffer`.

    pub(crate) fn new(buffer: &'a mut dyn BufMut) -> Self {

        CrcBufMut {

            buffer,

            crc: Hasher::new(),

        }

        self.buffer.advance_mut(cnt);

    }

    fn chunk_mut(&mut self) -> &mut UninitSlice {

        self.buffer.chunk_mut()

    }

}

#[cfg(test)]

mod crc_buf_mut_tests {

    use super::CrcBufMut;

    use bytes::BufMut;

    #[test]

    fn crc_no_bytes_written() {

        let mut buffer: Vec<u8> = Vec::new();

        let mut crc_buf = CrcBufMut::new(&mut buffer);

        crc_buf.put_crc();

        crc_buf.put_crc();

        assert_eq!(vec![0, 0, 0, 0u8, 0x21, 0x44, 0xDF, 0x1C], buffer);

///

/// This signer basically just establishes a MPSC channel so that the sender can

/// be placed in the request's config. Then the HTTP signer implementation can

/// retrieve the sender from that config and send an actual signing implementation

/// with all the context needed.

///

/// When an event stream implementation needs to sign a message, the first call to

/// sign will acquire a signing implementation off of the channel and cache it

/// for the remainder of the operation.

#[derive(Debug)]

pub struct DeferredSigner {

    rx: Option<Mutex<mpsc::Receiver<Box<dyn SignMessage + Send + Sync>>>>,

    signer: Option<Box<dyn SignMessage + Send + Sync>>,

}

impl DeferredSigner {

    pub fn new() -> (Self, DeferredSignerSender) {

        let (tx, rx) = mpsc::channel();

        (

            Self {

                    // this should panic rather than default to the `NoOpSigner`. The reason it defaults

                    // is because middleware-based generic clients don't have any default middleware,

                    // so there is no way to send a `NoOpSigner` by default when there is no other

                    // auth scheme. The orchestrator auth setup is a lot more robust and will make

                    // this problem trivial.

                    .unwrap_or_else(|| Box::new(NoOpSigner {}) as _),

            );

            self.acquire()

        }

    }

}

impl SignMessage for DeferredSigner {

    fn sign(&mut self, message: Message) -> Result<Message, SignMessageError> {

        self.acquire().sign(message)

    }

    fn sign_empty(&mut self) -> Option<Result<Message, SignMessageError>> {

        self.acquire().sign_empty()

    }

expect_shape_fn!(fn expect_int32[Int32] -> i32 { value -> *value });

expect_shape_fn!(fn expect_int64[Int64] -> i64 { value -> *value });

expect_shape_fn!(fn expect_byte_array[ByteArray] -> Blob { bytes -> Blob::new(bytes.as_ref()) });

expect_shape_fn!(fn expect_string[String] -> String { value -> value.as_str().into() });

expect_shape_fn!(fn expect_timestamp[Timestamp] -> DateTime { value -> *value });

/// Structured header data from a [`Message`]

#[derive(Debug)]

pub struct ResponseHeaders<'a> {

    /// Content Type of the message

    ///

    /// This can be a number of things depending on the protocol. For example, if the protocol is

    /// AwsJson1, then this could be `application/json`, or `application/xml` for RestXml.

    ///

    /// It will be `application/octet-stream` if there is a Blob payload shape, and `text/plain` if

    /// there is a String payload shape.

    pub content_type: Option<&'a StrBytes>,

    /// Message Type field

    ///

    match header {

        Some(header) => Ok(header.value().as_string().map_err(|value| {

            Error::from(ErrorKind::Unmarshalling(format!(

                "expected response {} header to be string, received {:?}",

                name, value

            )))

        })?),

        None => Err(ErrorKind::Unmarshalling(format!(

            "expected response to include {} header, but it was missing",

            name

        ))

        .into()),

    }

}

/// Parse headers from [`Message`]

///

/// `:content-type`, `:message-type`, `:event-type`, and `:exception-type` headers will be parsed.

/// If any headers are invalid or missing, an error will be returned.

pub fn parse_response_headers(message: &Message) -> Result<ResponseHeaders<'_>, Error> {

# Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

[[example]]

name = "client-ring"

required-features = ["rustls-ring"]

doc-scrape-examples = true

[[example]]

name = "client-aws-lc"

required-features = ["rustls-aws-lc", "rustls-aws-lc-fips"]

doc-scrape-examples = true

[[example]]

name = "client-s2n-tls"

required-features = ["s2n-tls"]

doc-scrape-examples = true

version = "1.6.0"

features = ["client", "http1", "http2"]

optional = true

[dependencies.hyper-util]

version = "0.1.10"

features = ["http1", "http2"]

optional = true

[dependencies.http-1x]

package = "http"

version = "1"

optional = true

[dependencies.http-body-1x]

package = "http-body"

version = "1"

optional = true

[dependencies.hyper-rustls]

version = "1.0.210"

features = ["derive"]

optional = true

[dependencies.serde_json]

version = "1.0.128"

features = ["preserve_order"]

optional = true

[dependencies.indexmap]

version = "2.6.0"

features = ["serde"]

optional = true

[dependencies.http-body-util]

version = "0.1.2"

optional = true

[dev-dependencies]

rustls-pemfile = "2.2.0"

features = ["std"]

[dev-dependencies.tokio]

version = "1"

features = ["macros", "rt", "rt-multi-thread", "test-util", "full"]

mod capture_request;

pub use capture_request::{capture_request, CaptureRequestHandler, CaptureRequestReceiver};

#[cfg(feature = "legacy-test-util")]

pub use capture_request::legacy_capture_request;

pub mod dvr;

mod replay;

pub use replay::{ReplayEvent, StaticReplayClient};

mod infallible;

pub use infallible::infallible_client_fn;

// infallible based on http_02x stack had to be duplicated to avoid breaking API changes

#[allow(missing_docs)]

#[cfg(feature = "legacy-test-util")]

pub mod legacy_infallible;

impl BodyData {

    /// Convert [`BodyData`] into Bytes.

    pub fn into_bytes(self) -> Vec<u8> {

        match self {

            BodyData::Utf8(string) => string.into_bytes(),

            BodyData::Base64(string) => base64::decode(string).unwrap(),

        }

    }

    /// Copy [`BodyData`] into a `Vec<u8>`.

    pub fn copy_to_vec(&self) -> Vec<u8> {

        match self {

            BodyData::Utf8(string) => string.as_bytes().into(),

            BodyData::Base64(string) => base64::decode(string).unwrap(),

        }

    }

}

impl From<Bytes> for BodyData {

    fn from(data: Bytes) -> Self {

        };

        // content length is not added when it wasn't initially present

        assert_eq!(headers.get("content-length"), None);

        let Action::Response {

            response: Ok(Response { headers, .. }),

        } = &network_traffic.events[3].action

        else {

            panic!("unexpected event: {:?}", network_traffic.events[3].action);

        };

        // content length is not added when it wasn't initially present

        let expected_length = "hello from example.com".len();

        assert_eq!(

            headers.get("content-length"),

            Some(&vec![expected_length.to_string()])

        );

        Ok(())

    }

    #[cfg(feature = "legacy-test-util")]

        fn poll_read(

            self: Pin<&mut Self>,

            _cx: &mut Context<'_>,

            _buf: &mut ReadBuf<'_>,

        ) -> Poll<std::io::Result<()>> {

            unreachable!()

        }

    }

    impl AsyncWrite for NeverTcpConnection {

        fn poll_write(

            self: Pin<&mut Self>,

            _cx: &mut Context<'_>,

            _buf: &[u8],

        ) -> Poll<Result<usize, Error>> {

            unreachable!()

        }

        fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), Error>> {

            unreachable!()

            .with_sleep_impl(Some(TokioSleep::new()))

            .with_time_source(Some(SystemTimeSource::new()))

            .build()

            .unwrap();

        let http_connector = client.http_connector(

            &HttpConnectorSettings::builder()

                .connect_timeout(Duration::from_millis(100))

                .build(),

            &components,

        );

        let err = http_connector

            .call(HttpRequest::get("http://fakeuri.com").unwrap())

            .await

            .expect_err("it should time out");

        assert!(dbg!(err).is_timeout());

    }

    #[cfg(feature = "default-client")]

    #[tokio::test]