Skip to content

Commit 52f97d4

Browse files
halter73Copilot
andcommitted
test: implement MRTR tampered-state and capability-check conformance scenarios
Adds the two SEP-2322 ConformanceServer tools that RunMrtrConformanceTest previously skipped as "not yet implemented": - test_input_required_result_tampered_state: R1 issues an HMAC-signed requestState; R2 with a tampered requestState surfaces a -32602 JSON-RPC error (McpProtocolException propagates as a protocol error, not an isError CallToolResult). - test_input_required_result_capabilities: emits inputRequests only for the capabilities the client declared on the per-request _meta clientCapabilities envelope (read via JsonRpcMessageContext.ClientCapabilities). Removes the per-row Skip from both [InlineData] rows so they run under the same HasMrtrScenarios() gate as the other MRTR scenarios. Verified live: 14/14 RunMrtrConformanceTest scenarios pass against the local compat/conformance-draft build (which emits the 2026-07-28 wire string). Adds in-process wire-level regression coverage in MrtrProtocolTests (TamperedRequestState_ReturnsJsonRpcError and CapabilityCheck_OnlyEmitsInputRequestsForDeclaredCapabilities) so both behaviors stay verified in CI even while the published conformance package's draft wire string lags this SDK. Co-authored-by: Copilot <[email protected]>
1 parent fb4f2f1 commit 52f97d4

3 files changed

Lines changed: 304 additions & 10 deletions

File tree

‎tests/ModelContextProtocol.AspNetCore.Tests/MrtrProtocolTests.cs‎

Lines changed: 162 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -56,6 +56,98 @@ private async Task StartAsync()
5656
Name = "throwing-tool",
5757
Description = "A tool that throws immediately"
5858
}),
59+
McpServerTool.Create(
60+
static CallToolResult (RequestContext<CallToolRequestParams> context) =>
61+
{
62+
// Mirrors ConformanceServer.Tools.IncompleteResultTools.ToolWithTamperedState:
63+
// R1 (no requestState) issues a requestState; R2 with a tampered requestState
64+
// surfaces a JSON-RPC error rather than a complete result or a re-prompt.
65+
if (context.Params!.RequestState is { } state)
66+
{
67+
if (state != "valid-request-state-token")
68+
{
69+
throw new McpProtocolException(
70+
"requestState failed integrity verification.", McpErrorCode.InvalidParams);
71+
}
72+
73+
return new CallToolResult { Content = [new TextContentBlock { Text = "state-ok" }] };
74+
}
75+
76+
throw new InputRequiredException(
77+
new Dictionary<string, InputRequest>
78+
{
79+
["confirm"] = InputRequest.ForElicitation(new ElicitRequestParams
80+
{
81+
Message = "Please confirm",
82+
RequestedSchema = new ElicitRequestParams.RequestSchema
83+
{
84+
Properties = new Dictionary<string, ElicitRequestParams.PrimitiveSchemaDefinition>
85+
{
86+
["ok"] = new ElicitRequestParams.BooleanSchema(),
87+
},
88+
Required = ["ok"],
89+
},
90+
}),
91+
},
92+
requestState: "valid-request-state-token");
93+
},
94+
new McpServerToolCreateOptions
95+
{
96+
Name = "tampered-state-tool",
97+
Description = "Rejects a tampered requestState with a JSON-RPC error"
98+
}),
99+
McpServerTool.Create(
100+
static CallToolResult (RequestContext<CallToolRequestParams> context) =>
101+
{
102+
// Mirrors ConformanceServer.Tools.IncompleteResultTools.ToolWithCapabilityCheck:
103+
// emit inputRequests only for capabilities declared on the per-request _meta envelope.
104+
var caps = context.JsonRpcRequest.Context?.ClientCapabilities;
105+
var inputRequests = new Dictionary<string, InputRequest>();
106+
107+
if (caps?.Sampling is not null)
108+
{
109+
inputRequests["capital_question"] = InputRequest.ForSampling(new CreateMessageRequestParams
110+
{
111+
Messages =
112+
[
113+
new SamplingMessage
114+
{
115+
Role = Role.User,
116+
Content = [new TextContentBlock { Text = "What is the capital of France?" }],
117+
},
118+
],
119+
MaxTokens = 100,
120+
});
121+
}
122+
123+
if (caps?.Elicitation is not null)
124+
{
125+
inputRequests["user_name"] = InputRequest.ForElicitation(new ElicitRequestParams
126+
{
127+
Message = "What is your name?",
128+
RequestedSchema = new ElicitRequestParams.RequestSchema
129+
{
130+
Properties = new Dictionary<string, ElicitRequestParams.PrimitiveSchemaDefinition>
131+
{
132+
["name"] = new ElicitRequestParams.StringSchema(),
133+
},
134+
Required = ["name"],
135+
},
136+
});
137+
}
138+
139+
if (inputRequests.Count == 0)
140+
{
141+
return new CallToolResult { Content = [new TextContentBlock { Text = "no-caps" }] };
142+
}
143+
144+
throw new InputRequiredException(inputRequests);
145+
},
146+
new McpServerToolCreateOptions
147+
{
148+
Name = "capability-check-tool",
149+
Description = "Gates inputRequests on the per-request _meta clientCapabilities envelope"
150+
}),
59151
]).WithHttpTransport(options => options.Stateless = false);
60152

61153
_app = Builder.Build();
@@ -124,6 +216,76 @@ public async Task RetryWithInvalidRequestState_ReturnsJsonRpcError()
124216
$"Expected JsonRpcResponse or JsonRpcError, got {message?.GetType().Name}");
125217
}
126218

219+
[Fact]
220+
public async Task TamperedRequestState_ReturnsJsonRpcError()
221+
{
222+
await StartAsync();
223+
await InitializeWithMrtrAsync();
224+
225+
// Round 1: no requestState -> InputRequiredResult carrying the issued requestState.
226+
using var r1 = await PostJsonRpcAsync(CallTool("tampered-state-tool"));
227+
var r1Response = await AssertSingleSseResponseAsync(r1);
228+
var r1Result = Assert.IsType<JsonObject>(r1Response.Result);
229+
Assert.Equal("input_required", r1Result["resultType"]?.GetValue<string>());
230+
231+
var requestState = r1Result["requestState"]!.GetValue<string>();
232+
var inputKey = r1Result["inputRequests"]!.AsObject().First().Key;
233+
234+
// Round 2: tamper the requestState the way the conformance harness does and retry.
235+
// The tool MUST reject it with a JSON-RPC error (not a complete result, not a re-prompt).
236+
var inputResponse = InputResponse.FromElicitResult(new ElicitResult { Action = "accept" });
237+
var retryParams = new JsonObject
238+
{
239+
["name"] = "tampered-state-tool",
240+
["arguments"] = new JsonObject(),
241+
["requestState"] = requestState + "-TAMPERED",
242+
["inputResponses"] = new JsonObject
243+
{
244+
[inputKey] = JsonSerializer.SerializeToNode(inputResponse, McpJsonUtilities.DefaultOptions.GetTypeInfo(typeof(InputResponse)))
245+
},
246+
};
247+
248+
using var r2 = await PostJsonRpcAsync(Request("tools/call", retryParams.ToJsonString()));
249+
Assert.Equal(HttpStatusCode.OK, r2.StatusCode);
250+
251+
var sseData = Assert.Single(await ReadSseAsync(r2.Content).ToListAsync(TestContext.Current.CancellationToken));
252+
var message = JsonSerializer.Deserialize<JsonRpcMessage>(sseData, McpJsonUtilities.DefaultOptions);
253+
var error = Assert.IsType<JsonRpcError>(message);
254+
Assert.Equal((int)McpErrorCode.InvalidParams, error.Error.Code);
255+
}
256+
257+
[Fact]
258+
public async Task CapabilityCheck_OnlyEmitsInputRequestsForDeclaredCapabilities()
259+
{
260+
await StartAsync();
261+
await InitializeWithMrtrAsync();
262+
263+
// Per SEP-2575 the client declares capabilities per request in
264+
// _meta['io.modelcontextprotocol/clientCapabilities']. Declare ONLY sampling: the tool
265+
// must emit a sampling/createMessage inputRequest but no elicitation/create.
266+
var callParams = new JsonObject
267+
{
268+
["name"] = "capability-check-tool",
269+
["arguments"] = new JsonObject(),
270+
["_meta"] = new JsonObject
271+
{
272+
["io.modelcontextprotocol/clientCapabilities"] = new JsonObject
273+
{
274+
["sampling"] = new JsonObject(),
275+
},
276+
},
277+
};
278+
279+
using var response = await PostJsonRpcAsync(Request("tools/call", callParams.ToJsonString()));
280+
var rpcResponse = await AssertSingleSseResponseAsync(response);
281+
var resultObj = Assert.IsType<JsonObject>(rpcResponse.Result);
282+
Assert.Equal("input_required", resultObj["resultType"]?.GetValue<string>());
283+
284+
var inputRequests = resultObj["inputRequests"]!.AsObject();
285+
Assert.Contains(inputRequests, kvp => kvp.Value!["method"]?.GetValue<string>() == "sampling/createMessage");
286+
Assert.DoesNotContain(inputRequests, kvp => kvp.Value!["method"]?.GetValue<string>() == "elicitation/create");
287+
}
288+
127289
[Fact]
128290
public async Task SessionDelete_CancelsPendingMrtrContinuation()
129291
{

‎tests/ModelContextProtocol.AspNetCore.Tests/ServerConformanceTests.cs‎

Lines changed: 9 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -185,14 +185,13 @@ public async Task RunConformanceTest_HttpCustomHeaderServerValidation()
185185
// installed conformance package ships SEP-2322 scenarios <em>and</em> emits this SDK's
186186
// draft wire string (see <see cref="NodeHelpers.HasMrtrScenarios"/>).
187187
//
188-
// Two scenarios (input-required-result-tampered-state and input-required-result-capability-check)
189-
// require advanced server-side logic not yet built into the ConformanceServer:
190-
// - tampered-state: HMAC integrity protection on requestState. Server-implementer concern
191-
// outside the SDK wire surface; would need a sample tool implementing the pattern.
192-
// - capability-check: per-request reading of clientCapabilities to gate which inputRequests
193-
// are returned. SDK exposes capabilities via JsonRpcMessageContext but no current tool
194-
// conditionally emits inputRequests based on them.
195-
// These rows are skipped until matching tool implementations are added.
188+
// input-required-result-tampered-state and input-required-result-capability-check are
189+
// implemented by ConformanceServer.Tools.IncompleteResultTools.ToolWithTamperedState
190+
// (HMAC-protected requestState; a tampered requestState surfaces a -32602 JSON-RPC error)
191+
// and ToolWithCapabilityCheck (gates inputRequests on the per-request
192+
// _meta clientCapabilities envelope). Both behaviors also have in-process wire-level
193+
// regression coverage in MrtrProtocolTests so they stay verified even while the published
194+
// conformance package's draft wire string lags this SDK.
196195
[Theory]
197196
[InlineData("input-required-result-basic-elicitation")]
198197
[InlineData("input-required-result-basic-sampling")]
@@ -204,8 +203,8 @@ public async Task RunConformanceTest_HttpCustomHeaderServerValidation()
204203
[InlineData("input-required-result-non-tool-request")]
205204
[InlineData("input-required-result-result-type")]
206205
[InlineData("input-required-result-unsupported-methods")]
207-
[InlineData("input-required-result-tampered-state", Skip = "Requires HMAC-protected requestState pattern in ConformanceServer tools (not yet implemented).")]
208-
[InlineData("input-required-result-capability-check", Skip = "Requires per-request capability-aware inputRequest gating in ConformanceServer tools (not yet implemented).")]
206+
[InlineData("input-required-result-tampered-state")]
207+
[InlineData("input-required-result-capability-check")]
209208
[InlineData("input-required-result-ignore-extra-params")]
210209
[InlineData("input-required-result-validate-input")]
211210
public async Task RunMrtrConformanceTest(string scenario)

‎tests/ModelContextProtocol.ConformanceServer/Tools/IncompleteResultTools.cs‎

Lines changed: 133 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,8 @@
44
using ModelContextProtocol.Protocol;
55
using ModelContextProtocol.Server;
66
using System.ComponentModel;
7+
using System.Security.Cryptography;
8+
using System.Text;
79
using System.Text.Json;
810
using System.Text.Json.Nodes;
911

@@ -263,6 +265,137 @@ public static CallToolResult ToolForMissingResponse(RequestContext<CallToolReque
263265
});
264266
}
265267

268+
// ──── A12: Tampered requestState rejection (integrity protection) ───────
269+
// SEP-2322 recommends integrity-protecting requestState (e.g. an HMAC signature)
270+
// so a client cannot forge or mutate it. R1 returns a signed requestState; R2 with
271+
// a tampered requestState fails verification and surfaces a JSON-RPC error (not an
272+
// isError CallToolResult and not a re-prompt).
273+
private static readonly byte[] s_requestStateKey = Encoding.UTF8.GetBytes("mrtr-conformance-hmac-key-v1");
274+
275+
[McpServerTool(Name = "test_input_required_result_tampered_state")]
276+
[Description("SEP-2322 A12: R1 returns an HMAC-signed requestState; R2 rejects a tampered requestState with a JSON-RPC error.")]
277+
public static CallToolResult ToolWithTamperedState(RequestContext<CallToolRequestParams> context)
278+
{
279+
if (context.Params!.RequestState is { } state)
280+
{
281+
if (!VerifyRequestState(state))
282+
{
283+
throw new McpProtocolException(
284+
"requestState failed integrity verification (tampered or invalid signature).",
285+
McpErrorCode.InvalidParams);
286+
}
287+
288+
return TextResult("tampered-state-ok: requestState integrity verified");
289+
}
290+
291+
throw new InputRequiredException(
292+
inputRequests: new Dictionary<string, InputRequest>
293+
{
294+
["confirm"] = InputRequest.ForElicitation(new ElicitRequestParams
295+
{
296+
Message = "Please confirm",
297+
RequestedSchema = new ElicitRequestParams.RequestSchema
298+
{
299+
Properties = new Dictionary<string, ElicitRequestParams.PrimitiveSchemaDefinition>
300+
{
301+
["ok"] = new ElicitRequestParams.BooleanSchema(),
302+
},
303+
Required = ["ok"],
304+
},
305+
}),
306+
},
307+
requestState: SignRequestState());
308+
}
309+
310+
// ──── A13: Respect client capabilities ──────────────────────────────────
311+
// Per SEP-2575 the client declares its capabilities in the per-request
312+
// _meta['io.modelcontextprotocol/clientCapabilities'] envelope (surfaced on
313+
// JsonRpcMessageContext.ClientCapabilities). The server MUST only emit inputRequests
314+
// for capabilities the client advertised on this request.
315+
[McpServerTool(Name = "test_input_required_result_capabilities")]
316+
[Description("SEP-2322 A13: returns inputRequests only for the capabilities the client declared in per-request _meta.")]
317+
public static CallToolResult ToolWithCapabilityCheck(RequestContext<CallToolRequestParams> context)
318+
{
319+
if (context.Params!.InputResponses is { Count: > 0 })
320+
{
321+
return TextResult("capability-check-ok: received input responses");
322+
}
323+
324+
var capabilities = context.JsonRpcRequest.Context?.ClientCapabilities;
325+
var inputRequests = new Dictionary<string, InputRequest>();
326+
327+
if (capabilities?.Sampling is not null)
328+
{
329+
inputRequests["capital_question"] = InputRequest.ForSampling(new CreateMessageRequestParams
330+
{
331+
Messages =
332+
[
333+
new SamplingMessage
334+
{
335+
Role = Role.User,
336+
Content = [new TextContentBlock { Text = "What is the capital of France?" }],
337+
},
338+
],
339+
MaxTokens = 100,
340+
});
341+
}
342+
343+
if (capabilities?.Elicitation is not null)
344+
{
345+
inputRequests["user_name"] = InputRequest.ForElicitation(new ElicitRequestParams
346+
{
347+
Message = "What is your name?",
348+
RequestedSchema = new ElicitRequestParams.RequestSchema
349+
{
350+
Properties = new Dictionary<string, ElicitRequestParams.PrimitiveSchemaDefinition>
351+
{
352+
["name"] = new ElicitRequestParams.StringSchema(),
353+
},
354+
Required = ["name"],
355+
},
356+
});
357+
}
358+
359+
if (capabilities?.Roots is not null)
360+
{
361+
inputRequests["client_roots"] = InputRequest.ForRootsList(new ListRootsRequestParams());
362+
}
363+
364+
if (inputRequests.Count == 0)
365+
{
366+
return TextResult("capability-check-ok: client declared no MRTR-capable features");
367+
}
368+
369+
throw new InputRequiredException(inputRequests);
370+
}
371+
372+
private static string SignRequestState()
373+
{
374+
var nonce = Guid.NewGuid().ToString("N");
375+
return $"{nonce}.{ComputeSignature(nonce)}";
376+
}
377+
378+
private static bool VerifyRequestState(string state)
379+
{
380+
var separator = state.LastIndexOf('.');
381+
if (separator <= 0 || separator == state.Length - 1)
382+
{
383+
return false;
384+
}
385+
386+
var nonce = state[..separator];
387+
var signature = state[(separator + 1)..];
388+
return CryptographicOperations.FixedTimeEquals(
389+
Encoding.UTF8.GetBytes(signature),
390+
Encoding.UTF8.GetBytes(ComputeSignature(nonce)));
391+
}
392+
393+
private static string ComputeSignature(string nonce)
394+
{
395+
using var hmac = new HMACSHA256(s_requestStateKey);
396+
return Convert.ToHexString(hmac.ComputeHash(Encoding.UTF8.GetBytes(nonce)));
397+
}
398+
266399
private static CallToolResult TextResult(string text) => new()
267400
{
268401
Content = [new TextContentBlock { Text = text }],

0 commit comments

Comments
 (0)