Light, fluffy, and always free - The AWS Local Emulator alternative
chore(tls): pin the certificate path against backslash mangling (#3336)
Hector Ventura8a4c6494ed10
diff --git a/src/main/java/io/github/hectorvent/floci/config/TlsConfigSource.java b/src/main/java/io/github/hectorvent/floci/config/TlsConfigSource.javaindex 1a6fc3dfad..51ccba9255 100644--- a/src/main/java/io/github/hectorvent/floci/config/TlsConfigSource.java+++ b/src/main/java/io/github/hectorvent/floci/config/TlsConfigSource.java@@ -45,6 +45,14 @@ public class TlsConfigSource implements ConfigSource {private static final Logger LOG = Logger.getLogger(TlsConfigSource.class);+ /**+ * Internal ports Quarkus binds when TLS is enabled. {@link TlsProxyServer} listens on the+ * public Floci port and routes to these by protocol, so the two classes must agree; they are+ * declared here, next to the properties that set them, and referenced from the proxy.+ */+ static final int HTTP_INTERNAL_PORT = 4510;+ static final int HTTPS_INTERNAL_PORT = 4511;+private static final String SERVER_CERT_NAME = "floci-server.crt";private static final String SERVER_KEY_NAME = "floci-server.key";private static final String SERVER_METADATA_NAME = "floci-server.metadata.json";@@ -136,8 +144,8 @@ public class TlsConfigSource implements ConfigSource {// and does protocol detection to route HTTP and HTTPS to the correct backend.properties.put("quarkus.http.insecure-requests", "enabled");properties.put("quarkus.http.host", "127.0.0.1");- properties.put("quarkus.http.port", "4510");- properties.put("quarkus.http.ssl-port", "4511");+ properties.put("quarkus.http.port", String.valueOf(HTTP_INTERNAL_PORT));+ properties.put("quarkus.http.ssl-port", String.valueOf(HTTPS_INTERNAL_PORT));LOG.infov("TLS: HTTPS enabled, proxy will listen on port {0} (HTTP+HTTPS), cert={1}",resolveProperty("floci.port", "4566"), certPath);diff --git a/src/main/java/io/github/hectorvent/floci/config/TlsProxyServer.java b/src/main/java/io/github/hectorvent/floci/config/TlsProxyServer.javaindex 524bb5ca3d..dfff5303a8 100644--- a/src/main/java/io/github/hectorvent/floci/config/TlsProxyServer.java+++ b/src/main/java/io/github/hectorvent/floci/config/TlsProxyServer.java@@ -51,8 +51,8 @@ public class TlsProxyServer {/** TLS record content type for Handshake (ClientHello). */private static final byte TLS_HANDSHAKE = 0x16;- private static final int HTTP_BACKEND_PORT = 4510;- private static final int HTTPS_BACKEND_PORT = 4511;+ private static final int HTTP_BACKEND_PORT = TlsConfigSource.HTTP_INTERNAL_PORT;+ private static final int HTTPS_BACKEND_PORT = TlsConfigSource.HTTPS_INTERNAL_PORT;private final Vertx vertx;private final EmulatorConfig config;diff --git a/src/test/java/io/github/hectorvent/floci/config/TlsConfigSourceCertificatePathTest.java b/src/test/java/io/github/hectorvent/floci/config/TlsConfigSourceCertificatePathTest.javanew file mode 100644index 0000000000..845677165d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/config/TlsConfigSourceCertificatePathTest.java@@ -0,0 +1,125 @@+package io.github.hectorvent.floci.config;++import io.smallrye.config.PropertiesConfigSource;+import io.smallrye.config.SmallRyeConfig;+import io.smallrye.config.SmallRyeConfigBuilder;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.io.TempDir;++import java.nio.file.Path;+import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertNotEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Guards the certificate path against the backslash-mangling that broke TLS startup on Windows+ * in the sibling Azure emulator (floci-az #142), where a path such as+ * {@code D:\Dev\floci\data\tls\cert.crt} reached the HTTP server as+ * {@code D:Devflocidatatlscert.crt} and startup died with {@code NoSuchFileException}.+ *+ * <p>The mangling is not general SmallRye behaviour. Expression handling leaves a value with no+ * {@code $} untouched, and it deliberately compiles without escape processing. The damage comes+ * from {@code StringUtil.split}, which is reached only by the converter for collection-typed+ * properties, and which consumes each backslash.+ *+ * <p>That makes the property's declared type the whole defence. floci-aws is safe today only+ * because it writes {@code quarkus.tls.key-store.pem.0.cert}, a scalar {@code Path}. The key it+ * used to write, {@code quarkus.http.ssl.certificate.files}, is an {@code Optional<List<Path>>}+ * and is mangled. Nothing else records that distinction, so switching back would silently+ * reintroduce the bug; these tests fail if that happens.+ */+class TlsConfigSourceCertificatePathTest {++ /** A Windows path with no {@code $}, the shape that broke floci-az. */+ private static final String WINDOWS_PATH = "D:\\Dev\\floci\\data\\tls\\floci-server.crt";++ @TempDir+ Path tempDir;++ @BeforeEach+ void setup() {+ System.setProperty("floci.tls.enabled", "true");+ System.setProperty("floci.tls.self-signed", "true");+ System.setProperty("floci.storage.persistent-path", tempDir.toString());+ }++ @AfterEach+ void cleanup() {+ System.clearProperty("floci.tls.enabled");+ System.clearProperty("floci.tls.self-signed");+ System.clearProperty("floci.storage.persistent-path");+ }++ private static SmallRyeConfig config(String key, String value) {+ return new SmallRyeConfigBuilder()+ .addDefaultInterceptors()+ .withSources(new PropertiesConfigSource(Map.of(key, value), "test", 300))+ .build();+ }++ @Test+ void aWindowsPathSurvivesAsAScalarPathProperty() {+ SmallRyeConfig config = config("quarkus.tls.key-store.pem.0.cert", WINDOWS_PATH);++ assertEquals(WINDOWS_PATH, config.getValue("quarkus.tls.key-store.pem.0.cert", String.class),+ "a scalar property must round-trip a Windows path unchanged");+ assertEquals(Path.of(WINDOWS_PATH),+ config.getValue("quarkus.tls.key-store.pem.0.cert", Path.class),+ "converting to Path must not lose the separators either");+ }++ @Test+ void theSamePathIsMangledWhenReadAsACollection() {+ // Not a wish, a demonstration: this is exactly what floci-az hit, and it is why the+ // property's type is what protects us rather than anything in our own code.+ SmallRyeConfig config = config("quarkus.tls.key-store.pem.0.cert", WINDOWS_PATH);++ List<String> asList = config.getValues("quarkus.tls.key-store.pem.0.cert", String.class);++ assertEquals(1, asList.size());+ assertNotEquals(WINDOWS_PATH, asList.getFirst(),+ "if this ever stops mangling, the collection converter changed and the guard below "+ + "can be relaxed");+ assertEquals("D:Devflocidatatlsfloci-server.crt", asList.getFirst(),+ "the collection converter consumes every backslash");+ }++ @Test+ void theEmittedCertificateKeysAreScalarNotCollectionTyped() {+ // The actual regression guard. Quarkus types `...pem.0.cert` as a scalar Path and+ // `quarkus.http.ssl.certificate.files` as Optional<List<Path>>, so emitting the latter+ // would put the certificate path back through the splitter that broke floci-az.+ TlsConfigSource source = new TlsConfigSource();++ String certKey = "quarkus.tls.key-store.pem.0.cert";+ String keyKey = "quarkus.tls.key-store.pem.0.key";++ assertNotNull(source.getValue(certKey), "the scalar PEM cert key must be the one emitted");+ assertNotNull(source.getValue(keyKey), "the scalar PEM key key must be the one emitted");++ for (String plural : List.of("quarkus.http.ssl.certificate.files",+ "quarkus.http.ssl.certificate.key-files")) {+ assertTrue(source.getValue(plural) == null,+ "must not emit " + plural + ": it is collection-typed, so a Windows path "+ + "would be mangled by the collection converter");+ }+ }++ @Test+ void theGeneratedPathIsAbsoluteAndUsableAsWritten() {+ TlsConfigSource source = new TlsConfigSource();++ String certPath = source.getValue("quarkus.tls.key-store.pem.0.cert");++ assertNotNull(certPath);+ assertTrue(Path.of(certPath).isAbsolute(), "the emitted path must be absolute: " + certPath);+ assertTrue(java.nio.file.Files.exists(Path.of(certPath)),+ "the emitted path must resolve to the generated certificate: " + certPath);+ }+}