Light, fluffy, and always free - The AWS Local Emulator alternative
fix(apigatewayv2): pin websocket HTTP targets (#4341)
Ben Younes5467506fca8c
diff --git a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/HttpProxyInvoker.java b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/HttpProxyInvoker.javaindex fa898e6bbd..02f08690a3 100644--- a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/HttpProxyInvoker.java+++ b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/HttpProxyInvoker.java@@ -9,13 +9,9 @@ import javax.net.ssl.SSLParameters;import javax.net.ssl.TrustManager;import javax.net.ssl.X509TrustManager;-import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.InputStream;-import java.io.OutputStream;import java.net.InetAddress;-import java.net.InetSocketAddress;-import java.net.Socket;import java.net.URI;import java.net.URLEncoder;import java.net.UnknownHostException;@@ -56,9 +52,6 @@ import java.util.StringJoiner;public class HttpProxyInvoker {private static final Logger LOG = Logger.getLogger(HttpProxyInvoker.class);- /** API Gateway's integration payload quota: 10 MB, not adjustable. */- private static final int MAX_RESPONSE_BYTES = 10 * 1024 * 1024;-/** RFC 7230 hop-by-hop headers that must not be forwarded across proxies. */private static final Set<String> HOP_BY_HOP = Set.of("connection", "keep-alive", "proxy-authenticate", "proxy-authorization",@@ -332,7 +325,7 @@ public class HttpProxyInvoker {if (finalUrl.startsWith("http://") && (hasHeader(builder, "Host") || isNamedHost(finalUrl))) {try {return invokeHttpPinned(finalUrl, method, builder, options.timeout());- } catch (ResponseTooLargeException ignored) {+ } catch (PinnedHttpClient.ResponseTooLargeException ignored) {return tooLargeResult();} catch (Exception e) {LOG.warnv("HTTP_PROXY backend call failed: {0}", e.getMessage());@@ -374,7 +367,7 @@ public class HttpProxyInvoker {clientFor(options).send(hrb.build(), HttpResponse.BodyHandlers.ofInputStream());byte[] body;try (InputStream in = resp.body()) {- body = readBounded(in);+ body = PinnedHttpClient.readBounded(in);}Map<String, List<String>> respHeaders = new LinkedHashMap<>();for (Map.Entry<String, List<String>> e : resp.headers().map().entrySet()) {@@ -382,7 +375,7 @@ public class HttpProxyInvoker {respHeaders.put(e.getKey(), List.copyOf(e.getValue()));}return new ProxyResult(resp.statusCode(), respHeaders, body);- } catch (ResponseTooLargeException ignored) {+ } catch (PinnedHttpClient.ResponseTooLargeException ignored) {return tooLargeResult();} catch (Exception e) {LOG.warnv("HTTP_PROXY backend call failed: {0}", e.getMessage());@@ -419,184 +412,25 @@ public class HttpProxyInvoker {ProxyRequestBuilder builder, Duration timeout)throws IOException {URI uri = URI.create(finalUrl);- int port = uri.getPort() == -1 ? 80 : uri.getPort();- String path = uri.getRawPath();- if (path == null || path.isBlank()) {- path = "/";- }- if (uri.getRawQuery() != null) {- path += "?" + uri.getRawQuery();- }-InetAddress[] targets = resolveNonMetadataTarget(uri.getHost());- String hostHeader = firstHeader(builder, "Host");- if (hostHeader == null) {- hostHeader = uri.getRawAuthority();- }- try (Socket socket = new Socket()) {- socket.connect(new InetSocketAddress(targets[0], port), 10_000);- socket.setSoTimeout((int) Math.min(timeout.toMillis(), Integer.MAX_VALUE));-- OutputStream out = socket.getOutputStream();- byte[] body = builder.body() == null ? new byte[0] : builder.body();- StringBuilder request = new StringBuilder()- .append(method.toUpperCase(Locale.ROOT)).append(' ').append(path).append(" HTTP/1.1\r\n")- .append("Host: ").append(hostHeader).append("\r\n")- .append("Connection: close\r\n");- for (Map.Entry<String, List<String>> header : builder.headers().entrySet()) {- String name = header.getKey();- String lower = name.toLowerCase(Locale.ROOT);- if (RESTRICTED.contains(lower) || lower.equals("connection")) {- continue;- }- for (String value : header.getValue()) {- request.append(name).append(": ").append(value).append("\r\n");- }- }- if (body.length > 0) {- request.append("Content-Length: ").append(body.length).append("\r\n");- }- request.append("\r\n");- out.write(request.toString().getBytes(StandardCharsets.ISO_8859_1));- out.write(body);- out.flush();-- return readRawHttpResponse(socket.getInputStream(), method);- }- }- private static ProxyResult readRawHttpResponse(InputStream input, String method) throws IOException {- ByteArrayOutputStream headerBytes = new ByteArrayOutputStream();- int previous3 = -1;- int previous2 = -1;- int previous1 = -1;- int current;- while ((current = input.read()) != -1) {- headerBytes.write(current);- if (previous3 == '\r' && previous2 == '\n' && previous1 == '\r' && current == '\n') {- break;+ Map<String, List<String>> requestHeaders = new LinkedHashMap<>();+ for (Map.Entry<String, List<String>> header : builder.headers().entrySet()) {+ if (!RESTRICTED.contains(header.getKey().toLowerCase(Locale.ROOT))) {+ requestHeaders.put(header.getKey(), header.getValue());}- previous3 = previous2;- previous2 = previous1;- previous1 = current;}- String headersText = headerBytes.toString(StandardCharsets.ISO_8859_1);- String[] lines = headersText.split("\r\n");- if (lines.length == 0 || !lines[0].startsWith("HTTP/")) {- throw new IOException("invalid HTTP response");- }- String[] status = lines[0].split(" ", 3);- int statusCode = Integer.parseInt(status[1]);- Map<String, List<String>> headers = new LinkedHashMap<>();- String transferEncoding = null;- long contentLength = -1;- for (int i = 1; i < lines.length; i++) {- int separator = lines[i].indexOf(':');- if (separator <= 0) {- continue;- }- String name = lines[i].substring(0, separator);- String value = lines[i].substring(separator + 1).trim();- if (name.equalsIgnoreCase("Transfer-Encoding")) {- transferEncoding = value;- }- if (name.equalsIgnoreCase("Content-Length")) {- contentLength = Long.parseLong(value);- }- if (!HOP_BY_HOP.contains(name.toLowerCase(Locale.ROOT))) {- // Repeated header lines (Set-Cookie) accumulate rather than overwrite.- headers.computeIfAbsent(name, k -> new java.util.ArrayList<>()).add(value);- }- }- boolean bodyless = "HEAD".equalsIgnoreCase(method) || statusCode == 204 || statusCode == 304- || (statusCode >= 100 && statusCode < 200);- byte[] body = bodyless- ? new byte[0]- : transferEncoding != null && transferEncoding.toLowerCase(Locale.ROOT).contains("chunked")- ? readChunkedBody(input)- : contentLength >= 0 ? readContentLength(input, contentLength) : readBounded(input);- return new ProxyResult(statusCode, headers, body);- }-- private static byte[] readChunkedBody(InputStream input) throws IOException {- ByteArrayOutputStream body = new ByteArrayOutputStream();- while (true) {- String sizeLine = readAsciiLine(input);- if (sizeLine == null) {- throw new IOException("unexpected end of chunked response");- }- int extension = sizeLine.indexOf(';');- int size = Integer.parseInt((extension >= 0 ? sizeLine.substring(0, extension) : sizeLine).trim(), 16);- if (size == 0) {- while (true) {- String trailer = readAsciiLine(input);- if (trailer == null || trailer.isEmpty()) {- return body.toByteArray();- }- }- }- if (size < 0 || size > MAX_RESPONSE_BYTES - body.size()) {- throw new ResponseTooLargeException();- }- body.write(input.readNBytes(size));- expectCrlf(input);- }- }-- private static byte[] readContentLength(InputStream input, long contentLength) throws IOException {- if (contentLength > MAX_RESPONSE_BYTES) {- throw new ResponseTooLargeException();- }- return input.readNBytes((int) contentLength);- }-- /** Reads to end of stream, failing once more than the payload quota has arrived. */- private static byte[] readBounded(InputStream input) throws IOException {- byte[] body = input.readNBytes(MAX_RESPONSE_BYTES + 1);- if (body.length > MAX_RESPONSE_BYTES) {- throw new ResponseTooLargeException();- }- return body;- }-- private static final class ResponseTooLargeException extends IOException {- ResponseTooLargeException() {- super("integration response exceeds " + MAX_RESPONSE_BYTES + " bytes");- }- }-- private static String readAsciiLine(InputStream input) throws IOException {- ByteArrayOutputStream line = new ByteArrayOutputStream();- while (true) {- int b = input.read();- if (b == -1) {- return line.size() == 0 ? null : line.toString(StandardCharsets.ISO_8859_1);- }- if (b == '\n') {- return line.toString(StandardCharsets.ISO_8859_1);- }- if (b == '\r') {- int next = input.read();- if (next == '\n') {- return line.toString(StandardCharsets.ISO_8859_1);- }- line.write(b);- if (next != -1) {- line.write(next);- }- continue;- }- line.write(b);- }- }+ PinnedHttpClient.Response response = PinnedHttpClient.send(+ targets[0], uri, method, firstHeader(builder, "Host"),+ requestHeaders, builder.body(), timeout);- private static void expectCrlf(InputStream input) throws IOException {- int cr = input.read();- int lf = input.read();- if (cr != '\r' || lf != '\n') {- throw new IOException("invalid chunked response");+ Map<String, List<String>> respHeaders = new LinkedHashMap<>();+ for (Map.Entry<String, List<String>> header : response.headers().entrySet()) {+ if (HOP_BY_HOP.contains(header.getKey().toLowerCase(Locale.ROOT))) continue;+ respHeaders.put(header.getKey(), List.copyOf(header.getValue()));}+ return new ProxyResult(response.statusCode(), respHeaders, response.body());}private static String buildFinalUrl(ProxyRequestBuilder builder) {@@ -615,7 +449,8 @@ public class HttpProxyInvoker {}private static ProxyResult tooLargeResult() {- LOG.warnv("HTTP_PROXY backend response exceeds the {0}-byte payload quota", MAX_RESPONSE_BYTES);+ LOG.warnv("HTTP_PROXY backend response exceeds the {0}-byte payload quota",+ PinnedHttpClient.MAX_RESPONSE_BYTES);return ProxyResult.withSingleValueHeaders(413,Map.of("Content-Type", "application/json"),"{\"message\":\"Request Entity Too Large\"}".getBytes(StandardCharsets.UTF_8));diff --git a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/PinnedHttpClient.java b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/PinnedHttpClient.javanew file mode 100644index 0000000000..9d7e9e300c--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/proxy/PinnedHttpClient.java@@ -0,0 +1,280 @@+package io.github.hectorvent.floci.services.apigatewayv2.proxy;++import java.io.ByteArrayOutputStream;+import java.io.IOException;+import java.io.InputStream;+import java.io.OutputStream;+import java.net.InetAddress;+import java.net.InetSocketAddress;+import java.net.Socket;+import java.net.URI;+import java.nio.charset.StandardCharsets;+import java.time.Duration;+import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Locale;+import java.util.Map;+import java.util.Set;++/**+ * Sends one plain-HTTP request to an already checked {@link InetAddress} and reads the response+ * off the socket.+ *+ * <p>The address is supplied by the caller, which resolves the integration host once and runs it+ * through {@code SsrfProtection}. Connecting to that same address, rather than handing the name+ * back to a client that would resolve it again, is what closes the DNS-rebinding window between+ * the check and the connection.+ *+ * <p>Response framing is bounded on every path: the body stops at the API Gateway payload quota+ * whether it arrives with a Content-Length, chunked, or delimited by the connection closing, chunk+ * sizes are rejected when negative or oversized, and the CRLF that must follow each chunk is+ * verified. Both HTTP_PROXY and the WebSocket integrations go through here so those limits stay in+ * one place.+ */+public final class PinnedHttpClient {++ /** API Gateway's integration payload quota: 10 MB, not adjustable. */+ public static final int MAX_RESPONSE_BYTES = 10 * 1024 * 1024;++ private static final int CONNECT_TIMEOUT_MILLIS = 10_000;+ private static final int DEFAULT_HTTP_PORT = 80;+ private static final int MAX_STATUS_LINE_PARTS = 3;++ /** Written by this client itself, so a caller-supplied copy would duplicate the header. */+ private static final Set<String> CLIENT_OWNED_HEADERS =+ Set.of("host", "connection", "content-length");++ /** Methods that carry no body, so an empty payload needs no Content-Length. */+ private static final Set<String> BODYLESS_METHODS =+ Set.of("GET", "HEAD", "OPTIONS", "DELETE", "TRACE");++ private PinnedHttpClient() {+ }++ /**+ * A backend response, with the header names as the backend spelled them and repeated header+ * lines kept separate.+ */+ public record Response(int statusCode, Map<String, List<String>> headers, byte[] body) {+ }++ /** Raised once more than the payload quota has arrived, on any of the framing paths. */+ public static final class ResponseTooLargeException extends IOException {+ public ResponseTooLargeException() {+ super("integration response exceeds " + MAX_RESPONSE_BYTES + " bytes");+ }+ }++ /**+ * Connects to {@code address} and exchanges one request/response pair.+ *+ * @param address the checked address to connect to, never re-resolved from the URI+ * @param target the integration URI, read for the port, path, query and default Host+ * @param method the HTTP method to send+ * @param hostHeader the Host header to advertise, or null to use the target's host and port+ * @param headers extra request headers; Host, Connection and Content-Length are ignored+ * because this client writes them itself+ * @param body the request body, may be null or empty+ * @param timeout how long to wait for the backend to respond+ */+ public static Response send(InetAddress address, URI target, String method, String hostHeader,+ Map<String, List<String>> headers, byte[] body, Duration timeout)+ throws IOException {+ byte[] payload = body == null ? new byte[0] : body;+ String upperMethod = method.toUpperCase(Locale.ROOT);+ int port = target.getPort() == -1 ? DEFAULT_HTTP_PORT : target.getPort();++ try (Socket socket = new Socket()) {+ socket.connect(new InetSocketAddress(address, port), CONNECT_TIMEOUT_MILLIS);+ socket.setSoTimeout((int) Math.min(timeout.toMillis(), Integer.MAX_VALUE));++ OutputStream out = socket.getOutputStream();+ String requestHead = buildRequestHead(+ target, upperMethod,+ hostHeader == null ? hostAndPort(target) : hostHeader,+ headers, payload.length);+ out.write(requestHead.getBytes(StandardCharsets.ISO_8859_1));+ out.write(payload);+ out.flush();++ return readResponse(socket.getInputStream(), upperMethod);+ }+ }++ /** The authority to advertise as Host, without any {@code user:pass@} the URI carries. */+ private static String hostAndPort(URI target) {+ String host = target.getHost();+ if (host == null) {+ return target.getRawAuthority();+ }+ return target.getPort() == -1 ? host : host + ":" + target.getPort();+ }++ private static String buildRequestHead(URI target, String method, String hostHeader,+ Map<String, List<String>> headers, int contentLength) {+ String path = target.getRawPath();+ if (path == null || path.isBlank()) {+ path = "/";+ }+ if (target.getRawQuery() != null) {+ path += "?" + target.getRawQuery();+ }++ StringBuilder request = new StringBuilder()+ .append(method).append(' ').append(path).append(" HTTP/1.1\r\n")+ .append("Host: ").append(hostHeader).append("\r\n")+ .append("Connection: close\r\n");+ if (headers != null) {+ for (Map.Entry<String, List<String>> header : headers.entrySet()) {+ if (CLIENT_OWNED_HEADERS.contains(header.getKey().toLowerCase(Locale.ROOT))) {+ continue;+ }+ for (String value : header.getValue()) {+ request.append(header.getKey()).append(": ").append(value).append("\r\n");+ }+ }+ }+ if (contentLength > 0 || !BODYLESS_METHODS.contains(method)) {+ request.append("Content-Length: ").append(contentLength).append("\r\n");+ }+ return request.append("\r\n").toString();+ }++ private static Response readResponse(InputStream input, String method) throws IOException {+ String headersText = readHead(input);+ String[] lines = headersText.split("\r\n");+ if (lines.length == 0 || !lines[0].startsWith("HTTP/")) {+ throw new IOException("invalid HTTP response");+ }+ String[] status = lines[0].split(" ", MAX_STATUS_LINE_PARTS);+ if (status.length < 2) {+ throw new IOException("invalid HTTP status line");+ }+ int statusCode = Integer.parseInt(status[1]);++ Map<String, List<String>> headers = new LinkedHashMap<>();+ String transferEncoding = null;+ long contentLength = -1;+ for (int i = 1; i < lines.length; i++) {+ int separator = lines[i].indexOf(':');+ if (separator <= 0) {+ continue;+ }+ String name = lines[i].substring(0, separator);+ String value = lines[i].substring(separator + 1).trim();+ if (name.equalsIgnoreCase("Transfer-Encoding")) {+ transferEncoding = value;+ }+ if (name.equalsIgnoreCase("Content-Length")) {+ contentLength = Long.parseLong(value);+ }+ // Repeated header lines (Set-Cookie) accumulate rather than overwrite.+ headers.computeIfAbsent(name, k -> new ArrayList<>()).add(value);+ }++ boolean bodyless = "HEAD".equals(method) || statusCode == 204 || statusCode == 304+ || (statusCode >= 100 && statusCode < 200);+ byte[] body = bodyless+ ? new byte[0]+ : transferEncoding != null+ && transferEncoding.toLowerCase(Locale.ROOT).contains("chunked")+ ? readChunkedBody(input)+ : contentLength >= 0 ? readContentLength(input, contentLength) : readBounded(input);+ return new Response(statusCode, headers, body);+ }++ /** Reads up to and including the blank line that ends the response head. */+ private static String readHead(InputStream input) throws IOException {+ ByteArrayOutputStream headBytes = new ByteArrayOutputStream();+ int previous3 = -1;+ int previous2 = -1;+ int previous1 = -1;+ int current;+ while ((current = input.read()) != -1) {+ headBytes.write(current);+ if (previous3 == '\r' && previous2 == '\n' && previous1 == '\r' && current == '\n') {+ break;+ }+ previous3 = previous2;+ previous2 = previous1;+ previous1 = current;+ }+ return headBytes.toString(StandardCharsets.ISO_8859_1);+ }++ private static byte[] readChunkedBody(InputStream input) throws IOException {+ ByteArrayOutputStream body = new ByteArrayOutputStream();+ while (true) {+ String sizeLine = readAsciiLine(input);+ if (sizeLine == null) {+ throw new IOException("unexpected end of chunked response");+ }+ int extension = sizeLine.indexOf(';');+ int size = Integer.parseInt(+ (extension >= 0 ? sizeLine.substring(0, extension) : sizeLine).trim(), 16);+ if (size == 0) {+ while (true) {+ String trailer = readAsciiLine(input);+ if (trailer == null || trailer.isEmpty()) {+ return body.toByteArray();+ }+ }+ }+ if (size < 0 || size > MAX_RESPONSE_BYTES - body.size()) {+ throw new ResponseTooLargeException();+ }+ body.write(input.readNBytes(size));+ expectCrlf(input);+ }+ }++ private static byte[] readContentLength(InputStream input, long contentLength) throws IOException {+ if (contentLength > MAX_RESPONSE_BYTES) {+ throw new ResponseTooLargeException();+ }+ return input.readNBytes((int) contentLength);+ }++ /** Reads to end of stream, failing once more than the payload quota has arrived. */+ public static byte[] readBounded(InputStream input) throws IOException {+ byte[] body = input.readNBytes(MAX_RESPONSE_BYTES + 1);+ if (body.length > MAX_RESPONSE_BYTES) {+ throw new ResponseTooLargeException();+ }+ return body;+ }++ private static String readAsciiLine(InputStream input) throws IOException {+ ByteArrayOutputStream line = new ByteArrayOutputStream();+ while (true) {+ int b = input.read();+ if (b == -1) {+ return line.size() == 0 ? null : line.toString(StandardCharsets.ISO_8859_1);+ }+ if (b == '\n') {+ return line.toString(StandardCharsets.ISO_8859_1);+ }+ if (b == '\r') {+ int next = input.read();+ if (next == '\n') {+ return line.toString(StandardCharsets.ISO_8859_1);+ }+ line.write(b);+ if (next != -1) {+ line.write(next);+ }+ continue;+ }+ line.write(b);+ }+ }++ private static void expectCrlf(InputStream input) throws IOException {+ int cr = input.read();+ int lf = input.read();+ if (cr != '\r' || lf != '\n') {+ throw new IOException("invalid chunked response");+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/websocket/WebSocketIntegrationInvoker.java b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/websocket/WebSocketIntegrationInvoker.javaindex 7bdded4721..24c6d0ab29 100644--- a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/websocket/WebSocketIntegrationInvoker.java+++ b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/websocket/WebSocketIntegrationInvoker.java@@ -6,6 +6,7 @@ import io.github.hectorvent.floci.core.common.SsrfProtection;import io.github.hectorvent.floci.services.apigateway.AwsServiceRouter;import io.github.hectorvent.floci.services.apigateway.VtlTemplateEngine;import io.github.hectorvent.floci.services.apigatewayv2.model.Integration;+import io.github.hectorvent.floci.services.apigatewayv2.proxy.PinnedHttpClient;import io.github.hectorvent.floci.services.lambda.LambdaArnUtils;import io.github.hectorvent.floci.services.lambda.LambdaService;import io.github.hectorvent.floci.services.lambda.model.InvocationType;@@ -15,13 +16,18 @@ import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.jboss.logging.Logger;+import java.io.IOException;import java.net.InetAddress;import java.net.URI;import java.net.http.HttpClient;import java.net.http.HttpRequest;import java.net.http.HttpResponse;import java.nio.charset.StandardCharsets;+import java.time.Duration;import java.util.Collections;+import java.util.HashMap;+import java.util.Iterator;+import java.util.List;import java.util.Map;import java.util.regex.Matcher;import java.util.regex.Pattern;@@ -40,21 +46,41 @@ public class WebSocketIntegrationInvoker {*/private static final Pattern STAGE_VAR_PATTERN =Pattern.compile("\\$\\{stageVariables\\.([^}]+)}");+ private static final String APPLICATION_JSON = "application/json";+ private static final String CONTENT_TYPE_HEADER = "Content-Type";+ private static final String HTTP_SCHEME = "http";+ private static final Duration BACKEND_TIMEOUT = Duration.ofSeconds(10);private final LambdaService lambdaService;private final AwsServiceRouter serviceRouter;private final ObjectMapper objectMapper;private final VtlTemplateEngine vtlEngine;private final HttpClient httpClient;+ private final AddressResolver addressResolver;@Injectpublic WebSocketIntegrationInvoker(LambdaService lambdaService, AwsServiceRouter serviceRouter,ObjectMapper objectMapper, VtlTemplateEngine vtlEngine) {+ this(lambdaService, serviceRouter, objectMapper, vtlEngine, InetAddress::getAllByName);+ }++ WebSocketIntegrationInvoker(LambdaService lambdaService, AwsServiceRouter serviceRouter,+ ObjectMapper objectMapper, VtlTemplateEngine vtlEngine,+ AddressResolver addressResolver) {this.lambdaService = lambdaService;this.serviceRouter = serviceRouter;this.objectMapper = objectMapper;this.vtlEngine = vtlEngine;this.httpClient = HttpClient.newHttpClient();+ this.addressResolver = addressResolver;+ }++ @FunctionalInterface+ interface AddressResolver {+ InetAddress[] resolve(String host) throws IOException;+ }++ private record HttpBackendResponse(int statusCode, String body) {}@PreDestroy@@ -155,11 +181,11 @@ public class WebSocketIntegrationInvoker {}// Extract response headers (used by $connect to propagate to upgrade response)if (responseNode.has("headers") && responseNode.get("headers").isObject()) {- responseHeaders = new java.util.HashMap<>();- var headersNode = responseNode.get("headers");- var fields = headersNode.fields();+ responseHeaders = new HashMap<>();+ JsonNode headersNode = responseNode.get("headers");+ Iterator<Map.Entry<String, JsonNode>> fields = headersNode.fields();while (fields.hasNext()) {- var field = fields.next();+ Map.Entry<String, JsonNode> field = fields.next();responseHeaders.put(field.getKey(), field.getValue().asText());}}@@ -244,15 +270,7 @@ public class WebSocketIntegrationInvoker {try {URI target = URI.create(uri);- SsrfProtection.rejectMetadataAddresses(InetAddress.getAllByName(target.getHost()), target.getHost());- HttpRequest request = HttpRequest.newBuilder()- .uri(target)- .header("Content-Type", "application/json")- .POST(HttpRequest.BodyPublishers.ofString(eventJson, StandardCharsets.UTF_8))- .build();-- HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());-+ HttpBackendResponse response = postToHttpEndpoint(target, eventJson);return new IntegrationResult(response.statusCode(), response.body(), null);} catch (Exception e) {LOG.warnv("HTTP_PROXY integration call failed: {0}", e.getMessage());@@ -294,15 +312,7 @@ public class WebSocketIntegrationInvoker {try {URI target = URI.create(uri);- SsrfProtection.rejectMetadataAddresses(InetAddress.getAllByName(target.getHost()), target.getHost());- HttpRequest request = HttpRequest.newBuilder()- .uri(target)- .header("Content-Type", "application/json")- .POST(HttpRequest.BodyPublishers.ofString(transformedPayload, StandardCharsets.UTF_8))- .build();-- HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());-+ HttpBackendResponse response = postToHttpEndpoint(target, transformedPayload);int statusCode = response.statusCode();String body = response.body();@@ -319,6 +329,44 @@ public class WebSocketIntegrationInvoker {}}+ private HttpBackendResponse postToHttpEndpoint(URI target, String payload)+ throws IOException, InterruptedException {+ if (HTTP_SCHEME.equalsIgnoreCase(target.getScheme())) {+ return postToPinnedHttpEndpoint(target, payload);+ }++ resolveNonMetadataTarget(target.getHost());+ HttpRequest request = HttpRequest.newBuilder()+ .uri(target)+ .header(CONTENT_TYPE_HEADER, APPLICATION_JSON)+ .POST(HttpRequest.BodyPublishers.ofString(payload, StandardCharsets.UTF_8))+ .build();+ HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());+ return new HttpBackendResponse(response.statusCode(), response.body());+ }++ private InetAddress[] resolveNonMetadataTarget(String host) throws IOException {+ if (host == null || host.isBlank()) {+ throw new IOException("integration URI has no host");+ }+ return SsrfProtection.rejectMetadataAddresses(addressResolver.resolve(host), host);+ }++ /**+ * Sends the payload to the address the host resolved to, instead of letting a client resolve+ * the name a second time. The shared {@link PinnedHttpClient} owns the request writing and the+ * bounded response parsing, so HTTP_PROXY and the WebSocket integrations keep the same limits.+ */+ private HttpBackendResponse postToPinnedHttpEndpoint(URI target, String payload) throws IOException {+ InetAddress[] targets = resolveNonMetadataTarget(target.getHost());+ PinnedHttpClient.Response response = PinnedHttpClient.send(+ targets[0], target, "POST", null,+ Map.of(CONTENT_TYPE_HEADER, List.of(APPLICATION_JSON)),+ payload.getBytes(StandardCharsets.UTF_8), BACKEND_TIMEOUT);+ return new HttpBackendResponse(+ response.statusCode(), new String(response.body(), StandardCharsets.UTF_8));+ }+/*** Handle a MOCK integration — no backend invocation.* Evaluates templateSelectionExpression against requestTemplates to determine status code,diff --git a/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/websocket/WebSocketIntegrationInvokerHttpTargetTest.java b/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/websocket/WebSocketIntegrationInvokerHttpTargetTest.javaindex aba9d36781..8926e21822 100644--- a/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/websocket/WebSocketIntegrationInvokerHttpTargetTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/apigatewayv2/websocket/WebSocketIntegrationInvokerHttpTargetTest.java@@ -12,9 +12,15 @@ import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import java.io.IOException;+import java.io.OutputStream;+import java.net.InetAddress;import java.net.InetSocketAddress;+import java.net.ServerSocket;+import java.net.Socket;import java.nio.charset.StandardCharsets;import java.util.Map;+import java.util.concurrent.atomic.AtomicInteger;+import java.util.concurrent.atomic.AtomicReference;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertNotNull;@@ -25,6 +31,7 @@ class WebSocketIntegrationInvokerHttpTargetTest {private WebSocketIntegrationInvoker invoker;private HttpServer backend;+ private final AtomicReference<String> receivedHost = new AtomicReference<>();@BeforeEachvoid setUp() throws IOException {@@ -35,6 +42,7 @@ class WebSocketIntegrationInvokerHttpTargetTest {mock(VtlTemplateEngine.class));backend = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);backend.createContext("/", exchange -> {+ receivedHost.set(exchange.getRequestHeaders().getFirst("Host"));byte[] body = "ok".getBytes(StandardCharsets.UTF_8);exchange.sendResponseHeaders(200, body.length);exchange.getResponseBody().write(body);@@ -80,4 +88,81 @@ class WebSocketIntegrationInvokerHttpTargetTest {assertEquals(200, result.statusCode());assertEquals("ok", result.body());}++ @Test+ void httpProxyConnectsToTheAddressItCheckedInsteadOfResolvingTheNameAgain() throws Exception {+ assertConnectsToTheAddressItCheckedInsteadOfResolvingTheNameAgain("HTTP_PROXY");+ }++ @Test+ void httpConnectsToTheAddressItCheckedInsteadOfResolvingTheNameAgain() throws Exception {+ assertConnectsToTheAddressItCheckedInsteadOfResolvingTheNameAgain("HTTP");+ }++ private void assertConnectsToTheAddressItCheckedInsteadOfResolvingTheNameAgain(String integrationType)+ throws Exception {+ receivedHost.set(null);+ AtomicInteger lookups = new AtomicInteger();+ WebSocketIntegrationInvoker pinnedInvoker = new WebSocketIntegrationInvoker(+ mock(LambdaService.class),+ mock(AwsServiceRouter.class),+ new ObjectMapper(),+ mock(VtlTemplateEngine.class),+ host -> {+ if (lookups.incrementAndGet() == 1) {+ return new InetAddress[] {InetAddress.getByName("127.0.0.1")};+ }+ return new InetAddress[] {InetAddress.getByName("169.254.169.254")};+ });+ String uri = "http://rebind.example.test:" + backend.getAddress().getPort() + "/";+ Integration integration = new Integration();+ integration.setIntegrationType(integrationType);+ integration.setIntegrationUri(uri);++ IntegrationResult result = pinnedInvoker.invoke("us-east-1", integration, "{}", Map.of(), Map.of(), Map.of());++ assertEquals(200, result.statusCode());+ assertEquals("ok", result.body());+ assertEquals(1, lookups.get(), "the name must be resolved once, then the checked address used");+ assertEquals("rebind.example.test:" + backend.getAddress().getPort(), receivedHost.get());+ }++ @Test+ void hostHeaderCarriesOnlyTheHostAndPortOfAnIntegrationUriWithCredentials() {+ receivedHost.set(null);+ int port = backend.getAddress().getPort();++ IntegrationResult result = invoke("HTTP_PROXY", "http://user:[email protected]:" + port + "/");++ assertEquals(200, result.statusCode());+ assertEquals("127.0.0.1:" + port, receivedHost.get());+ }++ @Test+ void responseOverTheTenMegabytePayloadQuotaIsRejected() throws Exception {+ try (ServerSocket server = serveOversizedContentLength()) {+ IntegrationResult result =+ invoke("HTTP_PROXY", "http://127.0.0.1:" + server.getLocalPort() + "/");++ assertEquals(500, result.statusCode());+ assertNotNull(result.functionError());+ assertTrue(result.functionError().contains("exceeds"), result.functionError());+ }+ }++ /** A backend announcing a body larger than the integration payload quota. */+ private static ServerSocket serveOversizedContentLength() throws IOException {+ ServerSocket server = new ServerSocket(0, 1, InetAddress.getLoopbackAddress());+ Thread.ofVirtual().start(() -> {+ try (Socket socket = server.accept()) {+ OutputStream out = socket.getOutputStream();+ out.write(("HTTP/1.1 200 OK\r\nContent-Length: " + (10 * 1024 * 1024 + 1) + "\r\n\r\n")+ .getBytes(StandardCharsets.ISO_8859_1));+ out.flush();+ } catch (IOException ignored) {+ // The client gives up as soon as it reads the oversized Content-Length.+ }+ });+ return server;+ }}