feat: Pin TLS 1.2/1.3, enforce min key size, guard empty chain

Author: thced

src/main/java/com/retailsvc/http/OpenApiServer.java

@@ -24,6 +24,7 @@
 import com.sun.net.httpserver.HttpContext;
 import com.sun.net.httpserver.HttpServer;
 import com.sun.net.httpserver.HttpsConfigurator;
+import com.sun.net.httpserver.HttpsParameters;
 import com.sun.net.httpserver.HttpsServer;
 import java.io.IOException;
 import java.net.InetAddress;
@@ -40,6 +41,7 @@
 import java.util.TreeSet;
 import java.util.stream.Collectors;
 import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLParameters;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -98,7 +100,7 @@ record HandlerConfig(
             : new InetSocketAddress(bindAddress, port);
     if (sslContext != null) {
       HttpsServer https = HttpsServer.create(socketAddress, 0);
-      https.setHttpsConfigurator(new HttpsConfigurator(sslContext));
+      https.setHttpsConfigurator(new TlsHttpsConfigurator(sslContext));
       this.httpServer = https;
     } else {
       this.httpServer = HttpServer.create(socketAddress, 0);
@@ -475,4 +477,23 @@ private static TypeMapper tryLoadGsonMapper() {
       return new GsonJsonMapper();
     }
   }
+
+  /**
+   * Pins HTTPS to TLS 1.2 and 1.3 only, regardless of operator-level {@code java.security}
+   * overrides, and explicitly leaves client-cert auth off (no mTLS in v1).
+   */
+  private static final class TlsHttpsConfigurator extends HttpsConfigurator {
+    TlsHttpsConfigurator(SSLContext context) {
+      super(context);
+    }
+
+    @Override
+    public void configure(HttpsParameters params) {
+      SSLParameters sslParams = getSSLContext().getDefaultSSLParameters();
+      sslParams.setProtocols(new String[] {"TLSv1.3", "TLSv1.2"});
+      sslParams.setNeedClientAuth(false);
+      sslParams.setWantClientAuth(false);
+      params.setSSLParameters(sslParams);
+    }
+  }
 }

src/main/java/com/retailsvc/http/internal/PemSslContext.java

@@ -8,9 +8,13 @@
 import java.security.KeyFactory;
 import java.security.KeyStore;
 import java.security.PrivateKey;
+import java.security.PublicKey;
 import java.security.Signature;
 import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
 import java.security.cert.CertificateFactory;
+import java.security.interfaces.ECPublicKey;
+import java.security.interfaces.RSAPublicKey;
 import java.security.spec.InvalidKeySpecException;
 import java.security.spec.PKCS8EncodedKeySpec;
 import java.util.Base64;
@@ -43,9 +47,24 @@ private static Certificate[] readCertificateChain(Path path) {
   private static Certificate[] decodeCertificateChain(byte[] pem, Path source) {
     try {
       CertificateFactory factory = CertificateFactory.getInstance("X.509");
-      Collection<? extends Certificate> certs =
-          factory.generateCertificates(new ByteArrayInputStream(pem));
-      return certs.toArray(new Certificate[0]);
+      Collection<? extends Certificate> certs;
+      try {
+        certs = factory.generateCertificates(new ByteArrayInputStream(pem));
+      } catch (CertificateException e) {
+        // JDK X509Factory throws "No certificate data found" for input with no
+        // BEGIN CERTIFICATE block. Treat that as an empty chain rather than a parse error.
+        if (e.getMessage() != null && e.getMessage().contains("No certificate data found")) {
+          throw new IllegalStateException(
+              "No certificates found in TLS certificate chain: " + source);
+        }
+        throw e;
+      }
+      Certificate[] chain = certs.toArray(new Certificate[0]);
+      if (chain.length == 0) {
+        throw new IllegalStateException(
+            "No certificates found in TLS certificate chain: " + source);
+      }
+      return chain;
     } catch (GeneralSecurityException e) {
       throw new IllegalStateException("Failed to parse TLS certificate chain from " + source, e);
     }
@@ -92,6 +111,7 @@ private static PrivateKey decodePrivateKey(String pem, Path source) {
 
   private static SSLContext buildSslContext(Certificate[] chain, PrivateKey key) {
     verifyKeyMatchesCert(key, chain[0]);
+    requireMinimumStrength(key, chain[0]);
     try {
       KeyStore ks = KeyStore.getInstance("PKCS12");
       ks.load(null, null);
@@ -106,6 +126,29 @@ private static SSLContext buildSslContext(Certificate[] chain, PrivateKey key) {
     }
   }
 
+  private static void requireMinimumStrength(PrivateKey key, Certificate cert) {
+    PublicKey publicKey = cert.getPublicKey();
+    switch (publicKey) {
+      case RSAPublicKey rsa -> {
+        int bits = rsa.getModulus().bitLength();
+        if (bits < 2048) {
+          throw new IllegalStateException(
+              "TLS RSA key below minimum strength: " + bits + " bits (require >= 2048)");
+        }
+      }
+      case ECPublicKey ec -> {
+        int bits = ec.getParams().getCurve().getField().getFieldSize();
+        if (bits < 256) {
+          throw new IllegalStateException(
+              "TLS EC key below minimum strength: " + bits + " bits (require >= 256)");
+        }
+      }
+      default ->
+          throw new IllegalStateException(
+              "Unsupported TLS public key algorithm: " + publicKey.getAlgorithm());
+    }
+  }
+
   private static void verifyKeyMatchesCert(PrivateKey key, Certificate cert) {
     String algorithm =
         switch (key.getAlgorithm()) {

src/test/java/com/retailsvc/http/OpenApiServerHttpsIT.java

@@ -20,7 +20,9 @@
 import java.util.Optional;
 import javax.net.ssl.KeyManager;
 import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
 import javax.net.ssl.TrustManagerFactory;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvSource;
 
@@ -70,6 +72,39 @@ void servesHttpsTraffic(String algo, String certPath, String keyPath) throws Exc
     }
   }
 
+  @Test
+  void negotiatesTls13() throws Exception {
+    Path cert = Path.of("src/test/resources/tls/rsa-cert.pem");
+    Path key = Path.of("src/test/resources/tls/rsa-key.pem");
+
+    Spec spec;
+    try (InputStream in = getClass().getResourceAsStream("/openapi.json")) {
+      spec = Spec.fromJson(in);
+    }
+
+    RequestHandler handler = req -> Response.ok(Map.of("hello", "world"));
+    Map<String, RequestHandler> handlers = stubAllHandlers(spec, Map.of("get-data", handler));
+
+    try (OpenApiServer server =
+        OpenApiServer.builder()
+            .spec(spec)
+            .handlers(handlers)
+            .securityValidator("apiKeyAuth", (req, cred) -> Optional.empty())
+            .securityValidator("bearerAuth", (req, cred) -> Optional.empty())
+            .securityValidator("basicAuth", (req, cred) -> Optional.empty())
+            .port(0)
+            .https(cert, key)
+            .build()) {
+
+      SSLContext clientCtx = trustStoreFor(cert);
+      try (SSLSocket socket =
+          (SSLSocket) clientCtx.getSocketFactory().createSocket("localhost", server.listenPort())) {
+        socket.startHandshake();
+        assertThat(socket.getSession().getProtocol()).isEqualTo("TLSv1.3");
+      }
+    }
+  }
+
   private static SSLContext trustStoreFor(Path certPath) throws Exception {
     byte[] bytes = Files.readAllBytes(certPath);
     Certificate cert =

src/test/java/com/retailsvc/http/internal/PemSslContextTest.java

@@ -3,6 +3,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import java.nio.file.Files;
 import java.nio.file.Path;
 import javax.net.ssl.SSLContext;
 import org.junit.jupiter.api.Test;
@@ -70,4 +71,24 @@ void rejectsMismatchedCertAndKey() {
         .isInstanceOf(IllegalStateException.class)
         .hasMessageContaining("do not match");
   }
+
+  @Test
+  void rejectsEmptyCertificateChain() throws Exception {
+    Path emptyCert = Files.createTempFile("empty-chain", ".pem");
+    Files.writeString(emptyCert, "# no certificates here\n");
+    try {
+      assertThatThrownBy(() -> PemSslContext.load(emptyCert, RSA_KEY))
+          .isInstanceOf(IllegalStateException.class)
+          .hasMessageContaining("No certificates found in TLS certificate chain");
+    } finally {
+      Files.deleteIfExists(emptyCert);
+    }
+  }
+
+  @Test
+  void acceptsEcKeyAtMinimumStrength() throws Exception {
+    // P-256 (256 bits) is exactly at the floor — must pass.
+    SSLContext ctx = PemSslContext.load(EC_CERT, EC_KEY);
+    assertThat(ctx).isNotNull();
+  }
 }