Reject compromised eMudhra certificate keys

communication/src/main/java/datadog/communication/http/ForbiddenCertificatesHostnameVerifier.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2026 OkHttp Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package datadog.communication.http;
+
+import static java.util.Arrays.asList;
+
+import java.security.cert.Certificate;
+import java.util.HashSet;
+import java.util.Set;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+import okhttp3.internal.tls.OkHostnameVerifier;
+import okio.ByteString;
+
+/**
+ * Rejects the compromised eMudhra keys from CVE-2026-111943 before sending HTTP data.
+ *
+ * <p>Adapted from Jesse Wilson's corrected mitigation:
+ * https://gist.github.com/swankjesse/de8828e357a4d3fc8ebe1ca14ec2bc9f
+ */
+public final class ForbiddenCertificatesHostnameVerifier implements HostnameVerifier {
+  public static final ForbiddenCertificatesHostnameVerifier INSTANCE =
+      new ForbiddenCertificatesHostnameVerifier(
+          new HashSet<>(
+              asList(
+                  ByteString.decodeHex(
+                      "43bffa19d6ef651451f6841e019931e96f6f2eaeff28ab4b6f1ce4576de2717b"),
+                  ByteString.decodeHex(
+                      "49dd353dc2b919a3770645117d0e60c16115e7d1bc259eefe734b00ea434fe5f"),
+                  ByteString.decodeHex(
+                      "5c0660a2b164910d8ff589c18e14552e9e0ec237dcefe2cb736d41a4811f81a0"),
+                  ByteString.decodeHex(
+                      "63ecefee431d49523bc1136c4e72d0206a477086caf606cd5cf025686c109cf8"),
+                  ByteString.decodeHex(
+                      "92c063d67e8f14db71d288e11266ffdaf69cbf115f7bab14f3bc2f68d25e0e30"),
+                  ByteString.decodeHex(
+                      "e0254c7fcdc265e2f0f8a428dabb75ab4ae039b4872d62f5ee57f0877d5a8a41"),
+                  ByteString.decodeHex(
+                      "ebed6475c2c2d80fcb199f3fe8dd6e6b3ce60b77eb15d4e42c3dec0c6f5b5105"),
+                  ByteString.decodeHex(
+                      "ec4ffa1ad0ac88081314b7aaffef6a91f97cd57291bb5ba686c5415f5eb4f6b6"))));
+
+  private final Set<ByteString> forbiddenSpkiSha256s;
+
+  ForbiddenCertificatesHostnameVerifier(Set<ByteString> forbiddenSpkiSha256s) {
+    this.forbiddenSpkiSha256s = forbiddenSpkiSha256s;
+  }
+
+  @Override
+  public boolean verify(String hostname, SSLSession session) {
+    if (!OkHostnameVerifier.INSTANCE.verify(hostname, session)) {
+      return false;
+    }
+
+    try {
+      // Match keys throughout the chain, including cross-signed certificates.
+      for (Certificate certificate : session.getPeerCertificates()) {
+        ByteString spkiSha256 = ByteString.of(certificate.getPublicKey().getEncoded()).sha256();
+        if (forbiddenSpkiSha256s.contains(spkiSha256)) {
+          return false;
+        }
+      }
+      return true;
+    } catch (SSLPeerUnverifiedException e) {
+      return false;
+    }
+  }
+}

communication/src/main/java/datadog/communication/http/OkHttpUtils.java

@@ -170,6 +170,7 @@ private static OkHttpClient buildHttpClient(
     }
 
     builder
+        .hostnameVerifier(ForbiddenCertificatesHostnameVerifier.INSTANCE)
         .connectTimeout(timeoutMillis, MILLISECONDS)
         .writeTimeout(timeoutMillis, MILLISECONDS)
         .readTimeout(timeoutMillis, MILLISECONDS)

communication/src/test/java/datadog/communication/http/ForbiddenCertificatesHostnameVerifierTest.java

@@ -0,0 +1,192 @@
+package datadog.communication.http;
+
+import static java.util.Collections.singleton;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.InputStream;
+import java.lang.reflect.Proxy;
+import java.security.KeyStore;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateFactory;
+import java.security.cert.X509Certificate;
+import java.util.stream.Stream;
+import javax.net.ssl.HostnameVerifier;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.SSLSession;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.RequestBody;
+import okhttp3.Response;
+import okhttp3.mockwebserver.MockResponse;
+import okhttp3.mockwebserver.MockWebServer;
+import okhttp3.mockwebserver.RecordedRequest;
+import okio.ByteString;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class ForbiddenCertificatesHostnameVerifierTest {
+  private static HostnameVerifier hostnameVerifier;
+  private static X509Certificate localhostCertificate;
+  private static SSLContext sslContext;
+  private static X509TrustManager trustManager;
+
+  @BeforeAll
+  static void setUpTls() throws Exception {
+    hostnameVerifier = OkHttpUtils.buildHttpClient(false, null, null, 5000).hostnameVerifier();
+    KeyStore keyStore = KeyStore.getInstance("PKCS12");
+    char[] password = "datadog".toCharArray();
+    try (InputStream input = resource("localhost.p12")) {
+      keyStore.load(input, password);
+    }
+    localhostCertificate = (X509Certificate) keyStore.getCertificate("localhost");
+
+    KeyManagerFactory keyManagers =
+        KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+    keyManagers.init(keyStore, password);
+    TrustManagerFactory trustManagers =
+        TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+    trustManagers.init(keyStore);
+    trustManager = (X509TrustManager) trustManagers.getTrustManagers()[0];
+    sslContext = SSLContext.getInstance("TLS");
+    sslContext.init(keyManagers.getKeyManagers(), trustManagers.getTrustManagers(), null);
+  }
+
+  @ParameterizedTest
+  @MethodSource("compromisedCertificates")
+  void rejectsCompromisedIntermediateKeysIncludingCrossSignatures(X509Certificate compromised) {
+    assertFalse(hostnameVerifier.verify("localhost", session(localhostCertificate, compromised)));
+    assertFalse(
+        hostnameVerifier.verify(
+            "localhost", session(localhostCertificate, localhostCertificate, compromised)));
+  }
+
+  @Test
+  void preservesHostnameVerification() {
+    assertTrue(hostnameVerifier.verify("localhost", session(localhostCertificate)));
+    assertFalse(hostnameVerifier.verify("different.example", session(localhostCertificate)));
+  }
+
+  @Test
+  void rejectsUnverifiedPeer() {
+    assertFalse(hostnameVerifier.verify("localhost", session()));
+  }
+
+  static Stream<X509Certificate> compromisedCertificates() throws Exception {
+    try (InputStream input = resource("emudhra-compromised-certificates.pem")) {
+      return CertificateFactory.getInstance("X.509").generateCertificates(input).stream()
+          .map(X509Certificate.class::cast);
+    }
+  }
+
+  private static InputStream resource(String name) {
+    return ForbiddenCertificatesHostnameVerifierTest.class.getResourceAsStream("/" + name);
+  }
+
+  private static SSLSession session(Certificate... certificates) {
+    return (SSLSession)
+        Proxy.newProxyInstance(
+            SSLSession.class.getClassLoader(),
+            new Class<?>[] {SSLSession.class},
+            (proxy, method, args) -> {
+              if (!method.getName().equals("getPeerCertificates")) {
+                throw new UnsupportedOperationException(method.getName());
+              }
+              if (certificates.length == 0) {
+                throw new SSLPeerUnverifiedException("no peer");
+              }
+              return certificates;
+            });
+  }
+
+  @Nested
+  class HttpConnections {
+    private MockWebServer server;
+    private OkHttpClient client;
+
+    @BeforeEach
+    void setUp() {
+      server = new MockWebServer();
+    }
+
+    @AfterEach
+    void tearDown() throws Exception {
+      if (client != null) {
+        client.connectionPool().evictAll();
+        client.dispatcher().executorService().shutdownNow();
+      }
+      server.shutdown();
+    }
+
+    @Test
+    void acceptsTrustedHttps() throws Exception {
+      startHttpsServer();
+      server.enqueue(new MockResponse().setBody("accepted"));
+
+      try (Response response = client.newCall(secretRequest()).execute()) {
+        assertEquals("accepted", response.body().string());
+      }
+
+      RecordedRequest request = server.takeRequest();
+      assertEquals("secret-api-key", request.getHeader("DD-API-KEY"));
+      assertEquals("secret-body", request.getBody().readUtf8());
+    }
+
+    @Test
+    void rejectsForbiddenKeyBeforeSendingHeadersOrBody() throws Exception {
+      startHttpsServer();
+      // Block our test key to exercise real TLS without using compromised private keys.
+      ByteString forbiddenKey =
+          ByteString.of(localhostCertificate.getPublicKey().getEncoded()).sha256();
+      client =
+          client
+              .newBuilder()
+              .hostnameVerifier(new ForbiddenCertificatesHostnameVerifier(singleton(forbiddenKey)))
+              .build();
+
+      assertThrows(
+          SSLPeerUnverifiedException.class, () -> client.newCall(secretRequest()).execute());
+      assertEquals(0, server.getRequestCount());
+    }
+
+    @Test
+    void acceptsCleartextHttp() throws Exception {
+      server.start();
+      server.enqueue(new MockResponse().setBody("accepted"));
+      client = OkHttpUtils.buildHttpClient(server.url("/"), 5000);
+
+      try (Response response = client.newCall(secretRequest()).execute()) {
+        assertEquals("accepted", response.body().string());
+      }
+    }
+
+    private void startHttpsServer() throws Exception {
+      server.useHttps(sslContext.getSocketFactory(), false);
+      server.start();
+      client =
+          OkHttpUtils.buildHttpClient(server.url("/"), 5000)
+              .newBuilder()
+              .sslSocketFactory(sslContext.getSocketFactory(), trustManager)
+              .build();
+    }
+
+    private Request secretRequest() {
+      return new Request.Builder()
+          .url(server.url("/intake"))
+          .header("DD-API-KEY", "secret-api-key")
+          .post(RequestBody.create(null, "secret-body"))
+          .build();
+    }
+  }
+}