Skip to content

Commit 6e82adb

Browse files
committed
Reject non application/json POST requests in Spring transports
Signed-off-by: Daniel Garnier-Moiroux <git@garnier.wf>
1 parent ba66498 commit 6e82adb

16 files changed

Lines changed: 622 additions & 0 deletions
Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
/*
2+
* Copyright 2026-2026 the original author or authors.
3+
*/
4+
5+
package io.modelcontextprotocol.server.transport;
6+
7+
import org.springframework.http.InvalidMediaTypeException;
8+
import org.springframework.http.MediaType;
9+
import org.springframework.web.reactive.function.server.ServerRequest;
10+
11+
/**
12+
* Utility methods for working with {@link ServerRequest}. For internal use only.
13+
*
14+
* @author Daniel Garnier-Moiroux
15+
*/
16+
final class WebFluxServerRequestUtils {
17+
18+
private WebFluxServerRequestUtils() {
19+
}
20+
21+
/**
22+
* Checks whether the request's {@code Content-Type} header denotes
23+
* {@code application/json}. Only the media type is compared, case-insensitively;
24+
* parameters such as {@code charset} are ignored. A missing or malformed header is
25+
* rejected.
26+
* <p>
27+
* Requiring {@code application/json} prevents browsers from sending cross-origin
28+
* JSON-RPC messages as CORS "simple requests" (e.g. with {@code text/plain}), which
29+
* would otherwise reach the server without a preflight.
30+
* @param request The incoming server request
31+
* @return {@code true} if the media type is {@code application/json}
32+
*/
33+
static boolean isJsonContentType(ServerRequest request) {
34+
try {
35+
return request.headers().contentType().map(MediaType.APPLICATION_JSON::equalsTypeAndSubtype).orElse(false);
36+
}
37+
catch (InvalidMediaTypeException ex) {
38+
return false;
39+
}
40+
}
41+
42+
}

‎mcp-spring/mcp-spring-webflux/src/main/java/io/modelcontextprotocol/server/transport/WebFluxSseServerTransportProvider.java‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -359,6 +359,13 @@ private Mono<ServerResponse> handleMessage(ServerRequest request) {
359359
return ServerResponse.status(e.getStatusCode()).bodyValue(e.getMessage());
360360
}
361361

362+
if (!WebFluxServerRequestUtils.isJsonContentType(request)) {
363+
return ServerResponse.status(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
364+
.bodyValue(McpError.builder(McpSchema.ErrorCodes.INVALID_REQUEST)
365+
.message("Unsupported Media Type: Content-Type must be application/json")
366+
.build());
367+
}
368+
362369
if (request.queryParam("sessionId").isEmpty()) {
363370
return ServerResponse.badRequest().bodyValue(new McpError("Session ID missing in message endpoint"));
364371
}

‎mcp-spring/mcp-spring-webflux/src/main/java/io/modelcontextprotocol/server/transport/WebFluxStatelessServerTransport.java‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -114,6 +114,13 @@ private Mono<ServerResponse> handlePost(ServerRequest request) {
114114
return ServerResponse.status(e.getStatusCode()).bodyValue(e.getMessage());
115115
}
116116

117+
if (!WebFluxServerRequestUtils.isJsonContentType(request)) {
118+
return ServerResponse.status(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
119+
.bodyValue(McpError.builder(McpSchema.ErrorCodes.INVALID_REQUEST)
120+
.message("Unsupported Media Type: Content-Type must be application/json")
121+
.build());
122+
}
123+
117124
McpTransportContext transportContext = this.contextExtractor.extract(request);
118125

119126
List<MediaType> acceptHeaders = request.headers().asHttpHeaders().getAccept();

‎mcp-spring/mcp-spring-webflux/src/main/java/io/modelcontextprotocol/server/transport/WebFluxStreamableServerTransportProvider.java‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -246,6 +246,13 @@ private Mono<ServerResponse> handlePost(ServerRequest request) {
246246
return ServerResponse.status(e.getStatusCode()).bodyValue(e.getMessage());
247247
}
248248

249+
if (!WebFluxServerRequestUtils.isJsonContentType(request)) {
250+
return ServerResponse.status(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
251+
.bodyValue(McpError.builder(McpSchema.ErrorCodes.INVALID_REQUEST)
252+
.message("Unsupported Media Type: Content-Type must be application/json")
253+
.build());
254+
}
255+
249256
McpTransportContext transportContext = this.contextExtractor.extract(request);
250257

251258
List<MediaType> acceptHeaders = request.headers().asHttpHeaders().getAccept();

‎mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/WebFluxSseIntegrationTests.java‎

Lines changed: 82 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,16 +5,25 @@
55
package io.modelcontextprotocol;
66

77
import java.time.Duration;
8+
import java.util.List;
89
import java.util.Map;
10+
import java.util.concurrent.atomic.AtomicBoolean;
911
import java.util.stream.Stream;
1012

1113
import org.junit.jupiter.api.AfterEach;
1214
import org.junit.jupiter.api.BeforeEach;
1315
import org.junit.jupiter.api.Timeout;
16+
import org.junit.jupiter.params.ParameterizedTest;
1417
import org.junit.jupiter.params.provider.Arguments;
18+
import org.junit.jupiter.params.provider.ValueSource;
1519

20+
import org.springframework.core.ParameterizedTypeReference;
21+
import org.springframework.http.HttpStatus;
22+
import org.springframework.http.MediaType;
23+
import org.springframework.http.codec.ServerSentEvent;
1624
import org.springframework.http.server.reactive.HttpHandler;
1725
import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;
26+
import org.springframework.web.reactive.function.client.ClientResponse;
1827
import org.springframework.web.reactive.function.client.WebClient;
1928
import org.springframework.web.reactive.function.server.RouterFunctions;
2029
import org.springframework.web.reactive.function.server.ServerRequest;
@@ -26,12 +35,20 @@
2635
import io.modelcontextprotocol.server.McpServer;
2736
import io.modelcontextprotocol.server.McpServer.AsyncSpecification;
2837
import io.modelcontextprotocol.server.McpServer.SingleSessionSyncSpecification;
38+
import io.modelcontextprotocol.server.McpServerFeatures;
2939
import io.modelcontextprotocol.server.McpTransportContextExtractor;
3040
import io.modelcontextprotocol.server.TestUtil;
3141
import io.modelcontextprotocol.server.transport.WebFluxSseServerTransportProvider;
42+
import io.modelcontextprotocol.spec.McpSchema;
43+
import reactor.core.Disposable;
44+
import reactor.core.publisher.Mono;
45+
import reactor.core.publisher.Sinks;
3246
import reactor.netty.DisposableServer;
3347
import reactor.netty.http.server.HttpServer;
3448

49+
import static io.modelcontextprotocol.util.ToolsUtils.EMPTY_JSON_SCHEMA;
50+
import static org.assertj.core.api.Assertions.assertThat;
51+
3552
@Timeout(15)
3653
class WebFluxSseIntegrationTests extends AbstractMcpClientServerIntegrationTests {
3754

@@ -103,4 +120,69 @@ public void after() {
103120
}
104121
}
105122

123+
@ParameterizedTest
124+
@ValueSource(strings = { "text/plain;charset=UTF-8", "application/x-www-form-urlencoded", "multipart/form-data" })
125+
void rejectsNonJsonContentType(String contentType) {
126+
var webClient = WebClient.create("http://localhost:" + PORT);
127+
var toolCalled = new AtomicBoolean();
128+
prepareAsyncServerBuilder().capabilities(McpSchema.ServerCapabilities.builder().tools(true).build())
129+
.tools(McpServerFeatures.AsyncToolSpecification.builder()
130+
.tool(McpSchema.Tool.builder().name("tool1").inputSchema(EMPTY_JSON_SCHEMA).build())
131+
.callHandler((exchange, request) -> {
132+
toolCalled.set(true);
133+
return Mono.just(McpSchema.CallToolResult.builder().build());
134+
})
135+
.build())
136+
.build();
137+
138+
// Establish an SSE session to obtain the session-scoped message endpoint. The
139+
// SSE stream must stay open for the session to remain active.
140+
var messageEndpoint = Sinks.<String>one();
141+
Disposable sseSubscription = webClient.get()
142+
.uri(CUSTOM_SSE_ENDPOINT)
143+
.accept(MediaType.TEXT_EVENT_STREAM)
144+
.retrieve()
145+
.bodyToFlux(new ParameterizedTypeReference<ServerSentEvent<String>>() {
146+
})
147+
.filter(event -> WebFluxSseServerTransportProvider.ENDPOINT_EVENT_TYPE.equals(event.event()))
148+
.subscribe(event -> messageEndpoint.tryEmitValue(event.data()));
149+
try {
150+
String endpoint = messageEndpoint.asMono().block(Duration.ofSeconds(5));
151+
152+
// Initialize the session, so that the tool call below would be handled if it
153+
// were accepted
154+
for (String message : List.of("""
155+
{"jsonrpc":"2.0","id":"init","method":"initialize","params":{
156+
"protocolVersion":"2024-11-05","capabilities":{},
157+
"clientInfo":{"name":"test-client","version":"1.0.0"}}}""", """
158+
{"jsonrpc":"2.0","method":"notifications/initialized"}""")) {
159+
var initResponse = webClient.post()
160+
.uri(endpoint)
161+
.contentType(MediaType.APPLICATION_JSON)
162+
.bodyValue(message)
163+
.exchangeToMono(ClientResponse::toBodilessEntity)
164+
.block();
165+
assertThat(initResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
166+
}
167+
168+
// CORS-safelisted content types can be sent cross-origin by a browser without
169+
// a preflight, so they must be rejected before the message is handled
170+
var response = webClient.post()
171+
.uri(endpoint)
172+
.contentType(MediaType.parseMediaType(contentType))
173+
.bodyValue(
174+
"""
175+
{"jsonrpc":"2.0","id":"call-1","method":"tools/call","params":{"name":"tool1","arguments":{}}}""")
176+
.exchangeToMono(clientResponse -> clientResponse.toEntity(String.class))
177+
.block();
178+
179+
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNSUPPORTED_MEDIA_TYPE);
180+
assertThat(response.getBody()).contains("Unsupported Media Type: Content-Type must be application/json");
181+
assertThat(toolCalled).isFalse();
182+
}
183+
finally {
184+
sseSubscription.dispose();
185+
}
186+
}
187+
106188
}

‎mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/WebFluxStatelessIntegrationTests.java‎

Lines changed: 42 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,13 +5,18 @@
55
package io.modelcontextprotocol;
66

77
import java.time.Duration;
8+
import java.util.concurrent.atomic.AtomicBoolean;
89
import java.util.stream.Stream;
910

1011
import org.junit.jupiter.api.AfterEach;
1112
import org.junit.jupiter.api.BeforeEach;
1213
import org.junit.jupiter.api.Timeout;
14+
import org.junit.jupiter.params.ParameterizedTest;
1315
import org.junit.jupiter.params.provider.Arguments;
16+
import org.junit.jupiter.params.provider.ValueSource;
1417

18+
import org.springframework.http.HttpStatus;
19+
import org.springframework.http.MediaType;
1520
import org.springframework.http.server.reactive.HttpHandler;
1621
import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;
1722
import org.springframework.web.reactive.function.client.WebClient;
@@ -22,11 +27,17 @@
2227
import io.modelcontextprotocol.server.McpServer;
2328
import io.modelcontextprotocol.server.McpServer.StatelessAsyncSpecification;
2429
import io.modelcontextprotocol.server.McpServer.StatelessSyncSpecification;
30+
import io.modelcontextprotocol.server.McpStatelessServerFeatures;
2531
import io.modelcontextprotocol.server.TestUtil;
2632
import io.modelcontextprotocol.server.transport.WebFluxStatelessServerTransport;
33+
import io.modelcontextprotocol.spec.McpSchema;
34+
import reactor.core.publisher.Mono;
2735
import reactor.netty.DisposableServer;
2836
import reactor.netty.http.server.HttpServer;
2937

38+
import static io.modelcontextprotocol.util.ToolsUtils.EMPTY_JSON_SCHEMA;
39+
import static org.assertj.core.api.Assertions.assertThat;
40+
3041
@Timeout(15)
3142
class WebFluxStatelessIntegrationTests extends AbstractStatelessIntegrationTests {
3243

@@ -88,4 +99,35 @@ public void after() {
8899
}
89100
}
90101

102+
@ParameterizedTest
103+
@ValueSource(strings = { "text/plain;charset=UTF-8", "application/x-www-form-urlencoded", "multipart/form-data" })
104+
void rejectsNonJsonContentType(String contentType) {
105+
var toolCalled = new AtomicBoolean();
106+
prepareAsyncServerBuilder().capabilities(McpSchema.ServerCapabilities.builder().tools(true).build())
107+
.tools(McpStatelessServerFeatures.AsyncToolSpecification.builder()
108+
.tool(McpSchema.Tool.builder().name("tool1").inputSchema(EMPTY_JSON_SCHEMA).build())
109+
.callHandler((transportContext, request) -> {
110+
toolCalled.set(true);
111+
return Mono.just(McpSchema.CallToolResult.builder().build());
112+
})
113+
.build())
114+
.build();
115+
116+
// CORS-safelisted content types can be sent cross-origin by a browser without a
117+
// preflight, so they must be rejected before the message is handled
118+
var response = WebClient.create("http://localhost:" + PORT)
119+
.post()
120+
.uri(CUSTOM_MESSAGE_ENDPOINT)
121+
.contentType(MediaType.parseMediaType(contentType))
122+
.accept(MediaType.APPLICATION_JSON, MediaType.TEXT_EVENT_STREAM)
123+
.bodyValue("""
124+
{"jsonrpc":"2.0","id":"call-1","method":"tools/call","params":{"name":"tool1","arguments":{}}}""")
125+
.exchangeToMono(clientResponse -> clientResponse.toEntity(String.class))
126+
.block();
127+
128+
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNSUPPORTED_MEDIA_TYPE);
129+
assertThat(response.getBody()).contains("Unsupported Media Type: Content-Type must be application/json");
130+
assertThat(toolCalled).isFalse();
131+
}
132+
91133
}

‎mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/WebFluxStreamableIntegrationTests.java‎

Lines changed: 85 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,13 +6,19 @@
66

77
import java.time.Duration;
88
import java.util.Map;
9+
import java.util.concurrent.atomic.AtomicBoolean;
910
import java.util.stream.Stream;
1011

1112
import org.junit.jupiter.api.AfterEach;
1213
import org.junit.jupiter.api.BeforeEach;
14+
import org.junit.jupiter.api.Test;
1315
import org.junit.jupiter.api.Timeout;
16+
import org.junit.jupiter.params.ParameterizedTest;
1417
import org.junit.jupiter.params.provider.Arguments;
18+
import org.junit.jupiter.params.provider.ValueSource;
1519

20+
import org.springframework.http.HttpStatus;
21+
import org.springframework.http.MediaType;
1622
import org.springframework.http.server.reactive.HttpHandler;
1723
import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;
1824
import org.springframework.web.reactive.function.client.WebClient;
@@ -26,12 +32,19 @@
2632
import io.modelcontextprotocol.server.McpServer;
2733
import io.modelcontextprotocol.server.McpServer.AsyncSpecification;
2834
import io.modelcontextprotocol.server.McpServer.SyncSpecification;
35+
import io.modelcontextprotocol.server.McpServerFeatures;
2936
import io.modelcontextprotocol.server.McpTransportContextExtractor;
3037
import io.modelcontextprotocol.server.TestUtil;
3138
import io.modelcontextprotocol.server.transport.WebFluxStreamableServerTransportProvider;
39+
import io.modelcontextprotocol.spec.HttpHeaders;
40+
import io.modelcontextprotocol.spec.McpSchema;
41+
import reactor.core.publisher.Mono;
3242
import reactor.netty.DisposableServer;
3343
import reactor.netty.http.server.HttpServer;
3444

45+
import static io.modelcontextprotocol.util.ToolsUtils.EMPTY_JSON_SCHEMA;
46+
import static org.assertj.core.api.Assertions.assertThat;
47+
3548
@Timeout(15)
3649
class WebFluxStreamableIntegrationTests extends AbstractMcpClientServerIntegrationTests {
3750

@@ -100,4 +113,76 @@ public void after() {
100113
}
101114
}
102115

116+
@ParameterizedTest
117+
@ValueSource(strings = { "text/plain;charset=UTF-8", "application/x-www-form-urlencoded", "multipart/form-data" })
118+
void rejectsInitializeWithNonJsonContentType(String contentType) {
119+
var webClient = WebClient.create("http://localhost:" + PORT);
120+
prepareAsyncServerBuilder().serverInfo("test-server", "1.0.0").build();
121+
122+
// CORS-safelisted content types can be sent cross-origin by a browser without a
123+
// preflight, so they must be rejected before a session is created
124+
var response = webClient.post()
125+
.uri(CUSTOM_MESSAGE_ENDPOINT)
126+
.contentType(MediaType.parseMediaType(contentType))
127+
.accept(MediaType.TEXT_EVENT_STREAM, MediaType.APPLICATION_JSON)
128+
.bodyValue("""
129+
{"jsonrpc":"2.0","id":"init","method":"initialize","params":{
130+
"protocolVersion":"2025-06-18","capabilities":{},
131+
"clientInfo":{"name":"test-client","version":"1.0.0"}}}""")
132+
.exchangeToMono(clientResponse -> clientResponse.toEntity(String.class))
133+
.block();
134+
135+
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNSUPPORTED_MEDIA_TYPE);
136+
assertThat(response.getBody()).contains("Unsupported Media Type: Content-Type must be application/json");
137+
assertThat(response.getHeaders().containsKey(HttpHeaders.MCP_SESSION_ID)).isFalse();
138+
}
139+
140+
@Test
141+
void rejectsToolCallWithNonJsonContentType() {
142+
var webClient = WebClient.create("http://localhost:" + PORT);
143+
var toolCalled = new AtomicBoolean();
144+
prepareAsyncServerBuilder().serverInfo("test-server", "1.0.0")
145+
.capabilities(McpSchema.ServerCapabilities.builder().tools(true).build())
146+
.tools(McpServerFeatures.AsyncToolSpecification.builder()
147+
.tool(McpSchema.Tool.builder().name("tool1").inputSchema(EMPTY_JSON_SCHEMA).build())
148+
.callHandler((exchange, request) -> {
149+
toolCalled.set(true);
150+
return Mono.just(McpSchema.CallToolResult.builder().build());
151+
})
152+
.build())
153+
.build();
154+
var sessionId = initializeSession(webClient);
155+
156+
var response = webClient.post()
157+
.uri(CUSTOM_MESSAGE_ENDPOINT)
158+
.contentType(MediaType.parseMediaType("text/plain;charset=UTF-8"))
159+
.accept(MediaType.TEXT_EVENT_STREAM, MediaType.APPLICATION_JSON)
160+
.header(HttpHeaders.MCP_SESSION_ID, sessionId)
161+
.bodyValue("""
162+
{"jsonrpc":"2.0","id":"call-1","method":"tools/call","params":{"name":"tool1","arguments":{}}}""")
163+
.exchangeToMono(clientResponse -> clientResponse.toEntity(String.class))
164+
.block();
165+
166+
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNSUPPORTED_MEDIA_TYPE);
167+
assertThat(response.getBody()).contains("Unsupported Media Type: Content-Type must be application/json");
168+
assertThat(toolCalled).isFalse();
169+
}
170+
171+
private String initializeSession(WebClient webClient) {
172+
var response = webClient.post()
173+
.uri(CUSTOM_MESSAGE_ENDPOINT)
174+
.contentType(MediaType.APPLICATION_JSON)
175+
.accept(MediaType.TEXT_EVENT_STREAM, MediaType.APPLICATION_JSON)
176+
.bodyValue("""
177+
{"jsonrpc":"2.0","id":"init","method":"initialize","params":{
178+
"protocolVersion":"2025-06-18","capabilities":{},
179+
"clientInfo":{"name":"test-client","version":"1.0.0"}}}""")
180+
.exchangeToMono(clientResponse -> clientResponse.toEntity(String.class))
181+
.block();
182+
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
183+
var sessionId = response.getHeaders().getFirst(HttpHeaders.MCP_SESSION_ID);
184+
assertThat(sessionId).isNotNull();
185+
return sessionId;
186+
}
187+
103188
}

0 commit comments

Comments
 (0)