feat: bound async HTTP attempts and track remaining security work

This commit is contained in:
xpp committed 2026-10-21 22:07:56 +08:00
1 parent d994ffb9a5
commit 926aa64ba3
13 files changed
+479 -8

No files matched your search

@@ -0,0 +1,32 @@
package com.moyi.controlplane.gateway.request;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
/** Lightweight source dependency gates, not a substitute for design review or a sandbox. */
class ModuleDependencyTest {
private final Path root = Path.of(System.getProperty("basedir", "."), "src/main/java/com/moyi/controlplane");
@Test void requestApplicationBoundaryDoesNotOwnHttpDatabaseOrProviderCredentials() throws Exception {
disallow(root.resolve("gateway/request"), List.of("java.net.http", "org.springframework.jdbc", ".security.SecretCipher", ".provider.credentials", ".task.AsyncProviderClient"));
}
@Test void transportDoesNotOwnRiskRoutingOrTheWallet() throws Exception {
disallow(root.resolve("provider/transport"), List.of(".gateway.", ".wallet.", ".auth.", ".task.", "org.springframework.jdbc", ".security.SecretCipher"));
}
@Test void taskSettlementDoesNotCallAnUpstream() throws Exception {
assertTrue(Files.exists(root.resolve("task/TaskSettlementService.java")));
disallow(root.resolve("task/TaskSettlementService.java"), List.of("java.net.http", "AsyncProviderClient", "OpenAiCompatibleProvider"));
}
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)) {
for (Path file : paths.filter(p -> p.toString().endsWith(".java")).toList()) {
String source = Files.readString(file);
for (String dependency : forbidden) assertFalse(source.contains(dependency), file + " crosses boundary via " + dependency);
}
}
}
}
@@ -0,0 +1,113 @@
package com.moyi.controlplane.provider.transport;
import com.sun.net.httpserver.HttpServer;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.http.HttpRequest;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class BoundedHttpTransportTest {
private HttpServer server;
private final BoundedHttpTransport transport = new BoundedHttpTransport();
private final CountDownLatch release = new CountDownLatch(1);
@BeforeEach void setup() throws Exception { server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0); }
@AfterEach void cleanup() { release.countDown(); server.stop(0); }
private HttpRequest request(String path, long timeoutMs) { return HttpRequest.newBuilder(URI.create("http://127.0.0.1:" + server.getAddress().getPort() + path)).timeout(Duration.ofMillis(timeoutMs)).GET().build(); }
@Test void returnsBoundedBytesWithoutExposingBodyInDiagnostics() throws Exception {
server.createContext("/", exchange -> {
byte[] bytes = "private-provider-result".getBytes(StandardCharsets.UTF_8);
exchange.sendResponseHeaders(200, bytes.length);
try (var output = exchange.getResponseBody()) { output.write(bytes); }
}); server.start();
var response = transport.send(request("/", 2000), 1024);
assertEquals("private-provider-result", new String(response.body(), StandardCharsets.UTF_8));
assertFalse(response.toString().contains("private-provider-result"));
}
@Test void oversizedChunkedResponseIsCancelledBeforeUnboundedBuffering() {
var calls = new AtomicInteger();
server.createContext("/", exchange -> {
calls.incrementAndGet(); 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();
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> transport.send(request("/", 2000), 8192));
assertEquals(BoundedHttpTransport.Reason.BODY_TOO_LARGE, failure.reason());
assertEquals(200, failure.observedStatus()); assertEquals(1, calls.get());
}
@Test void declaredOversizeIsRejectedWithoutWaitingForTheBody() {
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, () -> transport.send(request("/", 1000), 8192));
assertEquals(BoundedHttpTransport.Reason.BODY_TOO_LARGE, failure.reason());
}
@Test void totalDeadlineIncludesBodyReadsAfterHeaders() {
var calls = new AtomicInteger();
server.createContext("/", exchange -> {
calls.incrementAndGet(); exchange.sendResponseHeaders(200, 0);
try (var output = exchange.getResponseBody()) {
output.write('x'); output.flush();
try { release.await(3, 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, () -> transport.send(request("/", 200), 8192));
assertEquals(BoundedHttpTransport.Reason.TIMEOUT, failure.reason());
assertTrue(TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start) < 2000);
assertEquals(1, calls.get());
}
@Test void errorBodiesUseASmallerLimitAndRetainOnlyObservedStatus() {
server.createContext("/", exchange -> { exchange.sendResponseHeaders(401, 1_000_000); exchange.close(); }); server.start();
var failure = assertThrows(BoundedHttpTransport.Failure.class, () -> transport.send(request("/?private-query", 1000), 8 * 1024 * 1024));
assertEquals(BoundedHttpTransport.Reason.BODY_TOO_LARGE, failure.reason());
assertEquals(401, failure.observedStatus());
assertFalse(failure.toString().contains("private-query"));
}
@Test void redirectsAreReturnedAndNeverFollowed() throws Exception {
var redirected = new AtomicInteger();
server.createContext("/start", exchange -> { exchange.getResponseHeaders().set("Location", "/internal"); exchange.sendResponseHeaders(302, -1); exchange.close(); });
server.createContext("/internal", exchange -> { redirected.incrementAndGet(); exchange.sendResponseHeaders(200, -1); exchange.close(); }); server.start();
assertEquals(302, transport.send(request("/start", 2000), 1024).statusCode());
assertEquals(0, redirected.get());
}
@Test void interruptionCancelsTheAttemptAndRestoresInterruptFlag() throws Exception {
var arrived = new CountDownLatch(1); var result = new AtomicReference<BoundedHttpTransport.Reason>(); var interrupted = new AtomicReference<Boolean>();
server.createContext("/", exchange -> {
exchange.sendResponseHeaders(200, 0); arrived.countDown();
try { release.await(5, TimeUnit.SECONDS); } catch (InterruptedException error) { Thread.currentThread().interrupt(); }
exchange.close();
}); server.start();
var worker = new Thread(() -> {
try { transport.send(request("/", 5000), 1024); }
catch (BoundedHttpTransport.Failure failure) { result.set(failure.reason()); interrupted.set(Thread.currentThread().isInterrupted()); }
}); worker.setDaemon(true); worker.start();
try {
assertTrue(arrived.await(2, TimeUnit.SECONDS)); worker.interrupt(); worker.join(2000);
assertFalse(worker.isAlive()); assertEquals(BoundedHttpTransport.Reason.INTERRUPTED, result.get()); assertEquals(true, interrupted.get());
} finally { release.countDown(); worker.interrupt(); }
}
@Test void callersCannotOmitDeadlinesOrRequestUnboundedResponses() {
var request = HttpRequest.newBuilder(URI.create("http://127.0.0.1:1/")).GET().build();
assertThrows(IllegalArgumentException.class, () -> transport.send(request, 1024));
assertThrows(IllegalArgumentException.class, () -> transport.send(request, Integer.MAX_VALUE));
}
}
@@ -298,6 +298,23 @@ class AsyncProviderClientTest {
assertEquals("INVALID_CREDENTIAL_FINGERPRINT", assertThrows(ApiException.class, () -> client.requirePollableBinding("provider-vast", "route-a", "tripo", "3d", "test-key")).getCode());
}
@ParameterizedTest
@CsvSource({"200,UNKNOWN", "401,REJECTED"})
void responseLimitKeepsTheObservedAcceptanceBoundary(int status, ProviderRequestException.Acceptance expected) throws Exception {
HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
var calls = new java.util.concurrent.atomic.AtomicInteger();
server.createContext("/", exchange -> {
calls.incrementAndGet(); exchange.getRequestBody().readAllBytes();
exchange.sendResponseHeaders(status, 9 * 1024 * 1024); exchange.close();
}); server.start();
try {
var client = clientFor("http://127.0.0.1:" + server.getAddress().getPort());
var failure = assertThrows(ProviderRequestException.class, () -> client.submit("provider-vast", "tripo", "3d", "test"));
assertEquals(expected, failure.acceptance());
assertEquals(1, calls.get());
} finally { server.stop(0); }
}
@Test void invalidMediaIsKnownToFailBeforeSendingGenerationRequest() {
var client = clientFor("http://127.0.0.1:1");
var failure = assertThrows(ProviderRequestException.class, () -> client.submit("provider-vast", "tripo", "3d", Map.of("media_url", "http://127.0.0.1/private")));
@@ -127,6 +127,16 @@ class AsyncTaskPostgresTest {
verifyNoInteractions(provider);
}
@Test void taskReadsAreOwnerScopedAndCannotExposeAnotherUsersResult() {
UUID anotherUser = UUID.randomUUID(), anotherKey = UUID.randomUUID();
when(catalog.keyOwnerId(anotherKey)).thenReturn(anotherUser);
var foreignKey = Map.<String,Object>of("id", anotherKey.toString());
assertEquals("TASK_NOT_FOUND", assertThrows(ApiException.class, () -> tasks.getForKey(foreignKey, taskId)).getCode());
when(catalog.authenticateKey("foreign-token")).thenReturn(foreignKey);
assertTrue(tasks.list("Bearer foreign-token", 100).isEmpty());
assertEquals(taskId, tasks.getForKey(Map.of("id", keyId.toString()), taskId).get("id"));
}
@Test void idempotentReplayReturnsOriginalEvenAfterCompletionAndRouteRetirement() {
var input = Map.<String,Object>of("model", "model-mock-3d", "prompt", "one chair");
var first = create("client-operation-1", input);