Fix integer overflow in BufferedStream.WriteToUnderlyingStreamAsync for large buffers

[Copilot]

Description

BufferedStream.WriteToUnderlyingStreamAsync throws OverflowException when writing buffers larger than ~1GB due to signed integer overflow in the buffer size calculation. The synchronous Write methods were already fixed with (uint) casting, but the async path was missed.

Changes:

• Added (uint) cast to totalUserBytes + buffer.Length comparison in WriteToUnderlyingStreamAsync to match the existing fix in synchronous Write methods (lines 871, 942)
• Added WriteAsyncFromMemory_InputSizeLargerThanHalfOfMaxInt_ShouldSuccess test to verify async path handles large buffers correctly

// Before (throws OverflowException)
useBuffer = (totalUserBytes + buffer.Length < (_bufferSize + _bufferSize));

// After (handles up to int.MaxValue)
useBuffer = ((uint)totalUserBytes + buffer.Length < (_bufferSize + _bufferSize));

Customer Impact

Applications that write large buffers (>1GB) to BufferedStream via async methods fail with OverflowException. Common scenario: MemoryStream.CopyToAsync to BufferedStream with large content.

Regression

No, existing code path bug. Sync methods already fixed, async path oversight.

Testing

• All 474 BufferedStream tests pass
• OuterLoop tests verify handling of int.MaxValue/2 + 1 sized buffers for sync and async paths
• New test explicitly covers async large buffer scenario

Risk

Low. Single-line arithmetic fix matching proven pattern already in use for synchronous methods. Overflow prevention is safer than overflow.

Original prompt

Problem

In BufferedStream.WriteToUnderlyingStreamAsync, there's a potential integer overflow when calculating whether to use the buffer. This occurs when writing very large buffers (close to or exceeding ~1GB).

The issue is at line 1081 in src/libraries/System.Private.CoreLib/src/System/IO/BufferedStream.cs:

checked
{
    // We do not expect buffer sizes big enough for an overflow, but if it happens, lets fail early:
    totalUserBytes = _writePos + buffer.Length;
    useBuffer = (totalUserBytes + buffer.Length < (_bufferSize + _bufferSize));
}

When buffer.Length is very large, the expression totalUserBytes + buffer.Length can overflow because it's using signed int arithmetic, causing an OverflowException to be thrown.

Root Cause

The synchronous Write methods have already been fixed to use (uint) casting to prevent overflow:

// Line 871 in Write(byte[], int, int):
useBuffer = ((uint)totalUserbytes + count < (_bufferSize + _bufferSize));

// Line 942 in Write(ReadOnlySpan<byte>):
useBuffer = ((uint)totalUserbytes + buffer.Length < (_bufferSize + _bufferSize));

However, the async version in WriteToUnderlyingStreamAsync is missing this cast.

Fix

Change line 1081 from:

useBuffer = (totalUserBytes + buffer.Length < (_bufferSize + _bufferSize));

To:

useBuffer = ((uint)totalUserBytes + buffer.Length < (_bufferSize + _bufferSize));

This matches the fix already applied to the synchronous Write methods and prevents the overflow by promoting the arithmetic to unsigned.

Related Issue

This fix addresses the OverflowException described in #117789, which occurs when MemoryStream.CopyToAsync writes large buffers to a BufferedStream.

This pull request was created from Copilot chat.

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-io
See info in area-owners.md if you want to be subscribed.

[stephentoub]

/azp run runtime-libraries-coreclr outerloop

[azure-pipelines]

Azure Pipelines successfully started running 1 pipeline(s).

[Copilot]

Pull request overview

This PR fixes an integer overflow bug in BufferedStream.WriteToUnderlyingStreamAsync that causes an OverflowException when writing buffers larger than ~1GB. The synchronous Write methods were previously fixed with (uint) casting, but the async path was overlooked. This change brings the async implementation in line with the synchronous methods.

Key Changes:

• Added (uint) cast to the buffer size comparison in WriteToUnderlyingStreamAsync to prevent signed integer overflow
• Added test coverage for async writes with large buffers (>int.MaxValue/2)

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated no comments.

File	Description
src/libraries/System.Private.CoreLib/src/System/IO/BufferedStream.cs	Applied (uint) cast to totalUserBytes + buffer.Length comparison in WriteToUnderlyingStreamAsync (line 1082) to match the existing fix in synchronous Write methods, preventing overflow for buffers larger than 1GB
src/libraries/System.Runtime/tests/System.IO.Tests/BufferedStream/BufferedStreamTests.cs	Added WriteAsyncFromMemory_InputSizeLargerThanHalfOfMaxInt_ShouldSuccess test to verify the async write path correctly handles large buffers without throwing OverflowException

[adamsitnik]

LGTM!