fix:"修复媒体下载DNS重绑定并隔离出站传输"

This commit is contained in:
xpp committed 2026-10-21 22:49:57 +08:00
1 parent 926aa64ba3
commit 32f6f67b9f
15 files changed
+791 -56

No files matched your search

+7
View File
@@ -17,6 +17,9 @@
<properties>
<java.version>21</java.version>
<!-- Keep the new DNS-bound media transport on the matching stable Client/Core pair. -->
<httpclient5.version>5.6.5</httpclient5.version>
<httpcore5.version>5.4.4</httpcore5.version>
</properties>
<dependencies>
@@ -53,6 +56,10 @@
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-crypto</artifactId>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents.client5</groupId>
<artifactId>httpclient5</artifactId>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
@@ -0,0 +1,59 @@
package com.moyi.controlplane.provider.media;
import com.moyi.controlplane.common.ApiException;
import com.moyi.controlplane.provider.transport.BoundedHttpTransport;
import com.moyi.controlplane.provider.transport.PinnedHttpsTransport;
import java.time.Duration;
import java.util.Locale;
/** Public reference-image input only. No provider credentials, routing, retries or billing. */
public final class MediaDownloader {
private static final int MAX_BYTES = 8 * 1024 * 1024;
private final PublicMediaAddressPolicy policy = new PublicMediaAddressPolicy();
private final PinnedHttpsTransport transport;
private final PinnedHttpsTransport.AddressResolver resolver;
public MediaDownloader() { this(new PinnedHttpsTransport(), new PublicMediaAddressPolicy()::resolve); }
MediaDownloader(PinnedHttpsTransport transport, PinnedHttpsTransport.AddressResolver resolver) {
this.transport = transport;
this.resolver = resolver;
}
public record MediaBytes(byte[] bytes, String contentType, String filename) {
@Override public String toString() { return "MediaBytes[type=" + contentType + ", bytes=" + bytes.length + "]"; }
}
public MediaBytes download(String value) {
java.net.URI uri;
try { uri = policy.requireUri(value); }
catch (IllegalArgumentException error) { throw invalidAddress(); }
BoundedHttpTransport.Response response;
try { response = transport.get(uri, resolver, Duration.ofSeconds(15), MAX_BYTES); }
catch (BoundedHttpTransport.Failure failure) {
if (failure.reason() == BoundedHttpTransport.Reason.INVALID_ADDRESS) throw invalidAddress();
if (failure.reason() == BoundedHttpTransport.Reason.BODY_TOO_LARGE) throw new ApiException("MEDIA_TOO_LARGE", "媒体输入超过 8 MiB", 400);
throw new ApiException("MEDIA_FETCH_FAILED", "无法在期限内读取媒体输入", 400);
}
if (response.statusCode() < 200 || response.statusCode() >= 300) {
throw new ApiException("MEDIA_FETCH_FAILED", "无法读取媒体输入(HTTP " + response.statusCode() + ")", 400);
}
if (response.body().length == 0) throw new ApiException("MEDIA_TOO_LARGE", "媒体输入为空或超过 8 MiB", 400);
String contentType = response.headers().firstValue("Content-Type").orElse("application/octet-stream")
.split(";", 2)[0].trim().toLowerCase(Locale.ROOT);
if (!contentType.matches("image/[a-z0-9.+-]{1,64}")) {
throw new ApiException("MEDIA_TYPE_UNSUPPORTED", "图像编辑和视频参考图必须是 image/* 文件", 400);
}
String extension = switch (contentType) {
case "image/jpeg" -> ".jpg";
case "image/png" -> ".png";
case "image/webp" -> ".webp";
case "image/gif" -> ".gif";
default -> ".bin";
};
return new MediaBytes(response.body(), contentType, "input" + extension);
}
private ApiException invalidAddress() {
return new ApiException("INVALID_MEDIA_URL", "媒体地址必须是公开 HTTPS 地址,不能指向本机、内网或特殊用途地址", 400);
}
}
@@ -0,0 +1,53 @@
package com.moyi.controlplane.provider.media;
import com.moyi.controlplane.provider.transport.PinnedHttpsTransport;
import java.io.IOException;
import java.net.InetAddress;
import java.net.URI;
/** Fail closed for non-global and special-purpose targets, including mixed DNS answer sets. */
final class PublicMediaAddressPolicy {
URI requireUri(String value) {
try {
URI uri = URI.create(value);
if (!"https".equalsIgnoreCase(uri.getScheme()) || uri.getHost() == null || uri.getHost().contains("%")
|| uri.getUserInfo() != null || uri.getRawFragment() != null || uri.getPort() == 0 || uri.getPort() > 65535) {
throw new IllegalArgumentException();
}
return uri;
} catch (RuntimeException error) { throw new IllegalArgumentException("Invalid public HTTPS media URL"); }
}
InetAddress[] resolve(String host) throws IOException {
return requirePublic(InetAddress.getAllByName(host));
}
InetAddress[] requirePublic(InetAddress[] addresses) throws PinnedHttpsTransport.AddressRejectedException {
if (addresses == null || addresses.length == 0 || addresses.length > 16) throw new PinnedHttpsTransport.AddressRejectedException();
for (var address : addresses) if (address == null || !isPublic(address)) throw new PinnedHttpsTransport.AddressRejectedException();
return addresses.clone();
}
boolean isPublic(InetAddress address) {
byte[] raw = address.getAddress();
int a = Byte.toUnsignedInt(raw[0]), b = Byte.toUnsignedInt(raw[1]);
if (raw.length == 4) {
int c = Byte.toUnsignedInt(raw[2]), d = Byte.toUnsignedInt(raw[3]);
return !(a == 0 || a == 10 || a == 127 || a >= 224
|| a == 100 && b >= 64 && b <= 127
|| a == 169 && b == 254 || a == 172 && b >= 16 && b <= 31
|| a == 192 && (b == 168 || b == 0 && (c == 0 || c == 2) || b == 88 && c == 99)
|| a == 198 && (b == 18 || b == 19 || b == 51 && c == 100)
|| a == 203 && b == 0 && c == 113
|| a == 168 && b == 63 && c == 129 && d == 16); // Azure platform virtual address
}
// Only native global unicast 2000::/3, excluding special/tunnel/documentation prefixes.
// This also rejects ULA, link/site local, multicast, compatible/mapped IPv4 and well-known NAT64.
if (raw.length != 16 || (a & 0xe0) != 0x20) return false;
int c = Byte.toUnsignedInt(raw[2]), d = Byte.toUnsignedInt(raw[3]);
return !(a == 0x20 && b == 0x01 && (c <= 1 || c == 0x0d && d == 0xb8)
|| a == 0x20 && b == 0x02 // 6to4 can encode a private IPv4 target
|| a == 0x3f && b == 0xfe // retired 6bone allocation
|| a == 0x3f && b == 0xff && (c & 0xf0) == 0); // 3fff::/20 documentation
}
}
@@ -27,11 +27,11 @@ public final class BoundedHttpTransport {
public record Response(int statusCode, HttpHeaders headers, byte[] body) {
@Override public String toString() { return "TransportResponse[status=" + statusCode + ", bytes=" + body.length + "]"; }
}
public enum Reason { TIMEOUT, INTERRUPTED, BODY_TOO_LARGE, IO }
public enum Reason { TIMEOUT, INTERRUPTED, BODY_TOO_LARGE, IO, INVALID_ADDRESS, BUSY }
public static final class Failure extends IOException {
private final Reason reason;
private final Integer observedStatus;
private Failure(Reason reason, Integer status) {
Failure(Reason reason, Integer status) {
super("Bounded HTTP attempt failed: " + reason);
this.reason = reason; this.observedStatus = status;
}
@@ -0,0 +1,187 @@
package com.moyi.controlplane.provider.transport;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Proxy;
import java.net.Socket;
import java.net.URI;
import java.net.UnknownHostException;
import java.net.http.HttpHeaders;
import java.time.Duration;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;
import javax.net.ssl.SSLContext;
import org.apache.hc.client5.http.DnsResolver;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.config.ConnectionConfig;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.config.TlsConfig;
import org.apache.hc.client5.http.impl.DefaultSchemePortResolver;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.BasicHttpClientConnectionManager;
import org.apache.hc.client5.http.impl.io.DefaultHttpClientConnectionOperator;
import org.apache.hc.client5.http.impl.io.ManagedHttpClientConnectionFactory;
import org.apache.hc.client5.http.impl.routing.DefaultRoutePlanner;
import org.apache.hc.client5.http.ssl.DefaultClientTlsStrategy;
import org.apache.hc.client5.http.ssl.DefaultHostnameVerifier;
import org.apache.hc.client5.http.ssl.HostnameVerificationPolicy;
import org.apache.hc.core5.http.config.Http1Config;
import org.apache.hc.core5.io.CloseMode;
import org.apache.hc.core5.ssl.SSLContexts;
import org.apache.hc.core5.util.Timeout;
import static com.moyi.controlplane.provider.transport.BoundedHttpTransport.Reason;
/**
* A credential-free HTTPS GET with per-attempt DNS binding. The caller supplies address policy;
* this module owns only bounded transport. Never rewrite the URI to an IP: TLS/SNI and Host use
* the original authority. No proxy, cookies, redirects, retry or connection reuse across attempts.
*/
public final class PinnedHttpsTransport {
private static final ExecutorService WORKERS = new ThreadPoolExecutor(0, 8, 60, TimeUnit.SECONDS,
new SynchronousQueue<>(), task -> {
var thread = new Thread(task, "moyi-media-fetch");
thread.setDaemon(true);
return thread;
}, new ThreadPoolExecutor.AbortPolicy());
private final SSLContext sslContext;
private final ExecutorService workers;
public PinnedHttpsTransport() { this(SSLContexts.createDefault(), WORKERS); }
PinnedHttpsTransport(SSLContext sslContext, ExecutorService workers) {
this.sslContext = sslContext;
this.workers = workers;
}
@FunctionalInterface
public interface AddressResolver { InetAddress[] resolve(String host) throws IOException; }
public static final class AddressRejectedException extends IOException {
public AddressRejectedException() { super("Target address rejected"); }
}
public BoundedHttpTransport.Response get(URI uri, AddressResolver resolver, Duration deadline, int maxBytes)
throws BoundedHttpTransport.Failure {
if (uri == null || !"https".equalsIgnoreCase(uri.getScheme()) || uri.getHost() == null
|| uri.getUserInfo() != null || uri.getRawFragment() != null || uri.getHost().contains("%")
|| uri.getPort() == 0 || uri.getPort() > 65535) throw new IllegalArgumentException("Invalid HTTPS target");
if (maxBytes < 1 || maxBytes > 32 * 1024 * 1024 || deadline == null || deadline.isNegative()
|| deadline.isZero() || deadline.compareTo(Duration.ofMinutes(1)) > 0) throw new IllegalArgumentException("Invalid transport limits");
var request = new HttpGet(uri);
var observed = new AtomicInteger();
Future<BoundedHttpTransport.Response> attempt;
try {
attempt = workers.submit(() -> execute(uri, resolver, request, deadline, maxBytes, observed));
} catch (RejectedExecutionException error) {
throw failure(Reason.BUSY, observed);
}
try {
return attempt.get(Math.max(1, deadline.toMillis()), TimeUnit.MILLISECONDS);
} catch (TimeoutException error) {
cancel(request, attempt);
throw failure(Reason.TIMEOUT, observed);
} catch (InterruptedException error) {
cancel(request, attempt);
Thread.currentThread().interrupt();
throw failure(Reason.INTERRUPTED, observed);
} catch (ExecutionException error) {
cancel(request, attempt);
if (error.getCause() instanceof BoundedHttpTransport.Failure safe) throw safe;
if (error.getCause() instanceof AddressRejectedException) throw failure(Reason.INVALID_ADDRESS, observed);
if (error.getCause() instanceof java.net.SocketTimeoutException) throw failure(Reason.TIMEOUT, observed);
// Do not attach causes: TLS/DNS/parser exceptions can contain signed URLs or response data.
throw failure(Reason.IO, observed);
}
}
private BoundedHttpTransport.Response execute(URI uri, AddressResolver resolver, HttpGet request,
Duration deadline, int maxBytes, AtomicInteger observed) throws IOException {
String host = unbracket(uri.getHost());
InetAddress[] addresses = resolver.resolve(host);
if (addresses == null || addresses.length == 0 || addresses.length > 16
|| java.util.Arrays.stream(addresses).anyMatch(java.util.Objects::isNull)) throw new AddressRejectedException();
// DNS lookup may ignore interruption. Once timed out, it must never resume with a late HTTP GET.
if (request.isCancelled() || Thread.currentThread().isInterrupted()) throw failure(Reason.INTERRUPTED, observed);
InetAddress[] pinned = addresses.clone();
var timeout = Timeout.ofMilliseconds(Math.max(1, deadline.toMillis()));
var boundDns = new DnsResolver() {
@Override public InetAddress[] resolve(String target) throws UnknownHostException {
if (!host.equalsIgnoreCase(unbracket(target))) throw new UnknownHostException("Unexpected target");
return pinned.clone();
}
@Override public String resolveCanonicalHostname(String target) throws UnknownHostException {
if (!host.equalsIgnoreCase(unbracket(target))) throw new UnknownHostException("Unexpected target");
return host;
}
};
var tls = new DefaultClientTlsStrategy(sslContext, HostnameVerificationPolicy.BOTH, new DefaultHostnameVerifier());
// A direct HTTP route alone is insufficient: new Socket() can still use the JVM's SOCKS selector.
var operator = new DefaultHttpClientConnectionOperator(ignored -> new Socket(Proxy.NO_PROXY),
DefaultSchemePortResolver.INSTANCE, boundDns, scheme -> "https".equalsIgnoreCase(scheme) ? tls : null);
var manager = new BasicHttpClientConnectionManager(operator, ManagedHttpClientConnectionFactory.builder()
.http1Config(Http1Config.custom().setMaxLineLength(8192).setMaxHeaderCount(64).build()).build());
manager.setConnectionConfig(ConnectionConfig.custom().setConnectTimeout(timeout).setSocketTimeout(timeout).build());
manager.setTlsConfig(TlsConfig.custom().setHandshakeTimeout(timeout).build());
request.setConfig(RequestConfig.custom().setResponseTimeout(timeout).setConnectionRequestTimeout(timeout)
.setHardCancellationEnabled(true).setAuthenticationEnabled(false).setRedirectsEnabled(false).build());
request.setHeader("Accept", "image/*");
request.setHeader("Accept-Encoding", "identity");
request.setHeader("Connection", "close");
try (var client = HttpClients.custom().setConnectionManager(manager)
.setRoutePlanner(new DefaultRoutePlanner(DefaultSchemePortResolver.INSTANCE))
.disableAutomaticRetries().disableRedirectHandling().disableCookieManagement()
.disableAuthCaching().disableContentCompression().disableDefaultUserAgent().build()) {
try {
var response = client.executeOpen(null, request, null);
try {
observed.set(response.getCode());
var entity = response.getEntity();
int limit = response.getCode() >= 200 && response.getCode() < 300 ? maxBytes : Math.min(maxBytes, 64 * 1024);
if (entity != null && entity.getContentLength() > limit) throw failure(Reason.BODY_TOO_LARGE, observed);
// Compressed images are already encoded; do not accept a decompression bomb or compressed MIME wrapper.
if (entity != null && entity.getContentEncoding() != null
&& !"identity".equalsIgnoreCase(entity.getContentEncoding())) throw failure(Reason.IO, observed);
var body = new ByteArrayOutputStream();
if (entity != null) {
var input = entity.getContent();
byte[] chunk = new byte[8192];
int count;
while ((count = input.read(chunk)) != -1) {
if (request.isCancelled() || Thread.currentThread().isInterrupted()) throw failure(Reason.INTERRUPTED, observed);
if (count > limit - body.size()) throw failure(Reason.BODY_TOO_LARGE, observed);
body.write(chunk, 0, count);
}
}
var headers = new LinkedHashMap<String, List<String>>();
for (var header : response.getHeaders()) headers.computeIfAbsent(header.getName(), ignored -> new ArrayList<>()).add(header.getValue());
return new BoundedHttpTransport.Response(response.getCode(), HttpHeaders.of(headers, (key, value) -> true), body.toByteArray());
} finally {
// Cancel BEFORE closing the entity: close/consume must not drain an oversized/never-ending body.
request.cancel();
try { response.close(); }
catch (IOException expectedAfterCancellation) { /* Never replace the primary outcome with a closed-socket cleanup error. */ }
}
} finally {
request.cancel();
client.close(CloseMode.IMMEDIATE);
}
}
}
private static String unbracket(String host) {
return host.startsWith("[") && host.endsWith("]") ? host.substring(1, host.length() - 1) : host;
}
private static void cancel(HttpGet request, Future<?> attempt) { request.cancel(); attempt.cancel(true); }
private static BoundedHttpTransport.Failure failure(Reason reason, AtomicInteger observed) {
return new BoundedHttpTransport.Failure(reason, observed.get() == 0 ? null : observed.get());
}
}
@@ -8,8 +8,9 @@ import com.moyi.controlplane.security.SecretCipher;
import com.moyi.controlplane.provider.credentials.UpstreamCredentialResolver;
import com.moyi.controlplane.provider.transport.ProviderRequestException;
import com.moyi.controlplane.provider.transport.BoundedHttpTransport;
import com.moyi.controlplane.provider.media.MediaDownloader;
import com.moyi.controlplane.provider.media.MediaDownloader.MediaBytes;
import java.net.URI;
import java.net.InetAddress;
import java.net.http.HttpRequest;
import java.time.Duration;
import java.io.ByteArrayOutputStream;
@@ -42,6 +43,7 @@ public class AsyncProviderClient {
* every request otherwise selected the first upstream key forever. */
private final ConcurrentMap<String, AtomicInteger> keyCursors = new ConcurrentHashMap<>();
private final BoundedHttpTransport transport = new BoundedHttpTransport();
private final MediaDownloader mediaDownloader = new MediaDownloader();
public AsyncProviderClient(JdbcTemplate jdbc, SecretCipher cipher, ObjectMapper mapper, Environment environment) {
this.jdbc = jdbc; this.cipher = cipher; this.mapper = mapper; this.environment = environment;
@@ -221,7 +223,7 @@ public class AsyncProviderClient {
String media=mediaUrl(input);
if(media!=null) {
try {
MediaBytes file=downloadMedia(media);
MediaBytes file=mediaDownloader.download(media);
parts.add(Map.of("inlineData",Map.of("mimeType",file.contentType(),"data",Base64.getEncoder().encodeToString(file.bytes()))));
} catch(ApiException e) { throw e; }
catch(Exception e) { throw new ApiException("MEDIA_FETCH_FAILED","无法读取参考图",400); }
@@ -351,7 +353,7 @@ public class AsyncProviderClient {
multipartField(out, boundary, entry.getKey(), String.valueOf(entry.getValue()));
}
if (fileField != null && media != null) {
MediaBytes file = downloadMedia(media);
MediaBytes file = mediaDownloader.download(media);
multipartFile(out, boundary, fileField, file.filename(), file.contentType(), file.bytes());
}
out.write(("--" + boundary + "--\r\n").getBytes(java.nio.charset.StandardCharsets.UTF_8));
@@ -400,52 +402,6 @@ public class AsyncProviderClient {
out.write("\r\n".getBytes(java.nio.charset.StandardCharsets.UTF_8));
}
private MediaBytes downloadMedia(String value) throws IOException, InterruptedException {
URI uri = URI.create(value);
if (!"https".equalsIgnoreCase(uri.getScheme()) || uri.getHost() == null || uri.getUserInfo() != null) {
throw new ApiException("INVALID_MEDIA_URL", "媒体地址必须是可公开访问的 HTTPS URL", 400);
}
for (InetAddress address : InetAddress.getAllByName(uri.getHost())) {
if (address.isAnyLocalAddress() || address.isLoopbackAddress() || address.isLinkLocalAddress()
|| address.isSiteLocalAddress() || address.isMulticastAddress()) {
throw new ApiException("INVALID_MEDIA_URL", "媒体地址不能指向内网或本机地址", 400);
}
}
HttpRequest request = HttpRequest.newBuilder(uri).timeout(Duration.ofSeconds(15)).GET().build();
BoundedHttpTransport.Response response;
try { response = transport.send(request, 8 * 1024 * 1024); }
catch (BoundedHttpTransport.Failure failure) {
if (failure.reason() == BoundedHttpTransport.Reason.BODY_TOO_LARGE) throw new ApiException("MEDIA_TOO_LARGE", "媒体输入超过 8 MiB", 400);
throw new ApiException("MEDIA_FETCH_FAILED", "无法在期限内读取媒体输入", 400);
}
if (response.statusCode() < 200 || response.statusCode() >= 300) {
throw new ApiException("MEDIA_FETCH_FAILED", "无法读取媒体输入(HTTP " + response.statusCode() + ")", 400);
}
byte[] bytes = response.body();
if (bytes.length == 0 || bytes.length > 8 * 1024 * 1024) {
throw new ApiException("MEDIA_TOO_LARGE", "媒体输入为空或超过 8 MiB", 400);
}
String contentType = response.headers().firstValue("Content-Type").orElse("application/octet-stream")
.split(";", 2)[0].trim().toLowerCase(java.util.Locale.ROOT);
if (!contentType.startsWith("image/")) {
throw new ApiException("MEDIA_TYPE_UNSUPPORTED", "图像编辑和视频参考图必须是 image/* 文件", 400);
}
String filename = "input" + extension(contentType);
return new MediaBytes(bytes, contentType, filename);
}
private String extension(String contentType) {
return switch (contentType) {
case "image/jpeg" -> ".jpg";
case "image/png" -> ".png";
case "image/webp" -> ".webp";
case "image/gif" -> ".gif";
default -> ".bin";
};
}
private record MediaBytes(byte[] bytes, String contentType, String filename) {}
private Map<String,Object> request(String method, String url, String key, Map<String,Object> body, String message) {
boolean sending = false;
try {
@@ -20,6 +20,11 @@ class ModuleDependencyTest {
assertTrue(Files.exists(root.resolve("task/TaskSettlementService.java")));
disallow(root.resolve("task/TaskSettlementService.java"), List.of("java.net.http", "AsyncProviderClient", "OpenAiCompatibleProvider"));
}
@Test void mediaInputDoesNotOwnCredentialsRoutingOrBilling() throws Exception {
disallow(root.resolve("provider/media"), List.of(".gateway.", ".wallet.", ".auth.", ".task.",
".provider.credentials", "org.springframework.jdbc", ".security.SecretCipher", "java.net.http.HttpClient"));
assertFalse(Files.readString(root.resolve("task/AsyncProviderClient.java")).contains("InetAddress"), "DNS policy belongs to the media boundary");
}
private void disallow(Path path, List<String> forbidden) throws Exception {
assertTrue(Files.exists(path), "Expected source boundary: " + path);
try (var paths = Files.isDirectory(path) ? Files.walk(path) : java.util.stream.Stream.of(path)) {
@@ -0,0 +1,58 @@
package com.moyi.controlplane.provider.media;
import com.moyi.controlplane.common.ApiException;
import com.moyi.controlplane.provider.transport.BoundedHttpTransport;
import com.moyi.controlplane.provider.transport.PinnedHttpsTransport;
import java.net.URI;
import java.net.http.HttpHeaders;
import java.time.Duration;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
class MediaDownloaderTest {
private final PinnedHttpsTransport transport = mock(PinnedHttpsTransport.class);
private final MediaDownloader downloader = new MediaDownloader(transport, host -> { throw new AssertionError("Unexpected network"); });
@Test void normalizesImagesAndPreservesBoundedTransportContract() throws Exception {
byte[] bytes = {1, 2, 3};
when(transport.get(any(), any(), any(), anyInt())).thenReturn(response(200, "IMAGE/PNG; charset=utf-8", bytes));
var image = downloader.download("https://media.test/a?signature=synthetic");
assertArrayEquals(bytes, image.bytes()); assertEquals("image/png", image.contentType()); assertEquals("input.png", image.filename());
verify(transport).get(eq(URI.create("https://media.test/a?signature=synthetic")), any(), eq(Duration.ofSeconds(15)), eq(8 * 1024 * 1024));
assertFalse(image.toString().contains("synthetic"));
}
@Test void invalidUrlsFailBeforeTransport() {
assertEquals("INVALID_MEDIA_URL", assertThrows(ApiException.class, () -> downloader.download("https://user:secret@media.test/a")).getCode());
verifyNoInteractions(transport);
}
@ParameterizedTest @CsvSource({"BODY_TOO_LARGE,MEDIA_TOO_LARGE", "INVALID_ADDRESS,INVALID_MEDIA_URL", "TIMEOUT,MEDIA_FETCH_FAILED", "INTERRUPTED,MEDIA_FETCH_FAILED", "BUSY,MEDIA_FETCH_FAILED", "IO,MEDIA_FETCH_FAILED"})
void transportFailuresExposeOnlySafeDomainCodes(BoundedHttpTransport.Reason reason, String code) throws Exception {
var failure = mock(BoundedHttpTransport.Failure.class); when(failure.reason()).thenReturn(reason);
when(transport.get(any(), any(), any(), anyInt())).thenThrow(failure);
var error = assertThrows(ApiException.class, () -> downloader.download("https://media.test/a?signature=private"));
assertEquals(code, error.getCode()); assertFalse(error.getMessage().contains("private")); assertNull(error.getCause());
}
@ParameterizedTest @CsvSource({"302,image/png,MEDIA_FETCH_FAILED", "404,image/png,MEDIA_FETCH_FAILED", "200,text/html,MEDIA_TYPE_UNSUPPORTED", "200,image/invalid:type,MEDIA_TYPE_UNSUPPORTED"})
void redirectsErrorsAndUnsupportedTypesAreRejected(int status, String type, String code) throws Exception {
when(transport.get(any(), any(), any(), anyInt())).thenReturn(response(status, type, new byte[] {1}));
assertEquals(code, assertThrows(ApiException.class, () -> downloader.download("https://media.test/a")).getCode());
}
@Test void emptyBodyIsRejected() throws Exception {
when(transport.get(any(), any(), any(), anyInt())).thenReturn(response(200, "image/png", new byte[0]));
assertEquals("MEDIA_TOO_LARGE", assertThrows(ApiException.class, () -> downloader.download("https://media.test/a")).getCode());
}
private BoundedHttpTransport.Response response(int status, String type, byte[] body) {
return new BoundedHttpTransport.Response(status, HttpHeaders.of(Map.of("Content-Type", List.of(type)), (key, value) -> true), body);
}
}
@@ -0,0 +1,65 @@
package com.moyi.controlplane.provider.media;
import com.moyi.controlplane.provider.transport.PinnedHttpsTransport;
import java.net.InetAddress;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import static org.junit.jupiter.api.Assertions.*;
class PublicMediaAddressPolicyTest {
private final PublicMediaAddressPolicy policy = new PublicMediaAddressPolicy();
@ParameterizedTest
@ValueSource(strings = {
"0.0.0.0", "0.255.255.255", "10.0.0.1", "127.0.0.1", "127.255.255.254",
"100.64.0.1", "100.127.255.254", "169.254.169.254", "172.16.0.1", "172.31.255.254",
"192.0.0.1", "192.0.0.9", "192.0.2.1", "192.88.99.1", "192.168.1.1",
"198.18.0.1", "198.19.255.254", "198.51.100.1", "203.0.113.1", "224.0.0.1",
"239.255.255.255", "240.0.0.1", "255.255.255.255", "168.63.129.16",
"::", "::1", "::127.0.0.1", "::ffff:127.0.0.1", "::ffff:169.254.169.254",
"fc00::1", "fd00::1", "fe80::1", "fec0::1", "ff02::1", "64:ff9b::a00:1", "64:ff9b:1::1",
"100::1", "2001::1", "2001:1ff:ffff::1", "2001:2::1", "2001:20::1", "2001:db8::1",
"2002:7f00:1::1", "2002:0808:0808::1", "3ffe::1", "3fff::1", "3fff:fff:ffff::1", "4000::1"
})
void rejectsNonGlobalSpecialAndTranslationTargets(String literal) throws Exception {
InetAddress address = InetAddress.getByName(literal);
assertFalse(policy.isPublic(address), literal);
assertThrows(PinnedHttpsTransport.AddressRejectedException.class, () -> policy.requirePublic(new InetAddress[] {address}));
}
@ParameterizedTest
@ValueSource(strings = {"1.1.1.1", "8.8.8.8", "100.63.255.254", "100.128.0.1", "172.15.255.254", "172.32.0.1",
"192.0.1.1", "198.17.255.254", "198.20.0.1", "223.255.255.254", "2606:4700:4700::1111", "2001:4860:4860::8888", "3fff:1000::1"})
void permitsOrdinaryGlobalAddressesWithoutMakingInternetRequests(String literal) throws Exception {
var address = InetAddress.getByName(literal);
assertTrue(policy.isPublic(address), literal);
assertArrayEquals(new InetAddress[] {address}, policy.requirePublic(new InetAddress[] {address}));
}
@Test void rejectsTheWholeMixedAnswerSetInEitherOrder() throws Exception {
var external = InetAddress.getByName("8.8.8.8");
var internal = InetAddress.getByName("fd00::1");
assertThrows(PinnedHttpsTransport.AddressRejectedException.class, () -> policy.requirePublic(new InetAddress[] {external, internal}));
assertThrows(PinnedHttpsTransport.AddressRejectedException.class, () -> policy.requirePublic(new InetAddress[] {internal, external}));
assertThrows(PinnedHttpsTransport.AddressRejectedException.class, () -> policy.requirePublic(new InetAddress[0]));
assertThrows(PinnedHttpsTransport.AddressRejectedException.class, () -> policy.requirePublic(new InetAddress[] {null}));
assertThrows(PinnedHttpsTransport.AddressRejectedException.class, () -> policy.requirePublic(new InetAddress[17]));
}
@ParameterizedTest
@ValueSource(strings = {"http://example.test/a", "file:///etc/passwd", "data:image/png,a", "//example.test/a",
"https://user:secret@example.test/a", "https://example.test/a#fragment", "https://example.test:0/a", "https://example.test:65536/a",
"https://[fe80::1%25eth0]/a", "https://example.test\\@127.0.0.1/a", "https://example.test/%0d%0a/x\r\n", "https:///a", ""})
void rejectsAmbiguousOrNonHttpsUris(String value) {
var failure = assertThrows(IllegalArgumentException.class, () -> policy.requireUri(value));
assertFalse(failure.getMessage().contains("secret"));
assertNull(failure.getCause());
}
@Test void permitsSignedHttpsUrlsAndExplicitHttpsPortsWithoutRewritingAuthority() {
String value = "https://media.example.test:8443/a.png?signature=synthetic";
assertEquals(value, policy.requireUri(value).toString());
assertEquals("[2606:4700:4700::1111]", policy.requireUri("https://[2606:4700:4700::1111]/a").getHost());
}
}
@@ -0,0 +1,279 @@
package com.moyi.controlplane.provider.transport;
import com.sun.net.httpserver.HttpsConfigurator;
import com.sun.net.httpserver.HttpsServer;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.KeyStore;
import java.time.Duration;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import javax.net.ssl.ExtendedSSLSession;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SNIHostName;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import static org.junit.jupiter.api.Assertions.*;
class PinnedHttpsTransportTest {
@TempDir static Path temporary;
private static SSLContext serverTls, trustedTls;
private HttpsServer server;
private ExecutorService workers;
private PinnedHttpsTransport transport;
private final CountDownLatch release = new CountDownLatch(1);
@BeforeAll static void createEphemeralTestCertificate() throws Exception {
// No committed key, no trust-all TLS: mint a .test certificate and trust only this test key.
String password = java.util.UUID.randomUUID().toString();
Path store = temporary.resolve("media-test.p12");
var process = new ProcessBuilder(Path.of(System.getProperty("java.home"), "bin", "keytool").toString(),
"-genkeypair", "-alias", "test", "-keyalg", "RSA", "-keysize", "2048", "-validity", "2",
"-dname", "CN=media.test", "-ext", "SAN=dns:media.test", "-storetype", "PKCS12",
"-keystore", store.toString(), "-storepass", password, "-keypass", password, "-noprompt")
.redirectErrorStream(true).start();
assertTrue(process.waitFor(15, TimeUnit.SECONDS));
assertEquals(0, process.exitValue(), () -> "Unable to create ephemeral TLS fixture");
var keys = KeyStore.getInstance("PKCS12");
try (var input = Files.newInputStream(store)) { keys.load(input, password.toCharArray()); }
var kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
kmf.init(keys, password.toCharArray());
serverTls = SSLContext.getInstance("TLS");
serverTls.init(kmf.getKeyManagers(), null, null);
var trust = KeyStore.getInstance(KeyStore.getDefaultType()); trust.load(null, null);
trust.setCertificateEntry("test", keys.getCertificate("test"));
var tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); tmf.init(trust);
trustedTls = SSLContext.getInstance("TLS"); trustedTls.init(null, tmf.getTrustManagers(), null);
}
@BeforeEach void setup() throws Exception {
server = HttpsServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
server.setHttpsConfigurator(new HttpsConfigurator(serverTls));
workers = new ThreadPoolExecutor(0, 2, 5, TimeUnit.SECONDS, new SynchronousQueue<>(),
runnable -> { var thread = new Thread(runnable, "test-pinned-get"); thread.setDaemon(true); return thread; });
transport = new PinnedHttpsTransport(trustedTls, workers);
}
@AfterEach void cleanup() throws Exception {
release.countDown(); workers.shutdownNow(); server.stop(0);
assertTrue(workers.awaitTermination(3, TimeUnit.SECONDS));
}
private URI uri(String path) { return URI.create("https://media.test:" + server.getAddress().getPort() + path); }
private InetAddress[] loopback(String host) throws java.io.IOException { return new InetAddress[] {InetAddress.getByName("127.0.0.1")}; }
private BoundedHttpTransport.Response get(String path, long timeoutMs, int maxBytes) throws Exception {
return transport.get(uri(path), this::loopback, Duration.ofMillis(timeoutMs), maxBytes);
}
@Test void bindsDnsOnceWhilePreservingHostSniAndCredentialIsolation() throws Exception {
var lookups = new AtomicInteger(); var host = new AtomicReference<String>(); var sni = new AtomicReference<String>();
server.createContext("/", exchange -> {
host.set(exchange.getRequestHeaders().getFirst("Host"));
var session = (ExtendedSSLSession) ((com.sun.net.httpserver.HttpsExchange) exchange).getSSLSession();
sni.set(((SNIHostName) session.getRequestedServerNames().getFirst()).getAsciiName());
assertNull(exchange.getRequestHeaders().getFirst("Authorization"));
assertNull(exchange.getRequestHeaders().getFirst("Cookie"));
assertNull(exchange.getRequestHeaders().getFirst("Proxy-Authorization"));
assertEquals("identity", exchange.getRequestHeaders().getFirst("Accept-Encoding"));
exchange.getResponseHeaders().set("Content-Type", "image/png");
byte[] bytes = "synthetic-image".getBytes(StandardCharsets.UTF_8); exchange.sendResponseHeaders(200, bytes.length);
try (var output = exchange.getResponseBody()) { output.write(bytes); }
}); server.start();
var response = transport.get(uri("/?signature=synthetic-private-query"), target -> {
assertEquals("media.test", target);
if (lookups.incrementAndGet() != 1) throw new AssertionError("DNS was resolved twice");
return loopback(target);
}, Duration.ofSeconds(3), 1024);
assertEquals(200, response.statusCode()); assertEquals(1, lookups.get());
assertEquals("media.test:" + server.getAddress().getPort(), host.get()); assertEquals("media.test", sni.get());
assertEquals("synthetic-image", new String(response.body(), StandardCharsets.UTF_8));
assertFalse(response.toString().contains("synthetic"));
}
@Test void aTrustedCertificateForAnotherHostnameStillFails() throws Exception {
var calls = new AtomicInteger();
server.createContext("/", exchange -> { calls.incrementAndGet(); exchange.sendResponseHeaders(200, -1); exchange.close(); }); server.start();
URI wrong = URI.create("https://wrong.test:" + server.getAddress().getPort() + "/?signature=private");
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> transport.get(wrong, this::loopback, Duration.ofSeconds(3), 1024));
assertEquals(BoundedHttpTransport.Reason.IO, failure.reason()); assertEquals(0, calls.get());
assertNull(failure.getCause()); assertFalse(failure.toString().contains("private"));
}
@Test void theDefaultTrustStoreDoesNotAcceptOurSelfSignedTestCertificate() throws Exception {
server.createContext("/", exchange -> { exchange.sendResponseHeaders(200, -1); exchange.close(); }); server.start();
var strict = new PinnedHttpsTransport(org.apache.hc.core5.ssl.SSLContexts.createDefault(), workers);
assertEquals(BoundedHttpTransport.Reason.IO, assertThrows(BoundedHttpTransport.Failure.class,
() -> strict.get(uri("/"), this::loopback, Duration.ofSeconds(3), 1024)).reason());
}
@Test void redirectsAreNeverFollowed() throws Exception {
var calls = new AtomicInteger();
server.createContext("/", exchange -> {
calls.incrementAndGet(); exchange.getResponseHeaders().set("Location", "https://127.0.0.1/private");
exchange.sendResponseHeaders(302, -1); exchange.close();
}); server.start();
assertEquals(302, get("/", 3000, 1024).statusCode()); assertEquals(1, calls.get());
}
@Test void declaredOversizeDoesNotWaitForTheBodyOrDrainItOnClose() {
server.createContext("/", exchange -> {
exchange.sendResponseHeaders(200, 1_000_000);
try { release.await(3, TimeUnit.SECONDS); } catch (InterruptedException error) { Thread.currentThread().interrupt(); }
exchange.close();
}); server.start();
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 2000, 8192));
assertEquals(BoundedHttpTransport.Reason.BODY_TOO_LARGE, failure.reason()); assertEquals(200, failure.observedStatus());
}
@Test void chunkedOversizeIsStoppedDuringRead() {
server.createContext("/", exchange -> {
exchange.sendResponseHeaders(200, 0);
try (var output = exchange.getResponseBody()) { for (int i = 0; i < 100; i++) output.write(new byte[4096]); }
catch (java.io.IOException expectedAfterCancellation) { }
}); server.start();
assertEquals(BoundedHttpTransport.Reason.BODY_TOO_LARGE, assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 3000, 8192)).reason());
}
@Test void deadlineIncludesSlowResponseBodyAndRestoresWorkerCapacity() throws Exception {
var arrived = new CountDownLatch(1);
server.createContext("/", exchange -> {
exchange.sendResponseHeaders(200, 0);
try (var output = exchange.getResponseBody()) {
output.write('x'); output.flush(); arrived.countDown();
try { release.await(5, TimeUnit.SECONDS); } catch (InterruptedException error) { Thread.currentThread().interrupt(); }
} catch (java.io.IOException expectedAfterCancellation) { }
}); server.start();
long start = System.nanoTime();
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 1000, 8192));
assertEquals(BoundedHttpTransport.Reason.TIMEOUT, failure.reason()); assertEquals(200, failure.observedStatus());
assertEquals(0, arrived.getCount()); assertTrue(TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start) < 2500);
workers.shutdown(); assertTrue(workers.awaitTermination(2, TimeUnit.SECONDS));
}
@Test void lateDnsResolutionCannotStartHttpAfterTheDeadline() throws Exception {
var resolving = new CountDownLatch(1); var finished = new CountDownLatch(1); var calls = new AtomicInteger();
server.createContext("/", exchange -> { calls.incrementAndGet(); exchange.sendResponseHeaders(200, -1); exchange.close(); }); server.start();
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> transport.get(uri("/"), host -> {
resolving.countDown();
boolean interrupted = false;
while (release.getCount() != 0) try { release.await(1, TimeUnit.SECONDS); }
catch (InterruptedException ignoredForSimulatedNativeResolver) { interrupted = true; }
if (interrupted) Thread.currentThread().interrupt();
finished.countDown(); return loopback(host);
}, Duration.ofMillis(200), 1024));
assertEquals(BoundedHttpTransport.Reason.TIMEOUT, failure.reason()); assertEquals(0, resolving.getCount());
release.countDown(); assertTrue(finished.await(2, TimeUnit.SECONDS));
workers.shutdown(); assertTrue(workers.awaitTermination(2, TimeUnit.SECONDS)); assertEquals(0, calls.get());
}
@Test void interruptionCancelsSocketAndRestoresCallerInterruptFlag() throws Exception {
var arrived = new CountDownLatch(1); var observed = new AtomicReference<BoundedHttpTransport.Reason>(); var flag = new AtomicReference<Boolean>();
server.createContext("/", exchange -> {
exchange.sendResponseHeaders(200, 0);
try (var output = exchange.getResponseBody()) {
output.write('x'); output.flush(); arrived.countDown();
try { release.await(5, TimeUnit.SECONDS); } catch (InterruptedException error) { Thread.currentThread().interrupt(); }
} catch (java.io.IOException expectedAfterCancellation) { }
}); server.start();
var caller = new Thread(() -> {
try { get("/", 5000, 1024); }
catch (BoundedHttpTransport.Failure failure) { observed.set(failure.reason()); flag.set(Thread.currentThread().isInterrupted()); }
catch (Exception unexpected) { throw new AssertionError(unexpected); }
}); caller.setDaemon(true); caller.start();
try {
assertTrue(arrived.await(3, TimeUnit.SECONDS)); caller.interrupt(); caller.join(2000);
assertFalse(caller.isAlive()); assertEquals(BoundedHttpTransport.Reason.INTERRUPTED, observed.get()); assertEquals(true, flag.get());
} finally { release.countDown(); caller.interrupt(); }
}
@Test void refusedOrDroppedRequestsAreNotAutomaticallyRetried() {
var calls = new AtomicInteger();
server.createContext("/", exchange -> { calls.incrementAndGet(); exchange.close(); }); server.start();
assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 3000, 1024)); assertEquals(1, calls.get());
}
@Test void compressedBodiesAreNotDecompressedOrTreatedAsImages() {
server.createContext("/", exchange -> {
exchange.getResponseHeaders().set("Content-Encoding", "gzip"); exchange.sendResponseHeaders(200, 0);
try (var output = exchange.getResponseBody()) { output.write(new byte[16]); }
catch (java.io.IOException expectedAfterCancellation) { }
}); server.start();
assertEquals(BoundedHttpTransport.Reason.IO, assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 3000, 1024)).reason());
}
@Test void busyPoolRejectsImmediatelyRatherThanQueueingUnlimitedDnsRequests() throws Exception {
var occupied = new CountDownLatch(1);
var oneWorker = new ThreadPoolExecutor(0, 1, 5, TimeUnit.SECONDS, new SynchronousQueue<>());
try {
oneWorker.submit(() -> {
occupied.countDown();
try { release.await(5, TimeUnit.SECONDS); } catch (InterruptedException error) { Thread.currentThread().interrupt(); }
});
assertTrue(occupied.await(2, TimeUnit.SECONDS));
var rejected = new PinnedHttpsTransport(trustedTls, oneWorker);
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> rejected.get(uri("/"), this::loopback, Duration.ofSeconds(3), 1024));
assertEquals(BoundedHttpTransport.Reason.BUSY, failure.reason()); assertNull(failure.observedStatus());
assertEquals(0, oneWorker.getQueue().size());
} finally { release.countDown(); oneWorker.shutdownNow(); assertTrue(oneWorker.awaitTermination(2, TimeUnit.SECONDS)); }
}
@Test void defaultSystemProxySelectorCannotBypassDnsBinding() throws Exception {
var original = java.net.ProxySelector.getDefault();
var selections = new AtomicInteger();
server.createContext("/", exchange -> { exchange.sendResponseHeaders(200, 1); exchange.getResponseBody().write('x'); exchange.close(); }); server.start();
try {
java.net.ProxySelector.setDefault(new java.net.ProxySelector() {
@Override public java.util.List<java.net.Proxy> select(URI target) {
selections.incrementAndGet();
return java.util.List.of(new java.net.Proxy(java.net.Proxy.Type.SOCKS, new InetSocketAddress("127.0.0.1", 1)));
}
@Override public void connectFailed(URI target, java.net.SocketAddress address, java.io.IOException failure) { }
});
assertEquals(200, get("/", 3000, 1024).statusCode()); assertEquals(0, selections.get());
} finally { java.net.ProxySelector.setDefault(original); }
}
@Test void independentAttemptsRevalidateDnsAndNeverReuseCookiesOrThePreviousConnection() throws Exception {
var calls = new AtomicInteger(); var lookups = new AtomicInteger();
server.createContext("/", exchange -> {
calls.incrementAndGet(); assertNull(exchange.getRequestHeaders().getFirst("Cookie"));
exchange.getResponseHeaders().set("Set-Cookie", "synthetic=value; Secure");
exchange.sendResponseHeaders(200, 1); exchange.getResponseBody().write('x'); exchange.close();
}); server.start();
PinnedHttpsTransport.AddressResolver resolver = host -> {
if (lookups.incrementAndGet() == 3) throw new PinnedHttpsTransport.AddressRejectedException();
return loopback(host);
};
assertEquals(200, transport.get(uri("/"), resolver, Duration.ofSeconds(3), 1024).statusCode());
assertEquals(200, transport.get(uri("/"), resolver, Duration.ofSeconds(3), 1024).statusCode());
assertEquals(BoundedHttpTransport.Reason.INVALID_ADDRESS, assertThrows(BoundedHttpTransport.Failure.class,
() -> transport.get(uri("/"), resolver, Duration.ofSeconds(3), 1024)).reason());
assertEquals(3, lookups.get()); assertEquals(2, calls.get());
}
@Test void errorBodyLimitRetainsStatusAndIsSmallerThanTheImageLimit() {
server.createContext("/", exchange -> { exchange.sendResponseHeaders(401, 1_000_000); exchange.close(); }); server.start();
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 3000, 8 * 1024 * 1024));
assertEquals(BoundedHttpTransport.Reason.BODY_TOO_LARGE, failure.reason()); assertEquals(401, failure.observedStatus());
}
@Test void oversizedResponseHeadersAreNotBufferedWithoutLimits() {
server.createContext("/", exchange -> {
exchange.getResponseHeaders().set("X-Large", "x".repeat(16 * 1024));
exchange.sendResponseHeaders(200, 1); exchange.getResponseBody().write('x'); exchange.close();
}); server.start();
assertEquals(BoundedHttpTransport.Reason.IO, assertThrows(BoundedHttpTransport.Failure.class, () -> get("/", 3000, 1024)).reason());
}
}
@@ -322,6 +322,24 @@ class AsyncProviderClientTest {
assertEquals("INVALID_MEDIA_URL", failure.getCode());
}
@ParameterizedTest
@CsvSource({"image,gpt-image-2", "video,sora-2", "image,gemini-3-pro-image-preview"})
void localReferenceImageIsRejectedBeforeAnyGenerationPost(String type, String model) throws Exception {
var calls = new java.util.concurrent.atomic.AtomicInteger();
HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
server.createContext("/", exchange -> { calls.incrementAndGet(); exchange.sendResponseHeaders(500, -1); exchange.close(); }); server.start();
try {
var jdbc = mock(JdbcTemplate.class); var cipher = new SecretCipher("test-encryption");
when(jdbc.queryForMap(any(String.class), eq("relay"))).thenReturn(Map.of("code", "relay", "protocol", "openai-compatible",
"base_url", "http://127.0.0.1:" + server.getAddress().getPort(), "credential_ciphertext", cipher.encrypt("test-key")));
var client = new AsyncProviderClient(jdbc, cipher, new ObjectMapper(), mock(Environment.class));
var failure = assertThrows(ProviderRequestException.class, () -> client.submit("relay", model, type,
Map.of("prompt", "synthetic", "media_url", "https://127.0.0.1/private")));
assertEquals(ProviderRequestException.Acceptance.NOT_SENT, failure.acceptance()); assertEquals("INVALID_MEDIA_URL", failure.getCode());
assertEquals(0, calls.get());
} finally { server.stop(0); }
}
private AsyncProviderClient clientFor(String baseUrl) {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
SecretCipher cipher = new SecretCipher("test-encryption");