const absl::string_view override_region) {

  const auto content_hash = createContentHash(message, sign_body);

  auto& headers = message.headers();

  return sign(headers, content_hash, override_region);

}

                                              const absl::string_view override_region) {

  headers.setReference(SignatureHeaders::get().ContentSha256,

                       SignatureConstants::HashedEmptyString);

  return sign(headers, std::string(SignatureConstants::HashedEmptyString), override_region);

}

                                                 const absl::string_view override_region) {

  headers.setReference(SignatureHeaders::get().ContentSha256, SignatureConstants::UnsignedPayload);

  return sign(headers, std::string(SignatureConstants::UnsignedPayload), override_region);

}

bool SignerBaseImpl::addCallbackIfCredentialsPending(CredentialsPendingCallback&& cb) {

  return credentials_provider_chain_->addCallbackIfChainCredentialsPending(std::move(cb));

}

    ABSL_ATTRIBUTE_UNUSED const absl::string_view override_region) const {}

    ABSL_ATTRIBUTE_UNUSED const absl::string_view override_region) const {}

std::string SignerBaseImpl::getRegion() const { return region_; }

                                  const absl::string_view override_region) {

  if (!query_string_ && !content_hash.empty()) {

    headers.setReferenceKey(SignatureHeaders::get().ContentSha256, content_hash);

  }

  const auto credentials = credentials_provider_chain_->chainGetCredentials();

  if (!credentials.hasCredentials()) {

    ENVOY_LOG(debug, "Sign exiting early - no credentials found");

    return absl::OkStatus();

  }

  if (headers.Method() == nullptr) {

    return absl::Status{absl::StatusCode::kInvalidArgument, "Message is missing :method header"};

  }

  if (headers.Path() == nullptr) {

    return absl::Status{absl::StatusCode::kInvalidArgument, "Message is missing :path header"};

  }

  const auto long_date = long_date_formatter_.now(time_source_);

  const auto short_date = short_date_formatter_.now(time_source_);

  if (!query_string_) {

    addRequiredHeaders(headers, long_date, credentials.sessionToken(), override_region);

  }

  const auto canonical_headers =

      Utility::canonicalizeHeaders(headers, excluded_header_matchers_, included_header_matchers_);

  const auto credential_scope = createCredentialScope(short_date, override_region);

  auto query_params =

      Envoy::Http::Utility::QueryParamsMulti::parseQueryString(headers.getPathValue());

  if (query_string_) {

    addRegionQueryParam(query_params, override_region);

    createQueryParams(

        query_params,

        createAuthorizationCredential(credentials.accessKeyId().value(), credential_scope),

        long_date, credentials.sessionToken(), canonical_headers, expiration_time_);

    headers.setPath(query_params.replaceQueryString(headers.Path()->value()));

  }

  auto canonical_request = Utility::createCanonicalRequest(

      headers.Method()->value().getStringView(), headers.Path()->value().getStringView(),

      canonical_headers,

      content_hash.empty() ? SignatureConstants::HashedEmptyString : content_hash,

      Utility::shouldNormalizeUriPath(service_name_), Utility::useDoubleUriEncode(service_name_));

  ENVOY_LOG(debug, "Canonical request:\n{}", canonical_request);

  const auto string_to_sign = createStringToSign(canonical_request, long_date, credential_scope);

  ENVOY_LOG(debug, "String to sign:\n{}", string_to_sign);

  const auto signature =

      createSignature(credentials.accessKeyId().value(), credentials.secretAccessKey().value(),

                      short_date, string_to_sign, override_region);

  if (query_string_) {

    query_params.add(SignatureQueryParameterValues::AmzSignature, signature);

    headers.setPath(query_params.replaceQueryString(Http::HeaderString(headers.getPathValue())));

    query_params.overwrite(SignatureQueryParameterValues::AmzSignature, "*****");

    if (query_params.getFirstValue(SignatureQueryParameterValues::AmzSecurityToken)) {

      query_params.overwrite(SignatureQueryParameterValues::AmzSecurityToken, "*****");

    }

    auto sanitised_query_string =

        query_params.replaceQueryString(Http::HeaderString(headers.getPathValue()));

    ENVOY_LOG(debug, "Query string signing - New path (sanitised): {}", sanitised_query_string);

  } else {

    const auto authorization_header = createAuthorizationHeader(

        credentials.accessKeyId().value(), credential_scope, canonical_headers, signature);

    headers.setCopy(Http::CustomHeaders::get().Authorization, authorization_header);

    std::vector<std::string> sanitised_header =

        absl::StrSplit(authorization_header, absl::ByString("Signature="));

    ENVOY_LOG(debug, "Header signing - Authorization header (sanitised): {}Signature=*****",

              sanitised_header[0]);

  }

  return absl::OkStatus();

}

                                        const absl::string_view override_region) {

  headers.remove(Http::CustomHeaders::get().Authorization);

  headers.remove(SignatureHeaders::get().SecurityToken);

  if (session_token.has_value() && !session_token.value().empty()) {

    headers.setCopy(SignatureHeaders::get().SecurityToken, session_token.value());

  }

  headers.setCopy(SignatureHeaders::get().Date, long_date);

  addRegionHeader(headers, override_region);

}

std::string SignerBaseImpl::createContentHash(Http::RequestMessage& message, bool sign_body) const {

  if (!sign_body) {

    return std::string(SignatureConstants::HashedEmptyString);

  }

  auto& crypto_util = Envoy::Common::Crypto::UtilitySingleton::get();

  const auto content_hash = message.body().length() > 0

                                ? Hex::encode(crypto_util.getSha256Digest(message.body()))

                                : std::string(SignatureConstants::HashedEmptyString);

  return content_hash;

}

                                              absl::string_view credential_scope) const {

  return fmt::format(SignatureConstants::AuthorizationCredentialFormat, access_key_id,

                     credential_scope);

}

                                       const uint16_t expiration_time) const {

  query_params.add(SignatureQueryParameterValues::AmzAlgorithm, getAlgorithmString());

  query_params.add(SignatureQueryParameterValues::AmzDate, long_date);

  query_params.add(SignatureQueryParameterValues::AmzExpires, std::to_string(expiration_time));

  if (session_token.has_value()) {

    query_params.add(SignatureQueryParameterValues::AmzSecurityToken,

                     Envoy::Http::Utility::PercentEncoding::urlEncode(session_token.value()));

  }

  query_params.add(SignatureQueryParameterValues::AmzCredential,

                   Utility::encodeQueryComponentPreservingPlus(credential));

  query_params.add(SignatureQueryParameterValues::AmzSignedHeaders,

                   Utility::encodeQueryComponentPreservingPlus(

                       Utility::joinCanonicalHeaderNames(signed_headers)));

}