Add support for Apache HttpAsyncClient

Author: pimterry

README.md

@@ -13,6 +13,7 @@ Traffic can be captured from at least:
 - [x] Java's built-in HttpURLConnection
 - [x] Java 11's built-in HttpClient
 - [x] Apache HttpClient v4 & v5
+  [x] Apache HttpAsyncClient v4 & v5
 - [x] OkHttp v2, v3 & v4
 - [x] Retrofit
 - [x] Jetty-Client v9, 10 & 11

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

@@ -0,0 +1,16 @@
+package tech.httptoolkit.javaagent;
+
+import net.bytebuddy.asm.Advice;
+
+import javax.net.ssl.SSLContext;
+
+public class OverrideSslContextFieldAdvice {
+
+    @Advice.OnMethodEnter
+    public static void beforeMethod(
+            @Advice.FieldValue(value = "sslContext", readOnly = false) SSLContext sslContextField
+    ) {
+        sslContextField = HttpProxyAgent.getInterceptedSslContext();
+    }
+
+}

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

@@ -78,6 +78,7 @@ fun interceptAllHttps(config: Config, instrumentation: Instrumentation) {
         ApacheClientRoutingV4Transformer(),
         ApacheClientRoutingV5Transformer(),
         ApacheSslSocketFactoryTransformer(),
+        ApacheClientTlsStrategyTransformer(),
         JavaClientTransformer(),
         JettyClientTransformer(),
         AsyncHttpClientConfigTransformer(),

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

@@ -0,0 +1,57 @@
+package tech.httptoolkit.javaagent
+
+import net.bytebuddy.agent.builder.AgentBuilder
+import net.bytebuddy.asm.Advice
+import net.bytebuddy.description.method.MethodDescription
+import net.bytebuddy.description.type.TypeDescription
+import net.bytebuddy.dynamic.DynamicType
+import net.bytebuddy.matcher.ElementMatchers.*
+import net.bytebuddy.utility.JavaModule
+import tech.httptoolkit.javaagent.apacheclient.ApacheSetSslSocketFactoryAdvice
+import tech.httptoolkit.javaagent.apacheclient.ApacheV4ReturnProxyRouteAdvice
+import tech.httptoolkit.javaagent.apacheclient.ApacheV5ReturnProxyRouteAdvice
+
+// Apache async client hooks depend on the non-async Apache client transformers, which successfully transform proxy
+// configuration, but we need to separate re-transform TLS configuration too.
+
+// To do so, we get all instances of TlsStrategy/SSLIOSessionStrategy, all of which seem to have an sslContext private
+// field which they wrap around the connection their implementation upgrade(). Most of the real ones inherit from
+// AbstractClientTlsStrategy, which does this, but there's other examples too. We hook upgrade(), so that that
+// field is reset to use our context before any client TLS upgrade happens.
+
+class ApacheClientTlsStrategyTransformer : MatchingAgentTransformer {
+    override fun register(builder: AgentBuilder): AgentBuilder {
+        return builder
+            // For v5 we need to hook into every client TlsStrategy (of which there are many).
+            .type(
+                hasSuperType(named("org.apache.hc.core5.http.nio.ssl.TlsStrategy"))
+            ).and(
+                // There are both Server & Client strategies with the same interface, and checking the name is the only
+                // way to tell the difference:
+                nameContains("Client")
+            ).and(
+                // All strategies either do this, or extend a class that does this (which will be intercepted
+                // first by itself anyway)
+                declaresField(named("sslContext"))
+            ).and(
+                not(isInterface())
+            ).transform(this)
+            // For v4, we do exactly the same, but there's only a single implementation:
+            .type(
+                named("org.apache.http.nio.conn.ssl.SSLIOSessionStrategy")
+            ).transform(this)
+    }
+
+    override fun transform(
+        builder: DynamicType.Builder<*>,
+        typeDescription: TypeDescription,
+        classLoader: ClassLoader?,
+        module: JavaModule?
+    ): DynamicType.Builder<*>? {
+        return builder
+            .visit(
+            Advice.to(OverrideSslContextFieldAdvice::class.java)
+                .on(hasMethodName("upgrade"))
+        );
+    }
+}

test-app/build.gradle

@@ -13,6 +13,7 @@ repositories {
 dependencies {
     implementation group: 'org.apache.httpcomponents', name: 'httpclient', version: '4.5'
     implementation group: 'org.apache.httpcomponents.client5', name: 'httpclient5', version: '5.0.3'
+    implementation group: 'org.apache.httpcomponents', name: 'httpasyncclient', version: '4.1.4'
     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'

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

@@ -10,20 +10,23 @@
 import java.util.stream.Collectors;
 
 import static java.lang.Thread.sleep;
+import static java.util.Map.entry;
 
 public class Main {
 
-    private static final Map<String, ClientCase<?>> cases = Map.of(
-            "apache-v4", new ApacheHttpClientV4Case(),
-            "apache-v5", new ApacheHttpClientV5Case(),
-            "http-url-conn", new HttpUrlConnCase(),
-            "java-http-client", new JavaHttpClientCase(),
-            "okhttp-v2", new OkHttpV2Case(),
-            "okhttp-v4", new OkHttpV4Case(),
-            "retrofit", new RetrofitCase(),
-            "jetty-client", new JettyClientCase(),
-            "async-http-client", new AsyncHttpClientCase(),
-            "spring-web", new SpringWebClientCase()
+    private static final Map<String, ClientCase<?>> cases = Map.ofEntries(
+        entry("apache-v4", new ApacheHttpClientV4Case()),
+        entry("apache-v5", new ApacheHttpClientV5Case()),
+        entry("apache-async-v4", new ApacheHttpAsyncClientV4Case()),
+        entry("apache-async-v5", new ApacheHttpAsyncClientV5Case()),
+        entry("http-url-conn", new HttpUrlConnCase()),
+        entry("java-http-client", new JavaHttpClientCase()),
+        entry("okhttp-v2", new OkHttpV2Case()),
+        entry("okhttp-v4", new OkHttpV4Case()),
+        entry("retrofit", new RetrofitCase()),
+        entry("jetty-client", new JettyClientCase()),
+        entry("async-http-client", new AsyncHttpClientCase()),
+        entry("spring-web", new SpringWebClientCase())
     );
 
     public static void main(String[] args) throws Exception {

test-app/src/main/java/tech/httptoolkit/testapp/cases/ApacheHttpAsyncClientV4Case.java

@@ -0,0 +1,31 @@
+package tech.httptoolkit.testapp.cases;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
+import org.apache.http.impl.nio.client.HttpAsyncClients;
+
+import java.util.concurrent.Future;
+
+public class ApacheHttpAsyncClientV4Case extends ClientCase<CloseableHttpAsyncClient> {
+
+    @Override
+    public CloseableHttpAsyncClient newClient(String url) {
+        CloseableHttpAsyncClient client = HttpAsyncClients.createDefault();
+        client.start();
+        return client;
+    }
+
+    @Override
+    public void stopClient(CloseableHttpAsyncClient client) throws Exception {
+        client.close();
+    }
+
+    @Override
+    public int test(String url, CloseableHttpAsyncClient client) throws Exception {
+        HttpGet request = new HttpGet(url);
+        Future<HttpResponse> future = client.execute(request, null);
+        HttpResponse response = future.get();
+        return response.getStatusLine().getStatusCode();
+    }
+}

test-app/src/main/java/tech/httptoolkit/testapp/cases/ApacheHttpAsyncClientV5Case.java

@@ -0,0 +1,32 @@
+package tech.httptoolkit.testapp.cases;
+
+import org.apache.hc.client5.http.async.methods.SimpleHttpRequest;
+import org.apache.hc.client5.http.async.methods.SimpleHttpRequests;
+import org.apache.hc.client5.http.async.methods.SimpleHttpResponse;
+import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient;
+import org.apache.hc.client5.http.impl.async.HttpAsyncClients;
+
+import java.util.concurrent.Future;
+
+public class ApacheHttpAsyncClientV5Case extends ClientCase<CloseableHttpAsyncClient> {
+
+    @Override
+    public CloseableHttpAsyncClient newClient(String url) {
+        CloseableHttpAsyncClient client = HttpAsyncClients.createDefault();
+        client.start();
+        return client;
+    }
+
+    @Override
+    public void stopClient(CloseableHttpAsyncClient client) throws Exception {
+        client.close();
+    }
+
+    @Override
+    public int test(String url, CloseableHttpAsyncClient client) throws Exception {
+        SimpleHttpRequest request = SimpleHttpRequests.get(url);
+        Future<SimpleHttpResponse> future = client.execute(request, null);
+        SimpleHttpResponse response = future.get();
+        return response.getCode();
+    }
+}