diff --git a/src/oracle-db-mcp-java-toolkit/README.md b/src/oracle-db-mcp-java-toolkit/README.md index 2f84d6548..187a8f91c 100644 --- a/src/oracle-db-mcp-java-toolkit/README.md +++ b/src/oracle-db-mcp-java-toolkit/README.md @@ -669,6 +669,10 @@ In order to configure an OAuth2 server, enable `-Dauth.enabled=true` alongside t * `-Dauth.authorizationServer`: The OAuth2 server URL which MUST provide the `/.well-known/oauth-authorization-server`. If it only provides `/.well-known/openid-configuration`, enable `-Dauth.openIdDiscoveryRedirectEnabled=true`. * `-Dmcp.oauth.scopes`: Optional space- or comma-separated OAuth scopes advertised to MCP clients for end-user login (default: `openid`). * `-Dmcp.oauth.resourceUrl`: Optional externally visible MCP resource URL advertised in OAuth protected-resource metadata. Set this when the server is behind a proxy or public route whose URL differs from the incoming servlet request URL. +* `-Dmcp.oauth.resourceMetadataUrl`: Optional public protected-resource metadata URL advertised in both the HTTP 401 `WWW-Authenticate` header and JSON body. Absent or blank values retain the request-derived origin plus `/.well-known/oauth-protected-resource`. + A nonblank value must be an absolute ASCII HTTPS URI without user-info or a fragment, with a valid port; percent-encode non-ASCII path/query characters. Invalid values are rejected when the HTTP authorization filter initializes. The configured value is preserved exactly and no network reachability check is performed. + Configure `mcp.oauth.resourceUrl=https://mcp.example.com/owned/mcp` for the resource identifier and, independently, `mcp.oauth.resourceMetadataUrl=https://mcp.example.com/owned/.well-known/oauth-protected-resource` for the public metadata location. Ensure the proxy actually serves that location; this setting does not create a route. The value is public discovery information and must not contain credentials. + When `mcp.oauth.resourceUrl` is set, redirect mode advertises the configured authorization server directly; `auth.authorizationServer` must match that server's metadata issuer. * `-Dauth.openIdDiscoveryRedirectEnabled`: (default: `false`) Creates an `/.well-known/oauth-authorization-server` endpoint that redirects to the authorization server's `/.well-known/openid-configuration` endpoint. It works by creating an `/.well-known/oauth-authorization-server` endpoint on the MCP Server that redirects to the OAuth server's `/.well-known/openid-configuration` endpoint. * `-Dauth.userTokenValidation.mode`: Token validation mode. Use `introspection` (default) to validate bearer tokens by calling the OAuth2 introspection endpoint, or `jwt` to validate JWT access tokens locally with JWKS. @@ -1091,6 +1095,12 @@ Ultimately, the token must be included in the http request header (e.g. `Authori Externally visible MCP endpoint URL advertised in OAuth protected-resource metadata. Useful behind proxies or public routes. -Dmcp.oauth.resourceUrl=https://example.com/api/mcp + + mcp.oauth.resourceMetadataUrl + No + Public protected-resource metadata URL for the 401 challenge header and JSON body. An absolute ASCII HTTPS URI without user-info or fragment, with a valid port. Absent/blank retains the request-derived root well-known URL. Invalid explicit values fail HTTP filter initialization; the proxy must serve the configured route. + -Dmcp.oauth.resourceMetadataUrl=https://example.com/api/.well-known/oauth-protected-resource + auth.userTokenValidation.mode No diff --git a/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/LoadedConstants.java b/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/LoadedConstants.java index 5384078fc..0e20d1af2 100644 --- a/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/LoadedConstants.java +++ b/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/LoadedConstants.java @@ -78,6 +78,8 @@ private LoadedConstants() {} // Prevent instantiation /** MCP OAuth discovery config */ public static final String MCP_OAUTH_SCOPES = System.getProperty("mcp.oauth.scopes", "openid"); public static final String MCP_OAUTH_RESOURCE_URL = System.getProperty("mcp.oauth.resourceUrl"); + public static final String MCP_OAUTH_RESOURCE_METADATA_URL = + System.getProperty("mcp.oauth.resourceMetadataUrl"); /** Deep Data Security config */ public static final boolean DEEPSEC_ENABLED = Boolean.parseBoolean(System.getProperty("deepsec.enabled", "false")); diff --git a/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/web/AuthorizationFilter.java b/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/web/AuthorizationFilter.java index ffa982e73..c983cc6ff 100644 --- a/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/web/AuthorizationFilter.java +++ b/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/web/AuthorizationFilter.java @@ -45,6 +45,8 @@ public class AuthorizationFilter implements Filter { private static final OAuth2TokenValidator VALIDATOR = new OAuth2TokenValidator(); private static final RequestTargetValidator REQUEST_TARGET_VALIDATOR = new RequestTargetValidator(LoadedConstants.HTTP_ALLOWED_ORIGINAL_HOSTS); + private static final String CONFIGURED_RESOURCE_METADATA_URL = + WebUtils.validateMcpResourceMetadataUrl(LoadedConstants.MCP_OAUTH_RESOURCE_METADATA_URL); /** * Intercepts incoming requests to authenticate them based on the presence and validity of an OAuth2 access token. @@ -128,8 +130,9 @@ private EndUserSecurityContext createEndUserSecurityContext(String endUserToken) * @throws IOException if an I/O error occurs while writing the response */ private void handleError(HttpServletResponse httpResponse, HttpServletRequest httpRequest) throws IOException { - final String serverURL = WebUtils.buildURLFromRequest(httpRequest); - final String resourceMetadataURL = serverURL + "/.well-known/oauth-protected-resource"; + final String resourceMetadataURL = CONFIGURED_RESOURCE_METADATA_URL != null + ? CONFIGURED_RESOURCE_METADATA_URL + : WebUtils.buildURLFromRequest(httpRequest) + "/.well-known/oauth-protected-resource"; final String scopes = LoadedConstants.MCP_OAUTH_SCOPES == null || LoadedConstants.MCP_OAUTH_SCOPES.isBlank() ? "openid" : LoadedConstants.MCP_OAUTH_SCOPES; diff --git a/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/web/WebUtils.java b/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/web/WebUtils.java index 771c18ef8..fa29a14c5 100644 --- a/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/web/WebUtils.java +++ b/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/web/WebUtils.java @@ -10,6 +10,8 @@ import com.oracle.database.mcptoolkit.LoadedConstants; import jakarta.servlet.http.HttpServletRequest; +import java.net.URI; +import java.net.URISyntaxException; import java.util.Objects; /** @@ -58,6 +60,57 @@ static String buildURLFromRequest(final HttpServletRequest request) { return url.toString(); } + /** + * Resolves the protected resource identifier without changing a configured value. + * A configured identifier may include a public path prefix or query component. + * + * @param request the servlet request used only when the configured value is absent or blank + * @param configuredResourceUrl the optional externally visible MCP resource identifier + * @return the configured identifier, or the existing request-derived default + */ + static String resolveMcpResourceUrl( + final HttpServletRequest request, final String configuredResourceUrl) { + if (configuredResourceUrl != null && !configuredResourceUrl.isBlank()) { + return configuredResourceUrl; + } + return buildURLFromRequest(request) + "/mcp"; + } + + /** + * Validates an optional public metadata URL before it is advertised in a challenge. + * No network lookup or URL normalization is performed. + * + * @param configuredUrl an ASCII HTTPS URI, or an absent/blank value + * @return the unchanged configured URL, or null to retain the request-derived default + * @throws IllegalArgumentException if a nonblank value is not a valid public metadata URL + */ + static String validateMcpResourceMetadataUrl(final String configuredUrl) { + if (configuredUrl == null || configuredUrl.isBlank()) { + return null; + } + if (configuredUrl.chars().anyMatch(c -> c <= 0x20 || c >= 0x7f)) { + throw invalidMcpResourceMetadataUrl(); + } + try { + final URI uri = new URI(configuredUrl); + final int port = uri.getPort(); + if (!"https".equalsIgnoreCase(uri.getScheme()) || uri.getHost() == null + || uri.getRawUserInfo() != null || uri.getRawFragment() != null + || (port != -1 && (port < 1 || port > 65535))) { + throw invalidMcpResourceMetadataUrl(); + } + } catch (URISyntaxException e) { + throw invalidMcpResourceMetadataUrl(); + } + return configuredUrl; + } + + private static IllegalArgumentException invalidMcpResourceMetadataUrl() { + return new IllegalArgumentException( + "mcp.oauth.resourceMetadataUrl must be an absolute ASCII HTTPS URL " + + "without user-info or a fragment, and with a valid port"); + } + /** * Retrieves the value of the system property {@code allowedHosts}. * If the property is not set, it defaults to {@code "*"}. diff --git a/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/web/WellKnownServlet.java b/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/web/WellKnownServlet.java index 2af846bb9..8b5cd6a8c 100644 --- a/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/web/WellKnownServlet.java +++ b/src/oracle-db-mcp-java-toolkit/src/main/java/com/oracle/database/mcptoolkit/web/WellKnownServlet.java @@ -7,6 +7,8 @@ package com.oracle.database.mcptoolkit.web; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.oracle.database.mcptoolkit.LoadedConstants; import com.oracle.database.mcptoolkit.oauth.OAuth2Configuration; import jakarta.servlet.ServletException; import jakarta.servlet.http.HttpServlet; @@ -14,6 +16,8 @@ import jakarta.servlet.http.HttpServletResponse; import java.io.IOException; +import java.util.List; +import java.util.Map; /** * The WellKnownServlet class handles HTTP GET requests to the well-known endpoint, @@ -48,15 +52,16 @@ protected void doGet(HttpServletRequest request, HttpServletResponse response) t response.addHeader("Access-Control-Allow-Origin", WebUtils.getAllowedHosts()); response.setStatus(HttpServletResponse.SC_OK); - final String serverURL = WebUtils.buildURLFromRequest(request); - final String mcpEndpoint = serverURL + "/mcp"; - String authServer = WebUtils.isRedirectOpenIDToOAuthEnabled() ? serverURL : OAUTH2_CONFIG.getAuthServer(); + final String configuredResourceUrl = LoadedConstants.MCP_OAUTH_RESOURCE_URL; + final String mcpEndpoint = WebUtils.resolveMcpResourceUrl(request, configuredResourceUrl); + final String authServer = WebUtils.isRedirectOpenIDToOAuthEnabled() + && (configuredResourceUrl == null || configuredResourceUrl.isBlank()) + ? WebUtils.buildURLFromRequest(request) + : OAUTH2_CONFIG.getAuthServer(); - final String json = """ - { - "resource":"%s", - "authorization_servers":["%s"] - }""".formatted(mcpEndpoint, authServer); + final String json = new ObjectMapper().writeValueAsString(Map.of( + "resource", mcpEndpoint, + "authorization_servers", List.of(authServer))); response.getWriter() .write(json); } diff --git a/src/oracle-db-mcp-java-toolkit/src/test/java/com/oracle/database/mcptoolkit/web/WebUtilsResourceMetadataUrlTest.java b/src/oracle-db-mcp-java-toolkit/src/test/java/com/oracle/database/mcptoolkit/web/WebUtilsResourceMetadataUrlTest.java new file mode 100644 index 000000000..238e1481e --- /dev/null +++ b/src/oracle-db-mcp-java-toolkit/src/test/java/com/oracle/database/mcptoolkit/web/WebUtilsResourceMetadataUrlTest.java @@ -0,0 +1,63 @@ +package com.oracle.database.mcptoolkit.web; + +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class WebUtilsResourceMetadataUrlTest { + @Test + void absentAndBlankValuesRetainTheDefault() { + assertNull(WebUtils.validateMcpResourceMetadataUrl(null)); + assertNull(WebUtils.validateMcpResourceMetadataUrl("")); + assertNull(WebUtils.validateMcpResourceMetadataUrl(" \t\r\n")); + } + + @ParameterizedTest + @ValueSource(strings = { + "https://127.0.0.1:45450/owned/.well-known/oauth-protected-resource", + "HTTPS://metadata.example.test:8443/discovery?tenant=demo", + "https://[::1]:443/discovery", + "https://metadata.example.test:65535/a/../metadata", + "https://metadata.example.test/m%C3%A9tadata?value=%22safe%22" + }) + void preservesValidConfiguredUrlsExactly(String configured) { + assertEquals(configured, WebUtils.validateMcpResourceMetadataUrl(configured)); + } + + @ParameterizedTest + @MethodSource("invalidUrls") + void rejectsInvalidConfigurationWithoutEchoingItsValue(String configured) { + IllegalArgumentException error = assertThrows( + IllegalArgumentException.class, () -> WebUtils.validateMcpResourceMetadataUrl(configured)); + assertTrue(error.getMessage().contains("mcp.oauth.resourceMetadataUrl")); + assertFalse(error.getMessage().contains(configured)); + } + + static Stream invalidUrls() { + return Stream.of( + "http://127.0.0.1/discovery", + "/discovery", + "https:///discovery", + "https://127.0.0.1/discovery#section", + "https://fixture:fixture@127.0.0.1/discovery", + " https://127.0.0.1/discovery", + "https://127.0.0.1/discovery ", + "https://127.0.0.1:0/discovery", + "https://127.0.0.1:65536/discovery", + "https://127.0.0.1/discovery\n", + "https://127.0.0.1/dis\rcovery", + "https://127.0.0.1/discovery\u007f", + "https://127.0.0.1/m\u00e9tadata", + "https://127.0.0.1/discovery?value=\"raw\"", + "https://127.0.0.1/dis\\covery", + "https://127.0.0.1/discovery?value=\u0080"); + } +} diff --git a/src/oracle-db-mcp-java-toolkit/src/test/java/com/oracle/database/mcptoolkit/web/WebUtilsResourceUrlTest.java b/src/oracle-db-mcp-java-toolkit/src/test/java/com/oracle/database/mcptoolkit/web/WebUtilsResourceUrlTest.java new file mode 100644 index 000000000..56a17eb71 --- /dev/null +++ b/src/oracle-db-mcp-java-toolkit/src/test/java/com/oracle/database/mcptoolkit/web/WebUtilsResourceUrlTest.java @@ -0,0 +1,61 @@ +package com.oracle.database.mcptoolkit.web; + +import jakarta.servlet.http.HttpServletRequest; +import java.lang.reflect.Proxy; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +class WebUtilsResourceUrlTest { + private HttpServletRequest request() { + return (HttpServletRequest) Proxy.newProxyInstance( + getClass().getClassLoader(), new Class[]{HttpServletRequest.class}, + (proxy, method, args) -> switch (method.getName()) { + case "getHeader" -> null; + case "getScheme" -> "http"; + case "getServerName" -> "127.0.0.1"; + case "getServerPort" -> 18080; + default -> throw new UnsupportedOperationException(method.getName()); + }); + } + + @Test + void honorsConfiguredResourceInsteadOfServletOrigin() { + String configured = "https://127.0.0.1:45450/mcp"; + assertEquals(configured, WebUtils.resolveMcpResourceUrl(request(), configured)); + } + + @Test + void preservesPublicPathPrefixExactly() { + String configured = "https://127.0.0.1:45450/owned/mcp"; + assertEquals(configured, WebUtils.resolveMcpResourceUrl(request(), configured)); + } + + @Test + void preservesQueryAndTrailingSlashExactly() { + String configured = "https://127.0.0.1:45450/owned/mcp/?version=1"; + assertEquals(configured, WebUtils.resolveMcpResourceUrl(request(), configured)); + } + + @Test + void doesNotReadRequestWhenConfigured() { + String configured = "https://127.0.0.1:45450/mcp"; + assertEquals(configured, WebUtils.resolveMcpResourceUrl(null, configured)); + } + + @Test + void retainsRequestDefaultWhenAbsent() { + assertEquals("http://127.0.0.1:18080/mcp", WebUtils.resolveMcpResourceUrl(request(), null)); + } + + @Test + void retainsRequestDefaultWhenBlank() { + assertEquals("http://127.0.0.1:18080/mcp", WebUtils.resolveMcpResourceUrl(request(), " ")); + } + + @Test + void absentConfigurationStillRequiresRequest() { + assertThrows(NullPointerException.class, () -> WebUtils.resolveMcpResourceUrl(null, null)); + } +} diff --git a/src/oracle-db-mcp-java-toolkit/src/test/java/com/oracle/database/mcptoolkit/web/WellKnownServletConfiguredResourceTest.java b/src/oracle-db-mcp-java-toolkit/src/test/java/com/oracle/database/mcptoolkit/web/WellKnownServletConfiguredResourceTest.java new file mode 100644 index 000000000..13dc19e74 --- /dev/null +++ b/src/oracle-db-mcp-java-toolkit/src/test/java/com/oracle/database/mcptoolkit/web/WellKnownServletConfiguredResourceTest.java @@ -0,0 +1,83 @@ +package com.oracle.database.mcptoolkit.web; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.lang.reflect.Proxy; +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.util.concurrent.TimeUnit; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class WellKnownServletConfiguredResourceTest { + private static final String RESOURCE = "https://mcp.example.test/public/mcp"; + private static final String AUTHORIZATION_SERVER = "https://auth.example.test"; + + @Test + void advertisesConfiguredResourceAndAuthorizationServer() throws Exception { + // Configuration is static, so use a fresh JVM independent of other tests. + Process process = new ProcessBuilder( + Path.of(System.getProperty("java.home"), "bin", "java").toString(), + "-Dauth.enabled=true", + "-Dauth.userTokenValidation.mode=jwt", + "-Dauth.userTokenValidation.jwt.issuer=" + AUTHORIZATION_SERVER, + "-Dauth.userTokenValidation.jwt.jwksUri=" + AUTHORIZATION_SERVER + "/jwks", + "-Dauth.userTokenValidation.jwt.audience=configured-resource-test", + "-Dauth.authorizationServer=" + AUTHORIZATION_SERVER, + "-Dauth.openIdDiscoveryRedirectEnabled=false", + "-Dmcp.oauth.resourceUrl=" + RESOURCE, + "-cp", System.getProperty("surefire.test.class.path", + System.getProperty("java.class.path")), + WellKnownServletConfiguredResourceTest.class.getName()) + .redirectError(ProcessBuilder.Redirect.INHERIT) + .start(); + try { + assertTrue(process.waitFor(20, TimeUnit.SECONDS), "Servlet probe did not exit"); + assertEquals(0, process.exitValue(), "Servlet probe failed"); + String output = new String(process.getInputStream().readAllBytes(), StandardCharsets.UTF_8); + JsonNode metadata = new ObjectMapper().readTree(output); + assertEquals(RESOURCE, metadata.path("resource").asText()); + assertEquals(AUTHORIZATION_SERVER, metadata.path("authorization_servers").get(0).asText()); + } finally { + if (process.isAlive()) { + process.destroyForcibly(); + assertTrue(process.waitFor(5, TimeUnit.SECONDS), "Servlet probe did not stop"); + } + } + } + + public static void main(String[] args) throws Exception { + HttpServletRequest request = (HttpServletRequest) Proxy.newProxyInstance( + WellKnownServletConfiguredResourceTest.class.getClassLoader(), + new Class[]{HttpServletRequest.class}, + (proxy, method, arguments) -> switch (method.getName()) { + case "getHeader" -> null; + case "getScheme" -> "http"; + case "getServerName" -> "127.0.0.1"; + case "getServerPort" -> 18080; + default -> throw new UnsupportedOperationException(method.getName()); + }); + StringWriter body = new StringWriter(); + int[] status = {0}; + HttpServletResponse response = (HttpServletResponse) Proxy.newProxyInstance( + WellKnownServletConfiguredResourceTest.class.getClassLoader(), + new Class[]{HttpServletResponse.class}, + (proxy, method, arguments) -> switch (method.getName()) { + case "setContentType", "addHeader" -> null; + case "setStatus" -> { status[0] = (int) arguments[0]; yield null; } + case "getWriter" -> new PrintWriter(body); + default -> throw new UnsupportedOperationException(method.getName()); + }); + new WellKnownServlet().doGet(request, response); + if (status[0] != HttpServletResponse.SC_OK) { + throw new IllegalStateException("Expected metadata status 200, got " + status[0]); + } + System.out.print(body); + } +} diff --git a/src/oracle-db-mcp-java-toolkit/src/test/java/com/oracle/database/mcptoolkit/web/WellKnownServletRedirectAuthorizationServerTest.java b/src/oracle-db-mcp-java-toolkit/src/test/java/com/oracle/database/mcptoolkit/web/WellKnownServletRedirectAuthorizationServerTest.java new file mode 100644 index 000000000..5077184eb --- /dev/null +++ b/src/oracle-db-mcp-java-toolkit/src/test/java/com/oracle/database/mcptoolkit/web/WellKnownServletRedirectAuthorizationServerTest.java @@ -0,0 +1,113 @@ +/* + ** Copyright (c) 2026 Oracle and/or its affiliates. + ** Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/ + */ +package com.oracle.database.mcptoolkit.web; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.lang.reflect.Proxy; +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.TimeUnit; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class WellKnownServletRedirectAuthorizationServerTest { + private static final String RESOURCE = "https://mcp.example.test/public/mcp"; + private static final String IDP = "https://auth.example.test"; + private static final String REQUEST_BASE = "http://foreign.example.test:18080"; + + @Test + void configuredResourceUsesConfiguredAuthorizationServerWithForeignHost() throws Exception { + assertMetadata(RESOURCE, true, RESOURCE, IDP); + } + + @Test + void configuredResourceWithQueryAndTrailingSlashUsesConfiguredAuthorizationServer() throws Exception { + String configured = RESOURCE + "/?version=1"; + assertMetadata(configured, true, configured, IDP); + } + + @Test + void absentResourceRetainsRedirectFacadeAtRequestOrigin() throws Exception { + assertMetadata(null, true, REQUEST_BASE + "/mcp", REQUEST_BASE); + } + + @Test + void blankResourceRetainsRedirectFacadeAtRequestOrigin() throws Exception { + assertMetadata(" ", true, REQUEST_BASE + "/mcp", REQUEST_BASE); + } + + @Test + void redirectDisabledRetainsConfiguredAuthorizationServer() throws Exception { + assertMetadata(RESOURCE, false, RESOURCE, IDP); + } + + private void assertMetadata(String configuredResource, boolean redirect, + String expectedResource, String expectedAuthorizationServer) throws Exception { + // Configuration is loaded statically, so each case has its own JVM. + List command = new ArrayList<>(List.of( + Path.of(System.getProperty("java.home"), "bin", "java").toString(), + "-Dauth.enabled=true", "-Dauth.userTokenValidation.mode=jwt", + "-Dauth.userTokenValidation.jwt.issuer=" + IDP, + "-Dauth.userTokenValidation.jwt.jwksUri=" + IDP + "/jwks", + "-Dauth.userTokenValidation.jwt.audience=configured-as-test", + "-Dauth.authorizationServer=" + IDP, + "-Dauth.openIdDiscoveryRedirectEnabled=" + redirect)); + if (configuredResource != null) { + command.add("-Dmcp.oauth.resourceUrl=" + configuredResource); + } + command.addAll(List.of("-cp", System.getProperty("surefire.test.class.path", + System.getProperty("java.class.path")), getClass().getName())); + Process process = new ProcessBuilder(command).redirectError(ProcessBuilder.Redirect.INHERIT).start(); + try { + assertTrue(process.waitFor(20, TimeUnit.SECONDS), "Servlet probe did not exit"); + assertEquals(0, process.exitValue(), "Servlet probe failed"); + JsonNode metadata = new ObjectMapper().readTree( + new String(process.getInputStream().readAllBytes(), StandardCharsets.UTF_8)); + assertEquals(expectedResource, metadata.path("resource").asText()); + assertEquals(expectedAuthorizationServer, metadata.path("authorization_servers").get(0).asText()); + } finally { + if (process.isAlive()) { + process.destroyForcibly(); + assertTrue(process.waitFor(5, TimeUnit.SECONDS), "Servlet probe did not stop"); + } + } + } + + public static void main(String[] args) throws Exception { + HttpServletRequest request = (HttpServletRequest) Proxy.newProxyInstance( + WellKnownServletRedirectAuthorizationServerTest.class.getClassLoader(), + new Class[]{HttpServletRequest.class}, (proxy, method, arguments) -> switch (method.getName()) { + case "getHeader" -> "Host".equals(arguments[0]) ? "foreign.example.test:18080" : null; + case "getScheme" -> "http"; + case "getServerName" -> "foreign.example.test"; + case "getServerPort" -> 18080; + default -> throw new UnsupportedOperationException(method.getName()); + }); + StringWriter body = new StringWriter(); + int[] status = {0}; + HttpServletResponse response = (HttpServletResponse) Proxy.newProxyInstance( + WellKnownServletRedirectAuthorizationServerTest.class.getClassLoader(), + new Class[]{HttpServletResponse.class}, (proxy, method, arguments) -> switch (method.getName()) { + case "setContentType", "addHeader" -> null; + case "setStatus" -> { status[0] = (int) arguments[0]; yield null; } + case "getWriter" -> new PrintWriter(body); + default -> throw new UnsupportedOperationException(method.getName()); + }); + new WellKnownServlet().doGet(request, response); + if (status[0] != HttpServletResponse.SC_OK) { + throw new IllegalStateException("Expected metadata status 200, got " + status[0]); + } + System.out.print(body); + } +}