AWS SDK C++ PutObject intermittent BadDigest (CRC64NVME) with std::stringstream

[test0101010101011]

I'm encountering an intermittent checksum mismatch when uploading to S3 using the AWS SDK for C++.

Environment:

• OS: Rocky Linux 8.10
• AWS SDK for C++: 1.11.706
• Upload target: Amazon S3
• Upload API: "PutObject"
• Data source: Arrow → Parquet written to an in-memory buffer

The Parquet file is written to an Arrow "BufferOutputStream", and the resulting buffer is uploaded to S3.

Most uploads succeed, but occasionally I get the following error:

BadDigest: The CRC64NVME you specified did not match the calculated checksum

If I explicitly set the checksum algorithm to SHA256, I instead get:

BadDigest: The SHA256 you specified did not match the calculated checksum

So the error changes depending on the algorithm, but the result is always a checksum mismatch.

---

Upload Code

Below is the relevant part of my upload logic.

I added explicit validation for the stream size and state before sending the request.

std::shared_ptrarrow::Buffer buffer;
PARQUET_THROW_NOT_OK(stream->Finish().Value(&buffer));

for (int i = 0; i < 3; i++) {

std::string safe_copy(
    reinterpret_cast<const char*>(buffer->data()),
    buffer->size()
);

auto data_stream = Aws::MakeShared<Aws::StringStream>("");

data_stream->write(safe_copy.data(), safe_copy.size());

auto written = data_stream->tellp();

if (written != static_cast<std::streampos>(safe_copy.size())) {
    std::cout << "ERROR: stream size mismatch. retry : " << i << std::endl;
    continue;
}

data_stream->seekg(0, std::ios::beg);

if (!data_stream->good()) {
    std::cout << "ERROR: stream state invalid. retry : " << i << std::endl;
    continue;
}

Aws::S3::Model::PutObjectRequest object_request;

object_request.SetBucket(athena_bucket);
object_request.SetKey(file_path.c_str());
object_request.SetBody(data_stream);

auto put_object_outcome = s3_client->PutObject(object_request);

if (put_object_outcome.IsSuccess()) {
    break;
}

}

---

What I've already verified

I explicitly verified the following:

• The buffer size is correct
• "tellp()" matches the expected size
• The stream state ("good()") is valid
• The stream is rewound with "seekg(0)"
• A new stream is created for each retry
• The issue occurs intermittently
• The same data often succeeds on retry

I also tried explicitly setting:

object_request.SetContentLength(buffer->size());

but the same error still occurs.

---

Checksum Configuration

I tried changing the checksum configuration as follows:

config.requestChecksumCalculation =

Aws::Client::RequestChecksumCalculation::WHEN_REQUIRED;

However, I cannot change the WHEN_REQUIRED value within the code.

Aws::Client::ClientConfiguration does not have requestChecksumCalculation.

---

Observations

• The error appears before any retry logic in the SDK
• The failure is not deterministic
• Most uploads succeed
• Occasionally S3 returns "BadDigest"

---

Question

Has anyone encountered intermittent checksum mismatches when uploading with "std::stringstream" using the AWS SDK for C++?

Could this be related to:

• the SDK's automatic CRC64NVME calculation
• "std::istream" body handling
• or something specific to "std::stringstream" with binary payloads?

Any insight would be appreciated.

[sbiscigl]

AWS SDK for C++: 1.11.706

this is a known problem between versions 1.11.621 (August 6, 2025) and 1.11.740 (February 2, 2026), it was fixed with the change #3706.

please udpdate your version