Add support for jetty-client

Author: pimterry

README.md

@@ -18,6 +18,7 @@ Traffic can be captured from at least:
 - [x] OkHttp v3
 - [x] OkHttp v4
 - [x] Retrofit
+- [x] Jetty-Client
 
 This will also capture HTTP(S) from any downstream libraries based on each of these clients, and many other untested clients sharing similar implementations, and so should cover a very large percentage of HTTP client usage.
 

build.gradle

@@ -28,6 +28,7 @@ dependencies {
     // Dependencies we load only as part of rewriting them, iff the target app includes them:
     compileOnly group: 'org.apache.httpcomponents', name: 'httpclient', version: '4.5'
     compileOnly group: 'org.apache.httpcomponents.client5', name: 'httpclient5', version: '5.0.3'
+    compileOnly group: 'org.eclipse.jetty', name: 'jetty-client', version: '11.0.1'
 
     // Test deps:
     testImplementation group: 'io.kotest', name: 'kotest-runner-junit5-jvm', version: '4.4.0'

src/main/java/tech/httptoolkit/javaagent/JettyResetDestinationsAdvice.java

@@ -0,0 +1,36 @@
+package tech.httptoolkit.javaagent;
+
+import net.bytebuddy.asm.Advice;
+import org.eclipse.jetty.client.*;
+
+import java.util.Map;
+
+public class JettyResetDestinationsAdvice {
+    @Advice.OnMethodEnter
+    public static void beforeResolveDestination(
+        @Advice.This Object thisHttpClient
+        // ^ Note that we can't use the real HttpClient type here, since this class is redefining it, so it would
+        // cause a circular reference that breaks patching completely.
+    ) {
+        boolean alreadyReset = JettyClientTransformer.getPatchedHttpClients().contains(thisHttpClient);
+        if (!alreadyReset) {
+            // If this is the first time that we've seen this client, it's possible that it existed before we attached,
+            // and it might have some existing open connections that don't use our proxy. To fix that, just once per
+            // client, we use reflection to get the destinations (cached connections) and reset them.
+            try {
+                @SuppressWarnings("unchecked")
+                Map<Origin, HttpDestination> destinations = (Map<Origin, HttpDestination>)
+                        thisHttpClient.getClass().getDeclaredField("destinations").get(thisHttpClient);
+
+                // Reset this destinations list:
+                for (HttpDestination destination : destinations.values()) {
+                    destination.close();
+                }
+                destinations.clear();
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+            JettyClientTransformer.getPatchedHttpClients().add(thisHttpClient);
+        }
+    }
+}

src/main/java/tech/httptoolkit/javaagent/JettyReturnProxyConfigurationAdvice.java

@@ -0,0 +1,18 @@
+package tech.httptoolkit.javaagent;
+
+import net.bytebuddy.asm.Advice;
+import org.eclipse.jetty.client.HttpProxy;
+import org.eclipse.jetty.client.Origin;
+import org.eclipse.jetty.client.ProxyConfiguration;
+
+public class JettyReturnProxyConfigurationAdvice {
+    @Advice.OnMethodExit
+    public static void getProxyConfiguration(@Advice.Return(readOnly = false) ProxyConfiguration returnValue) {
+        Origin.Address proxyAddress = new Origin.Address(HttpProxyAgent.getAgentProxyHost(), HttpProxyAgent.getAgentProxyPort());
+
+        ProxyConfiguration proxyConfig = new ProxyConfiguration();
+        proxyConfig.getProxies().add(new HttpProxy(proxyAddress, false));
+
+        returnValue = proxyConfig;
+    }
+}

src/main/java/tech/httptoolkit/javaagent/JettyReturnSslContextFactoryAdvice.java

@@ -0,0 +1,19 @@
+package tech.httptoolkit.javaagent;
+
+import net.bytebuddy.asm.Advice;
+import org.eclipse.jetty.util.ssl.SslContextFactory;
+
+public class JettyReturnSslContextFactoryAdvice {
+    @Advice.OnMethodExit
+    public static void getSslContextFactory(@Advice.Return(readOnly = false) SslContextFactory.Client returnValue) {
+        SslContextFactory.Client sslFactory = new SslContextFactory.Client();
+        sslFactory.setSslContext(HttpProxyAgent.getInterceptedSslContext());
+        try {
+            sslFactory.start();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+
+        returnValue = sslFactory;
+    }
+}

src/main/kotlin/tech/httptoolkit/javaagent/AgentMain.kt

@@ -74,6 +74,7 @@ fun interceptAllHttps(config: Config, instrumentation: Instrumentation) {
         ApacheClientRoutingV5Transformer(),
         ApacheSslSocketFactoryTransformer(),
         JavaClientTransformer(),
+        JettyClientTransformer()
     ).forEach { matchingAgentTransformer ->
         agentBuilder = matchingAgentTransformer.register(agentBuilder)
     }

src/main/kotlin/tech/httptoolkit/javaagent/JettyClientTransformer.kt

@@ -0,0 +1,51 @@
+package tech.httptoolkit.javaagent
+
+import net.bytebuddy.agent.builder.AgentBuilder
+import net.bytebuddy.asm.Advice
+import net.bytebuddy.description.type.TypeDescription
+import net.bytebuddy.dynamic.DynamicType
+import net.bytebuddy.utility.JavaModule
+import net.bytebuddy.matcher.ElementMatchers.*
+import java.util.*
+
+/**
+ * Transforms the JettyClient to use our proxy & trust our certificate.
+ *
+ * For new clients, we just need to override the proxyConfiguration and
+ * sslContextFactory properties on the HTTP client itself.
+ *
+ * For existing clients, we do that, and we also reset the destinations
+ * (internal connection pools) when resolveDestination is first called
+ * on each client.
+ */
+class JettyClientTransformer : MatchingAgentTransformer {
+
+    companion object {
+        // This is used to cache the clients that have been fully configured (had any existing destinations
+        // reset) so that we don't unnecessarily reset them again later.
+        @JvmStatic
+        public val patchedHttpClients: MutableSet<Any> = Collections.newSetFromMap(WeakHashMap())
+    }
+
+    override fun register(builder: AgentBuilder): AgentBuilder {
+        return builder
+            .type(
+                named("org.eclipse.jetty.client.HttpClient")
+            ).transform(this)
+    }
+
+    override fun transform(
+        builder: DynamicType.Builder<*>,
+        typeDescription: TypeDescription,
+        classLoader: ClassLoader?,
+        module: JavaModule?
+    ): DynamicType.Builder<*>? {
+        return builder
+            .visit(Advice.to(JettyReturnProxyConfigurationAdvice::class.java)
+                .on(hasMethodName("getProxyConfiguration")))
+            .visit(Advice.to(JettyReturnSslContextFactoryAdvice::class.java)
+                .on(hasMethodName("getSslContextFactory")))
+            .visit(Advice.to(JettyResetDestinationsAdvice::class.java)
+                .on(hasMethodName("resolveDestination")))
+    }
+}

src/test/kotlin/IntegrationTests.kt

@@ -1,3 +1,5 @@
+@file:Suppress("BlockingMethodInNonBlockingContext")
+
 import com.github.tomakehurst.wiremock.WireMockServer
 import com.github.tomakehurst.wiremock.client.WireMock.*
 import com.github.tomakehurst.wiremock.core.WireMockConfiguration.options

test-app/build.gradle

@@ -16,6 +16,7 @@ dependencies {
     implementation group: 'com.squareup.okhttp3', name: 'okhttp', version: '4.9.1'
     implementation group: 'com.squareup.okhttp', name: 'okhttp', version: '2.7.5'
     implementation group: 'com.squareup.retrofit2', name: 'retrofit', version: '2.9.0'
+    implementation group: 'org.eclipse.jetty', name: 'jetty-client', version: '11.0.1'
 }
 
 test {

test-app/src/main/java/tech/httptoolkit/testapp/Main.java

@@ -17,7 +17,8 @@ public class Main {
             "java-http-client", new JavaHttpClientCase(),
             "okhttp-v2", new OkHttpV2Case(),
             "okhttp-v4", new OkHttpV4Case(),
-            "retrofit", new RetrofitCase()
+            "retrofit", new RetrofitCase(),
+            "jetty-client", new JettyClientCase()
     );
 
     public static void main(String[] args) throws Exception {