Light, fluffy, and always free - The AWS Local Emulator alternative
fix(core): serve HTTP/1.0 requests that omit the Host header (#4174)
Abhigyaf084243fc08a
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/MissingHostHeaderFilter.java b/src/main/java/io/github/hectorvent/floci/core/common/MissingHostHeaderFilter.javanew file mode 100644index 0000000000..b9230e942d--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/core/common/MissingHostHeaderFilter.java@@ -0,0 +1,127 @@+package io.github.hectorvent.floci.core.common;++import io.quarkus.vertx.http.runtime.CurrentVertxRequest;+import io.vertx.core.http.HttpServerRequest;+import io.vertx.core.net.SocketAddress;+import io.vertx.ext.web.RoutingContext;+import jakarta.annotation.Priority;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import jakarta.ws.rs.container.ContainerRequestContext;+import jakarta.ws.rs.container.ContainerRequestFilter;+import jakarta.ws.rs.container.PreMatching;+import jakarta.ws.rs.ext.Provider;+import org.jboss.logging.Logger;++import java.net.URI;+import java.net.URISyntaxException;++/**+ * Gives an HTTP/1.0 request that omitted {@code Host} the authority it never sent.+ *+ * <p>{@code Host} is mandatory only from HTTP/1.1 on: Vert.x answers 400 to a 1.1 request without+ * one and exempts 1.0 by design. A 1.0 request then reaches the application with no authority+ * anywhere, so {@code HttpServerRequest.absoluteURI()} is null and+ * {@code UriInfo.getRequestUri()} fails inside {@code new URI(null)}. Every host-routing filter+ * reads the request URI, through {@link RequestHost} or directly, so a plain+ * {@code GET /_floci/health HTTP/1.0} answered 500 on a healthy emulator, which reads as a hard+ * outage to a probe written without a {@code Host} header. Nothing about it is health-specific:+ * every endpoint answered 500 the same way.+ *+ * <p>The repair is the request URI rather than the {@code Host} header. Vert.x resolves the+ * authority once, in {@code RoutingContextImpl.route()}, before any handler runs, and caches the+ * absence; a header set afterwards is never looked at again. Rewriting the JAX-RS request URI+ * instead gives {@code UriInfo} the scheme, authority and path it needs, which is the same+ * mechanism the virtual-host filters use to reroute a request.+ *+ * <p>An origin-form target names no host anywhere, so the authority filled in for one is the local+ * socket the request arrived on, the address the client actually reached. It carries no virtual-host+ * meaning: an address literal names no S3 bucket, Lambda function URL, or custom domain, so the+ * request routes path-style, which is what a client sending no {@code Host} asked for.+ *+ * <p>An absolute-form target, which RFC 9112 section 3.2.2 requires a server to accept, states an+ * authority of its own: {@code GET http://bucket.s3.localhost:4566/key HTTP/1.0} names a bucket and+ * has to keep routing to it. It is broken without a {@code Host} header just the same, because the+ * authority vertx-web builds its absolute URI from is that header alone. Prepending the local socket+ * to a target that is already absolute would corrupt it instead: {@code URI} reads the concatenation+ * as the authority {@code 127.0.0.1:4566http:} and the path {@code //bucket.s3.localhost:4566/key}.+ * Asterisk-form names no host at all and is left alone, as it is with a {@code Host} header.+ */+@Provider+@PreMatching+@Priority(1) // ahead of every host-routing filter, the lowest of which is LambdaUrlRoutingFilter (5)+@ApplicationScoped+public class MissingHostHeaderFilter implements ContainerRequestFilter {++ private static final Logger LOG = Logger.getLogger(MissingHostHeaderFilter.class);++ private final CurrentVertxRequest currentVertxRequest;++ @Inject+ public MissingHostHeaderFilter(CurrentVertxRequest currentVertxRequest) {+ this.currentVertxRequest = currentVertxRequest;+ }++ @Override+ public void filter(ContainerRequestContext requestContext) {+ RoutingContext routingContext = currentVertxRequest.getCurrent();+ if (routingContext == null) {+ return;+ }+ // An HTTP/2 request has no Host header either, but carries :authority, which Vert.x+ // surfaces here. A null authority is the one case with nothing to route by.+ HttpServerRequest request = routingContext.request();+ if (request.authority() != null) {+ return;+ }+ String authority = requestAuthority(request);+ if (authority == null) {+ return;+ }+ // The scheme is the connection's rather than the target's, which is what vertx-web itself+ // uses once a Host header supplies the authority.+ URI requestUri = URI.create(request.scheme() + "://" + authority + pathAndQuery(request));+ // The two-argument form: the one-argument one derives the base URI from UriInfo, which is+ // the accessor that fails without an authority.+ requestContext.setRequestUri(requestUri.resolve("/"), requestUri);+ LOG.debugv("Request without an authority: {0} -> {1}", request.uri(), requestUri);+ }++ /**+ * The authority to route by: the one an absolute-form target states, the local socket for an+ * origin-form one. Null when the target names no host and none can stand in for it.+ */+ static String requestAuthority(HttpServerRequest request) {+ String target = request.uri();+ if (target.startsWith("/")) {+ return localAuthority(request.localAddress());+ }+ URI absolute;+ try {+ absolute = new URI(target);+ } catch (URISyntaxException malformed) {+ LOG.debugv("Request target is neither origin-form nor an absolute URI: {0}", target);+ return null;+ }+ // Asterisk-form and authority-form land here with no authority to read.+ return absolute.isAbsolute() ? absolute.getRawAuthority() : null;+ }++ /** The origin-form tail, which Vert.x parses out of an absolute-form target as well. */+ private static String pathAndQuery(HttpServerRequest request) {+ String query = request.query();+ return query == null ? request.path() : request.path() + "?" + query;+ }++ /** {@code host:port}, bracketing an IPv6 literal the way RFC 3986 requires. */+ static String localAuthority(SocketAddress localAddress) {+ if (localAddress == null || localAddress.host() == null) {+ return null;+ }+ String host = localAddress.host();+ if (host.indexOf(':') >= 0 && !host.startsWith("[")) {+ host = "[" + host + "]";+ }+ return localAddress.port() > 0 ? host + ":" + localAddress.port() : host;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/core/common/MissingHostHeaderFilterTest.java b/src/test/java/io/github/hectorvent/floci/core/common/MissingHostHeaderFilterTest.javanew file mode 100644index 0000000000..e8fe454a53--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/core/common/MissingHostHeaderFilterTest.java@@ -0,0 +1,75 @@+package io.github.hectorvent.floci.core.common;++import io.vertx.core.http.HttpServerRequest;+import io.vertx.core.net.SocketAddress;+import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++class MissingHostHeaderFilterTest {++ @Test+ void originFormTakesTheAuthorityFromTheLocalSocket() {+ assertEquals("127.0.0.1:4566", MissingHostHeaderFilter.requestAuthority(request("/_floci/health")));+ }++ @Test+ void absoluteFormTakesTheAuthorityFromTheTarget() {+ assertEquals("bucket.s3.localhost:4566",+ MissingHostHeaderFilter.requestAuthority(request("http://bucket.s3.localhost:4566/key")));+ }++ @Test+ void absoluteFormWithoutAPathTakesTheAuthorityFromTheTarget() {+ assertEquals("bucket.s3.localhost:4566",+ MissingHostHeaderFilter.requestAuthority(request("http://bucket.s3.localhost:4566")));+ }++ @Test+ void asteriskFormHasNoAuthority() {+ assertNull(MissingHostHeaderFilter.requestAuthority(request("*")));+ }++ @Test+ void malformedTargetHasNoAuthority() {+ assertNull(MissingHostHeaderFilter.requestAuthority(request("http://bucket.s3.localhost:45 66/key")));+ }++ @Test+ void localAuthorityKeepsIpv4Literal() {+ assertEquals("127.0.0.1:4566",+ MissingHostHeaderFilter.localAuthority(SocketAddress.inetSocketAddress(4566, "127.0.0.1")));+ }++ @Test+ void localAuthorityBracketsIpv6Literal() {+ assertEquals("[::1]:4566",+ MissingHostHeaderFilter.localAuthority(SocketAddress.inetSocketAddress(4566, "::1")));+ }++ @Test+ void localAuthorityLeavesBracketedIpv6Alone() {+ assertEquals("[::1]:4566",+ MissingHostHeaderFilter.localAuthority(SocketAddress.inetSocketAddress(4566, "[::1]")));+ }++ @Test+ void localAuthorityWithoutAddressIsNull() {+ assertNull(MissingHostHeaderFilter.localAuthority(null));+ }++ @Test+ void localAuthorityOfDomainSocketIsNull() {+ assertNull(MissingHostHeaderFilter.localAuthority(SocketAddress.domainSocketAddress("/tmp/floci.sock")));+ }++ private static HttpServerRequest request(String target) {+ HttpServerRequest request = mock(HttpServerRequest.class);+ when(request.uri()).thenReturn(target);+ when(request.localAddress()).thenReturn(SocketAddress.inetSocketAddress(4566, "127.0.0.1"));+ return request;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/core/common/MissingHostHeaderIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/core/common/MissingHostHeaderIntegrationTest.javanew file mode 100644index 0000000000..7e1be6b7cb--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/core/common/MissingHostHeaderIntegrationTest.java@@ -0,0 +1,100 @@+package io.github.hectorvent.floci.core.common;++import io.quarkus.test.junit.QuarkusTest;+import io.restassured.RestAssured;+import org.junit.jupiter.api.Test;++import java.io.ByteArrayOutputStream;+import java.io.InputStream;+import java.io.OutputStream;+import java.net.Socket;+import java.nio.charset.StandardCharsets;++import static io.restassured.RestAssured.given;+import static org.hamcrest.MatcherAssert.assertThat;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.startsWith;++/**+ * A Host-less request cannot be expressed with RestAssured or any SDK client, so these go over a+ * raw socket. HTTP/1.0 omitting Host is legal and used to answer 500; HTTP/1.1 omitting it is a+ * protocol violation that Vert.x rejects before the router, and still should. An absolute-form+ * target states its own authority and must keep routing by it, Host header or not.+ */+@QuarkusTest+class MissingHostHeaderIntegrationTest {++ @Test+ void http10WithoutHostHeaderServesHealth() throws Exception {+ String response = rawRequest("GET /_floci/health HTTP/1.0\r\n\r\n");++ assertThat(response, startsWith("HTTP/1.0 200 OK"));+ assertThat(response, containsString("\"edition\":\"community\""));+ }++ @Test+ void http10WithoutHostHeaderServesPathStyleS3() throws Exception {+ String response = rawRequest("GET / HTTP/1.0\r\n\r\n");++ assertThat(response, startsWith("HTTP/1.0 200 OK"));+ assertThat(response, containsString("ListAllMyBucketsResult"));+ }++ @Test+ void http10AbsoluteFormWithoutHostHeaderServesHealth() throws Exception {+ String response = rawRequest(+ "GET http://127.0.0.1:" + RestAssured.port + "/_floci/health HTTP/1.0\r\n\r\n");++ assertThat(response, startsWith("HTTP/1.0 200 OK"));+ assertThat(response, containsString("\"edition\":\"community\""));+ }++ @Test+ void http10AbsoluteFormWithoutHostHeaderRoutesByTheTargetAuthority() throws Exception {+ String bucket = "absolute-form-bucket";+ given().put("/" + bucket).then().statusCode(200);+ try {+ String response = rawRequest("GET http://" + bucket + ".s3.localhost:"+ + RestAssured.port + "/ HTTP/1.0\r\n\r\n");++ assertThat(response, startsWith("HTTP/1.0 200 OK"));+ assertThat(response, containsString("<Name>" + bucket + "</Name>"));+ } finally {+ given().delete("/" + bucket);+ }+ }++ @Test+ void http11WithoutHostHeaderIsRejected() throws Exception {+ String response = rawRequest("GET /_floci/health HTTP/1.1\r\nConnection: close\r\n\r\n");++ assertThat(response, startsWith("HTTP/1.1 400 Bad Request"));+ }++ @Test+ void http11WithHostHeaderServesHealth() throws Exception {+ String response = rawRequest(+ "GET /_floci/health HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n");++ assertThat(response, startsWith("HTTP/1.1 200 OK"));+ assertThat(response, containsString("\"edition\":\"community\""));+ }++ private String rawRequest(String request) throws Exception {+ try (Socket socket = new Socket("127.0.0.1", RestAssured.port)) {+ socket.setSoTimeout(15_000);+ OutputStream out = socket.getOutputStream();+ out.write(request.getBytes(StandardCharsets.US_ASCII));+ out.flush();++ InputStream in = socket.getInputStream();+ ByteArrayOutputStream received = new ByteArrayOutputStream();+ byte[] chunk = new byte[8192];+ int read;+ while ((read = in.read(chunk)) != -1) {+ received.write(chunk, 0, read);+ }+ return received.toString(StandardCharsets.UTF_8);+ }+ }+}