Fix base64 deserialization when JSON encoder escapes forward slashes (#1342)
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>
This commit is contained in:
Copilot
GitHub
parent
74622d0c9c
commit
774a1dba35
2 changed files with 710 additions and 48 deletions
|
|
@ -1,4 +1,5 @@
|
|||
using ModelContextProtocol.Protocol;
|
||||
using System.Text;
|
||||
using System.Text.Json;
|
||||
|
||||
namespace ModelContextProtocol.Tests.Protocol;
|
||||
|
|
@ -290,4 +291,275 @@ public class ContentBlockTests
|
|||
{
|
||||
Assert.ThrowsAny<ArgumentException>(() => AudioContentBlock.FromBytes((byte[])[1, 2, 3], mimeType!));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ImageContentBlock_Deserialization_HandlesEscapedForwardSlashInBase64()
|
||||
{
|
||||
// Base64 uses '/' which some JSON encoders escape as '\/' (valid JSON).
|
||||
// The converter must unescape before storing the base64 UTF-8 bytes.
|
||||
byte[] originalBytes = [0xFF, 0xD8, 0xFF, 0xE0]; // sample bytes that produce '/' in base64
|
||||
string base64 = Convert.ToBase64String(originalBytes); // "/9j/4A=="
|
||||
Assert.Contains("/", base64);
|
||||
|
||||
// Simulate a JSON encoder that escapes '/' as '\/'
|
||||
string json = $$"""{"type":"image","data":"{{base64.Replace("/", "\\/")}}","mimeType":"image/jpeg"}""";
|
||||
|
||||
var deserialized = JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions);
|
||||
var image = Assert.IsType<ImageContentBlock>(deserialized);
|
||||
Assert.Equal(base64, System.Text.Encoding.UTF8.GetString(image.Data.ToArray()));
|
||||
Assert.Equal(originalBytes, image.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AudioContentBlock_Deserialization_HandlesEscapedForwardSlashInBase64()
|
||||
{
|
||||
byte[] originalBytes = [0xFF, 0xD8, 0xFF, 0xE0];
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
Assert.Contains("/", base64);
|
||||
|
||||
string json = $$"""{"type":"audio","data":"{{base64.Replace("/", "\\/")}}","mimeType":"audio/wav"}""";
|
||||
|
||||
var deserialized = JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions);
|
||||
var audio = Assert.IsType<AudioContentBlock>(deserialized);
|
||||
Assert.Equal(base64, System.Text.Encoding.UTF8.GetString(audio.Data.ToArray()));
|
||||
Assert.Equal(originalBytes, audio.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Provides test data for base64 roundtrip tests. Each entry is a byte array that exercises
|
||||
/// different base64 encoding characteristics:
|
||||
/// - Various lengths producing 0, 1, or 2 padding characters
|
||||
/// - Bytes that produce all 64 base64 alphabet characters including '+' and '/'
|
||||
/// </summary>
|
||||
public static TheoryData<byte[]> Base64TestData()
|
||||
{
|
||||
var data = new TheoryData<byte[]>
|
||||
{
|
||||
Array.Empty<byte>(), // empty: ""
|
||||
new byte[] { 0x00 }, // 1 byte, 2 padding chars: "AA=="
|
||||
new byte[] { 0x00, 0x01 }, // 2 bytes, 1 padding char: "AAE="
|
||||
new byte[] { 0x00, 0x01, 0x02 }, // 3 bytes, no padding: "AAEC"
|
||||
new byte[] { 0xFF, 0xD8, 0xFF, 0xE0 }, // produces '/' in base64: "/9j/4A=="
|
||||
new byte[] { 0xFB, 0xEF, 0xBE }, // produces '+' in base64: "++++"
|
||||
};
|
||||
|
||||
// All 256 byte values to exercise the full base64 alphabet
|
||||
byte[] allBytes = new byte[256];
|
||||
for (int i = 0; i < 256; i++)
|
||||
{
|
||||
allBytes[i] = (byte)i;
|
||||
}
|
||||
data.Add(allBytes);
|
||||
|
||||
// Larger payload (1024 bytes)
|
||||
byte[] largePayload = new byte[1024];
|
||||
new Random(42).NextBytes(largePayload);
|
||||
data.Add(largePayload);
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void ImageContentBlock_FromBytes_RoundtripsCorrectly(byte[] originalBytes)
|
||||
{
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
var image = ImageContentBlock.FromBytes(originalBytes, "image/png");
|
||||
|
||||
Assert.Equal("image/png", image.MimeType);
|
||||
Assert.Equal(originalBytes, image.DecodedData.ToArray());
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(image.Data.ToArray()));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void ImageContentBlock_DataSetter_RoundtripsCorrectly(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
|
||||
|
||||
var image = new ImageContentBlock { Data = base64Utf8, MimeType = "image/png" };
|
||||
|
||||
Assert.Equal(base64Utf8, image.Data.ToArray());
|
||||
Assert.Equal(originalBytes, image.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void ImageContentBlock_JsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
|
||||
|
||||
var original = new ImageContentBlock { Data = base64Utf8, MimeType = "image/png" };
|
||||
string json = JsonSerializer.Serialize<ContentBlock>(original, McpJsonUtilities.DefaultOptions);
|
||||
var deserialized = Assert.IsType<ImageContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(base64Utf8, deserialized.Data.ToArray());
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void ImageContentBlock_FromBytes_JsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
var original = ImageContentBlock.FromBytes(originalBytes, "image/jpeg");
|
||||
string json = JsonSerializer.Serialize<ContentBlock>(original, McpJsonUtilities.DefaultOptions);
|
||||
var deserialized = Assert.IsType<ImageContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(deserialized.Data.ToArray()));
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void ImageContentBlock_EscapedJsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
// Simulate JSON encoder that escapes '/' as '\/'
|
||||
string json = $$"""{"type":"image","data":"{{base64.Replace("/", "\\/")}}","mimeType":"image/png"}""";
|
||||
|
||||
var deserialized = Assert.IsType<ImageContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(base64, Encoding.UTF8.GetString(deserialized.Data.ToArray()));
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ImageContentBlock_DataSetterInvalidatesCachedDecodedData()
|
||||
{
|
||||
byte[] bytes1 = [1, 2, 3];
|
||||
var image = ImageContentBlock.FromBytes(bytes1, "image/png");
|
||||
|
||||
// Access DecodedData to populate cache
|
||||
Assert.Equal(bytes1, image.DecodedData.ToArray());
|
||||
|
||||
// Set new Data to invalidate cache
|
||||
byte[] newBytes = [4, 5, 6];
|
||||
string newBase64 = Convert.ToBase64String(newBytes);
|
||||
image.Data = Encoding.UTF8.GetBytes(newBase64);
|
||||
|
||||
Assert.Equal(newBytes, image.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void AudioContentBlock_FromBytes_RoundtripsCorrectly(byte[] originalBytes)
|
||||
{
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
var audio = AudioContentBlock.FromBytes(originalBytes, "audio/wav");
|
||||
|
||||
Assert.Equal("audio/wav", audio.MimeType);
|
||||
Assert.Equal(originalBytes, audio.DecodedData.ToArray());
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(audio.Data.ToArray()));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void AudioContentBlock_DataSetter_RoundtripsCorrectly(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
|
||||
|
||||
var audio = new AudioContentBlock { Data = base64Utf8, MimeType = "audio/wav" };
|
||||
|
||||
Assert.Equal(base64Utf8, audio.Data.ToArray());
|
||||
Assert.Equal(originalBytes, audio.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void AudioContentBlock_JsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
|
||||
|
||||
var original = new AudioContentBlock { Data = base64Utf8, MimeType = "audio/wav" };
|
||||
string json = JsonSerializer.Serialize<ContentBlock>(original, McpJsonUtilities.DefaultOptions);
|
||||
var deserialized = Assert.IsType<AudioContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(base64Utf8, deserialized.Data.ToArray());
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void AudioContentBlock_FromBytes_JsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
var original = AudioContentBlock.FromBytes(originalBytes, "audio/mp3");
|
||||
string json = JsonSerializer.Serialize<ContentBlock>(original, McpJsonUtilities.DefaultOptions);
|
||||
var deserialized = Assert.IsType<AudioContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(deserialized.Data.ToArray()));
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void AudioContentBlock_EscapedJsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
string json = $$"""{"type":"audio","data":"{{base64.Replace("/", "\\/")}}","mimeType":"audio/wav"}""";
|
||||
|
||||
var deserialized = Assert.IsType<AudioContentBlock>(
|
||||
JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(base64, Encoding.UTF8.GetString(deserialized.Data.ToArray()));
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AudioContentBlock_DataSetterInvalidatesCachedDecodedData()
|
||||
{
|
||||
byte[] bytes1 = [1, 2, 3];
|
||||
var audio = AudioContentBlock.FromBytes(bytes1, "audio/wav");
|
||||
|
||||
Assert.Equal(bytes1, audio.DecodedData.ToArray());
|
||||
|
||||
byte[] newBytes = [4, 5, 6];
|
||||
string newBase64 = Convert.ToBase64String(newBytes);
|
||||
audio.Data = Encoding.UTF8.GetBytes(newBase64);
|
||||
|
||||
Assert.Equal(newBytes, audio.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void ImageContentBlock_FromBytes_LazilyEncodesData(byte[] originalBytes)
|
||||
{
|
||||
// FromBytes should only decode when Data is accessed
|
||||
var image = ImageContentBlock.FromBytes(originalBytes, "image/png");
|
||||
|
||||
// First, access DecodedData without touching Data
|
||||
Assert.Equal(originalBytes, image.DecodedData.ToArray());
|
||||
|
||||
// Now access Data and verify it lazily encoded correctly
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(image.Data.ToArray()));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(Base64TestData))]
|
||||
public void AudioContentBlock_FromBytes_LazilyEncodesData(byte[] originalBytes)
|
||||
{
|
||||
var audio = AudioContentBlock.FromBytes(originalBytes, "audio/wav");
|
||||
|
||||
Assert.Equal(originalBytes, audio.DecodedData.ToArray());
|
||||
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(audio.Data.ToArray()));
|
||||
}
|
||||
}
|
||||
|
|
@ -1,4 +1,5 @@
|
|||
using ModelContextProtocol.Protocol;
|
||||
using System.Text;
|
||||
using System.Text.Json;
|
||||
|
||||
namespace ModelContextProtocol.Tests.Protocol;
|
||||
|
|
@ -489,4 +490,129 @@ public static class ResourceContentsTests
|
|||
|
||||
Assert.DoesNotContain("mimeType", json);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public static void BlobResourceContents_Deserialization_HandlesEscapedForwardSlashInBase64()
|
||||
{
|
||||
// Base64 uses '/' which some JSON encoders escape as '\/' (valid JSON).
|
||||
// The converter must unescape before storing the base64 UTF-8 bytes.
|
||||
byte[] originalBytes = [0xFF, 0xD8, 0xFF, 0xE0]; // sample bytes that produce '/' in base64
|
||||
string base64 = Convert.ToBase64String(originalBytes); // "/9j/4A=="
|
||||
Assert.Contains("/", base64);
|
||||
|
||||
// Simulate a JSON encoder that escapes '/' as '\/'
|
||||
string json = $$"""{"uri":"file:///test.bin","blob":"{{base64.Replace("/", "\\/")}}","mimeType":"application/octet-stream"}""";
|
||||
|
||||
var deserialized = JsonSerializer.Deserialize<ResourceContents>(json, McpJsonUtilities.DefaultOptions);
|
||||
var blob = Assert.IsType<BlobResourceContents>(deserialized);
|
||||
Assert.Equal(base64, System.Text.Encoding.UTF8.GetString(blob.Blob.ToArray()));
|
||||
Assert.Equal(originalBytes, blob.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public static void BlobResourceContents_FromBytes_RoundtripsCorrectly(byte[] originalBytes)
|
||||
{
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
var blob = BlobResourceContents.FromBytes(originalBytes, "file:///test.bin", "application/octet-stream");
|
||||
|
||||
Assert.Equal("file:///test.bin", blob.Uri);
|
||||
Assert.Equal("application/octet-stream", blob.MimeType);
|
||||
Assert.Equal(originalBytes, blob.DecodedData.ToArray());
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(blob.Blob.ToArray()));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public static void BlobResourceContents_BlobSetter_RoundtripsCorrectly(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
|
||||
|
||||
var blob = new BlobResourceContents { Blob = base64Utf8, Uri = "file:///test.bin" };
|
||||
|
||||
Assert.Equal(base64Utf8, blob.Blob.ToArray());
|
||||
Assert.Equal(originalBytes, blob.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public static void BlobResourceContents_JsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
byte[] base64Utf8 = Encoding.UTF8.GetBytes(base64);
|
||||
|
||||
var original = new BlobResourceContents
|
||||
{
|
||||
Blob = base64Utf8,
|
||||
Uri = "file:///test.bin",
|
||||
MimeType = "application/octet-stream"
|
||||
};
|
||||
string json = JsonSerializer.Serialize<ResourceContents>(original, McpJsonUtilities.DefaultOptions);
|
||||
var deserialized = Assert.IsType<BlobResourceContents>(
|
||||
JsonSerializer.Deserialize<ResourceContents>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(base64Utf8, deserialized.Blob.ToArray());
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public static void BlobResourceContents_FromBytes_JsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
var original = BlobResourceContents.FromBytes(originalBytes, "file:///test.bin", "application/octet-stream");
|
||||
string json = JsonSerializer.Serialize<ResourceContents>(original, McpJsonUtilities.DefaultOptions);
|
||||
var deserialized = Assert.IsType<BlobResourceContents>(
|
||||
JsonSerializer.Deserialize<ResourceContents>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(deserialized.Blob.ToArray()));
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public static void BlobResourceContents_EscapedJsonRoundtrip_PreservesData(byte[] originalBytes)
|
||||
{
|
||||
string base64 = Convert.ToBase64String(originalBytes);
|
||||
|
||||
string json = $$"""{"uri":"file:///test.bin","blob":"{{base64.Replace("/", "\\/")}}","mimeType":"application/octet-stream"}""";
|
||||
|
||||
var deserialized = Assert.IsType<BlobResourceContents>(
|
||||
JsonSerializer.Deserialize<ResourceContents>(json, McpJsonUtilities.DefaultOptions));
|
||||
|
||||
Assert.Equal(base64, Encoding.UTF8.GetString(deserialized.Blob.ToArray()));
|
||||
Assert.Equal(originalBytes, deserialized.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public static void BlobResourceContents_BlobSetterInvalidatesCachedDecodedData()
|
||||
{
|
||||
byte[] bytes1 = [1, 2, 3];
|
||||
var blob = BlobResourceContents.FromBytes(bytes1, "file:///test.bin");
|
||||
|
||||
Assert.Equal(bytes1, blob.DecodedData.ToArray());
|
||||
|
||||
byte[] newBytes = [4, 5, 6];
|
||||
string newBase64 = Convert.ToBase64String(newBytes);
|
||||
blob.Blob = Encoding.UTF8.GetBytes(newBase64);
|
||||
|
||||
Assert.Equal(newBytes, blob.DecodedData.ToArray());
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[MemberData(nameof(ContentBlockTests.Base64TestData), MemberType = typeof(ContentBlockTests))]
|
||||
public static void BlobResourceContents_FromBytes_LazilyEncodesBlob(byte[] originalBytes)
|
||||
{
|
||||
var blob = BlobResourceContents.FromBytes(originalBytes, "file:///test.bin");
|
||||
|
||||
// Access DecodedData first without touching Blob
|
||||
Assert.Equal(originalBytes, blob.DecodedData.ToArray());
|
||||
|
||||
// Now access Blob and verify lazy encoding
|
||||
string expectedBase64 = Convert.ToBase64String(originalBytes);
|
||||
Assert.Equal(expectedBase64, Encoding.UTF8.GetString(blob.Blob.ToArray()));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue