Add server.request.body.files_content AppSec address for Vert.x 3/4/5 (#11724)

feat(appsec): fire server.request.body.files_content for Vert.x 3/4/5

Extends RoutingContextFilenamesAdvice in vertx-web-3.4, vertx-web-4.0,
and vertx-web-5.0 to also collect and fire the requestFilesContent()
IG callback alongside the existing requestFilesFilenames() callback.

Content is read from disk using FileInputStream and MultipartContentDecoder
since Vert.x BodyHandler always persists uploads to disk. The filenames
callback fires first; the content callback only fires if filenames did
not trigger a block (sequential guard).

Muzzle references are updated to include uploadedFileName() and
contentType() on FileUpload. Tests enable testBodyFilesContent() for
all three Vert.x versions.

fix(appsec): use Vert.x FileUpload.charSet() when decoding file content

FileUpload.contentType() in Vert.x returns only the MIME type without
the charset parameter. charSet() exposes it separately. Combine both
into a full content-type string before passing to
MultipartContentDecoder.readInputStream so extractCharset finds the
declared charset instead of falling back to the JVM default.

Add charSet() to FILE_UPLOAD_REF muzzle references in all three
Vert.x modules.

fix(appsec): extract FileUploadHelper to fix muzzle validation for Vert.x 3/4/5

Private static helpers in @advice classes generate INVOKESTATIC references to
the advice class itself. Muzzle resolves the advice class by name and validates
all its INVOKESTATIC targets against the library classpath, which does not
contain our advice classes, causing "Missing class" failures.

Extract readUploadContent and commitBlockingResponse into FileUploadHelper per
module and declare each in helperClassNames() so ByteBuddy injects them into
the target classloader and muzzle validates their references normally.

fix: make FileUploadHelper public and fix max files limit test for Vert.x 3/4/5

Helper classes injected via helperClassNames() are loaded into the app
classloader. When package-private, they cause IllegalAccessError from
instrumented classes in different packages within the same unnamed module.

The max files limit test also needed an override because Vert.x 3.4 returns
fileUploads() as a HashSet, whose iteration order depends on identity hash codes.
Adding helperClassNames() shifts object allocation counts and therefore hash
codes, changing which file is excluded. The override checks the count of
inspected files instead of which specific file was excluded.

style: replace em-dashes with colons in test comments

fix: skip ordering-dependent max files limit test for Vert.x HashSet

fileUploads() returns a HashSet in Vert.x so iteration order is JVM-
version-dependent. Add testBodyFilesContentOrdering() flag (defaults
true) to HttpServerTest to allow skipping the specific-file assertion.
Vert.x subclasses return false and add a count-based test instead.

fix: skip files_content test in VertxRxCircuitBreakerHttpServerForkedTest

The circuit breaker test server does not configure BodyHandler for the
multipart endpoint, so fileUploads() is never populated and the files_content
instrumentation does not fire. Consistent with the existing testBodyFilenames()
override in the same class.

Co-authored-by: devflow.devflow-routing-intake <devflow.devflow-routing-intake@kubernetes.us1.ddbuild.io>

Author: jandro996

dd-java-agent/instrumentation-testing/src/main/groovy/datadog/trace/agent/test/base/HttpServerTest.groovy

@@ -387,6 +387,11 @@ abstract class HttpServerTest<SERVER> extends WithHttpServer<SERVER> {
     false
   }
 
+  /** Override to false when the multipart implementation uses a set with non-deterministic ordering (e.g. HashSet). */
+  boolean testBodyFilesContentOrdering() {
+    true
+  }
+
   boolean testBodyJson() {
     false
   }
@@ -1767,7 +1772,7 @@ abstract class HttpServerTest<SERVER> extends WithHttpServer<SERVER> {
 
   def 'test instrumentation gateway file upload content max files limit'() {
     setup:
-    assumeTrue(testBodyFilesContent())
+    assumeTrue(testBodyFilesContent() && testBodyFilesContentOrdering())
     def maxFilesToInspect = Config.get().getAppSecMaxFileContentCount()
     def bodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM)
     (1..maxFilesToInspect + 1).each {

dd-java-agent/instrumentation/vertx/vertx-rx-3.5/src/test/groovy/server/VertxRxCircuitBreakerHttpServerForkedTest.groovy

@@ -44,6 +44,11 @@ class VertxRxCircuitBreakerHttpServerForkedTest extends VertxHttpServerForkedTes
     false
   }
 
+  @Override
+  boolean testBodyFilesContent() {
+    false
+  }
+
   @Override
   boolean testBodyJson() {
     false

dd-java-agent/instrumentation/vertx/vertx-web/vertx-web-3.4/src/main/java/datadog/trace/instrumentation/vertx_3_4/server/FileUploadHelper.java

@@ -0,0 +1,51 @@
+package datadog.trace.instrumentation.vertx_3_4.server;
+
+import datadog.appsec.api.blocking.BlockingException;
+import datadog.trace.api.gateway.BlockResponseFunction;
+import datadog.trace.api.gateway.Flow;
+import datadog.trace.api.gateway.RequestContext;
+import datadog.trace.api.http.MultipartContentDecoder;
+import io.vertx.ext.web.FileUpload;
+import java.io.FileInputStream;
+import java.util.List;
+import java.util.function.BiFunction;
+
+public class FileUploadHelper {
+
+  public static BlockingException commitBlockingResponse(
+      BiFunction<RequestContext, List<String>, Flow<Void>> cb,
+      RequestContext reqCtx,
+      List<String> data,
+      String reason) {
+    Flow<Void> flow = cb.apply(reqCtx, data);
+    Flow.Action action = flow.getAction();
+    if (action instanceof Flow.Action.RequestBlockingAction) {
+      BlockResponseFunction brf = reqCtx.getBlockResponseFunction();
+      if (brf != null) {
+        brf.tryCommitBlockingResponse(
+            reqCtx.getTraceSegment(), (Flow.Action.RequestBlockingAction) action);
+        return new BlockingException(reason);
+      }
+    }
+    return null;
+  }
+
+  public static String readUploadContent(FileUpload upload, int maxBytes) {
+    try {
+      String path = upload.uploadedFileName();
+      if (path == null || path.isEmpty()) {
+        return "";
+      }
+      String charSet = upload.charSet();
+      String contentType =
+          charSet != null && !charSet.isEmpty()
+              ? upload.contentType() + "; charset=" + charSet
+              : upload.contentType();
+      try (FileInputStream fis = new FileInputStream(path)) {
+        return MultipartContentDecoder.readInputStream(fis, maxBytes, contentType);
+      }
+    } catch (Exception ignored) {
+      return "";
+    }
+  }
+}

dd-java-agent/instrumentation/vertx/vertx-web/vertx-web-3.4/src/main/java/datadog/trace/instrumentation/vertx_3_4/server/RoutingContextFilenamesAdvice.java

@@ -2,10 +2,9 @@
 
 import static datadog.trace.api.gateway.Events.EVENTS;
 
-import datadog.appsec.api.blocking.BlockingException;
 import datadog.trace.advice.ActiveRequestContext;
 import datadog.trace.advice.RequiresRequestContext;
-import datadog.trace.api.gateway.BlockResponseFunction;
+import datadog.trace.api.Config;
 import datadog.trace.api.gateway.CallbackProvider;
 import datadog.trace.api.gateway.Flow;
 import datadog.trace.api.gateway.RequestContext;
@@ -38,35 +37,52 @@ static void after(
       return;
     }
 
-    List<String> filenames = new ArrayList<>(uploads.size());
+    CallbackProvider cbp = AgentTracer.get().getCallbackProvider(RequestContextSlot.APPSEC);
+    BiFunction<RequestContext, List<String>, Flow<Void>> filenamesCb =
+        cbp.getCallback(EVENTS.requestFilesFilenames());
+    BiFunction<RequestContext, List<String>, Flow<Void>> contentCb =
+        cbp.getCallback(EVENTS.requestFilesContent());
+    if (filenamesCb == null && contentCb == null) {
+      return;
+    }
+
+    int maxFiles = Config.get().getAppSecMaxFileContentCount();
+    int maxBytes = Config.get().getAppSecMaxFileContentBytes();
+    List<String> filenames = null;
+    List<String> filesContent = null;
+
     for (FileUpload upload : uploads) {
       String name = upload.fileName();
-      if (name != null && !name.isEmpty()) {
+      if (filenamesCb != null && name != null && !name.isEmpty()) {
+        if (filenames == null) {
+          filenames = new ArrayList<>();
+        }
         filenames.add(name);
       }
+      if (contentCb != null
+          && maxFiles > 0
+          && (filesContent == null || filesContent.size() < maxFiles)) {
+        if (filesContent == null) {
+          filesContent = new ArrayList<>();
+        }
+        filesContent.add(FileUploadHelper.readUploadContent(upload, maxBytes));
+      }
     }
-    if (filenames.isEmpty()) {
-      return;
+
+    if (filenamesCb != null && filenames != null) {
+      throwable =
+          FileUploadHelper.commitBlockingResponse(
+              filenamesCb, reqCtx, filenames, "Blocked request (multipart file upload)");
     }
 
-    CallbackProvider cbp = AgentTracer.get().getCallbackProvider(RequestContextSlot.APPSEC);
-    BiFunction<RequestContext, List<String>, Flow<Void>> cb =
-        cbp.getCallback(EVENTS.requestFilesFilenames());
-    if (cb == null) {
+    if (throwable != null) {
       return;
     }
 
-    Flow<Void> flow = cb.apply(reqCtx, filenames);
-    Flow.Action action = flow.getAction();
-    if (action instanceof Flow.Action.RequestBlockingAction) {
-      BlockResponseFunction brf = reqCtx.getBlockResponseFunction();
-      if (brf != null) {
-        brf.tryCommitBlockingResponse(
-            reqCtx.getTraceSegment(), (Flow.Action.RequestBlockingAction) action);
-        if (throwable == null) {
-          throwable = new BlockingException("Blocked request (multipart file upload)");
-        }
-      }
+    if (contentCb != null && filesContent != null) {
+      throwable =
+          FileUploadHelper.commitBlockingResponse(
+              contentCb, reqCtx, filesContent, "Blocked request (file content)");
     }
   }
 }

dd-java-agent/instrumentation/vertx/vertx-web/vertx-web-3.4/src/main/java/datadog/trace/instrumentation/vertx_3_4/server/RoutingContextImplInstrumentation.java

@@ -18,12 +18,20 @@ public class RoutingContextImplInstrumentation extends InstrumenterModule.AppSec
   private static final Reference FILE_UPLOAD_REF =
       new Reference.Builder("io.vertx.ext.web.FileUpload")
           .withMethod(new String[0], 0, "fileName", "Ljava/lang/String;")
+          .withMethod(new String[0], 0, "uploadedFileName", "Ljava/lang/String;")
+          .withMethod(new String[0], 0, "contentType", "Ljava/lang/String;")
+          .withMethod(new String[0], 0, "charSet", "Ljava/lang/String;")
           .build();
 
   public RoutingContextImplInstrumentation() {
     super("vertx", "vertx-3.4");
   }
 
+  @Override
+  public String[] helperClassNames() {
+    return new String[] {packageName + ".FileUploadHelper"};
+  }
+
   @Override
   public String instrumentedType() {
     return "io.vertx.ext.web.impl.RoutingContextImpl";

dd-java-agent/instrumentation/vertx/vertx-web/vertx-web-3.4/src/test/groovy/server/VertxHttpServerForkedTest.groovy

@@ -1,6 +1,8 @@
 package server
 
+import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.BODY_MULTIPART
 import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.ERROR
+import static org.junit.jupiter.api.Assumptions.assumeTrue
 import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.EXCEPTION
 import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.LOGIN
 import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.NOT_FOUND
@@ -10,6 +12,10 @@ import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.SUCCES
 import datadog.trace.agent.test.asserts.TraceAssert
 import datadog.trace.agent.test.base.HttpServer
 import datadog.trace.agent.test.base.HttpServerTest
+import datadog.trace.api.Config
+import okhttp3.MediaType
+import okhttp3.MultipartBody
+import okhttp3.RequestBody
 import datadog.trace.api.DDSpanTypes
 import datadog.trace.bootstrap.instrumentation.api.Tags
 import datadog.trace.instrumentation.netty41.server.NettyHttpServerDecorator
@@ -87,6 +93,42 @@ class VertxHttpServerForkedTest extends HttpServerTest<Vertx> {
     true
   }
 
+  @Override
+  boolean testBodyFilesContent() {
+    true
+  }
+
+  @Override
+  boolean testBodyFilesContentOrdering() {
+    false
+  }
+
+  // fileUploads() returns a HashSet in Vert.x: check count instead of which specific file is excluded
+  def 'test instrumentation gateway file upload content max files limit count'() {
+    setup:
+    assumeTrue(testBodyFilesContent())
+    def maxFilesToInspect = Config.get().getAppSecMaxFileContentCount()
+    def bodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM)
+    (1..maxFilesToInspect + 1).each { i ->
+      bodyBuilder.addFormDataPart("file${i}", "file${i}.bin",
+        RequestBody.create(MediaType.parse('application/octet-stream'), "content_of_file_${i}"))
+    }
+    def httpRequest = request(BODY_MULTIPART, 'POST', bodyBuilder.build()).build()
+    def response = client.newCall(httpRequest).execute()
+
+    when:
+    TEST_WRITER.waitForTraces(1)
+
+    then:
+    TEST_WRITER.get(0).any { span ->
+      def tag = span.getTag('request.body.files_content') as String
+      tag != null && tag.count('content_of_file_') == maxFilesToInspect
+    }
+
+    cleanup:
+    response.close()
+  }
+
   @Override
   boolean testBodyJson() {
     true

dd-java-agent/instrumentation/vertx/vertx-web/vertx-web-4.0/src/latestDepTest/groovy/server/VertxHttpServerForkedTest.groovy

@@ -1,6 +1,8 @@
 package server
 
+import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.BODY_MULTIPART
 import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.ERROR
+import static org.junit.jupiter.api.Assumptions.assumeTrue
 import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.EXCEPTION
 import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.LOGIN
 import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.NOT_FOUND
@@ -10,6 +12,10 @@ import static datadog.trace.agent.test.base.HttpServerTest.ServerEndpoint.SUCCES
 import datadog.trace.agent.test.asserts.TraceAssert
 import datadog.trace.agent.test.base.HttpServer
 import datadog.trace.agent.test.base.HttpServerTest
+import datadog.trace.api.Config
+import okhttp3.MediaType
+import okhttp3.MultipartBody
+import okhttp3.RequestBody
 import datadog.trace.api.DDSpanTypes
 import datadog.trace.bootstrap.instrumentation.api.Tags
 import datadog.trace.instrumentation.netty41.server.NettyHttpServerDecorator
@@ -82,6 +88,42 @@ class VertxHttpServerForkedTest extends HttpServerTest<Vertx> {
     true
   }
 
+  @Override
+  boolean testBodyFilesContent() {
+    true
+  }
+
+  @Override
+  boolean testBodyFilesContentOrdering() {
+    false
+  }
+
+  // fileUploads() returns a HashSet in Vert.x: check count instead of which specific file is excluded
+  def 'test instrumentation gateway file upload content max files limit count'() {
+    setup:
+    assumeTrue(testBodyFilesContent())
+    def maxFilesToInspect = Config.get().getAppSecMaxFileContentCount()
+    def bodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM)
+    (1..maxFilesToInspect + 1).each { i ->
+      bodyBuilder.addFormDataPart("file${i}", "file${i}.bin",
+        RequestBody.create(MediaType.parse('application/octet-stream'), "content_of_file_${i}"))
+    }
+    def httpRequest = request(BODY_MULTIPART, 'POST', bodyBuilder.build()).build()
+    def response = client.newCall(httpRequest).execute()
+
+    when:
+    TEST_WRITER.waitForTraces(1)
+
+    then:
+    TEST_WRITER.get(0).any { span ->
+      def tag = span.getTag('request.body.files_content') as String
+      tag != null && tag.count('content_of_file_') == maxFilesToInspect
+    }
+
+    cleanup:
+    response.close()
+  }
+
   @Override
   boolean testBodyJson() {
     true

dd-java-agent/instrumentation/vertx/vertx-web/vertx-web-4.0/src/main/java/datadog/trace/instrumentation/vertx_4_0/server/FileUploadHelper.java

@@ -0,0 +1,51 @@
+package datadog.trace.instrumentation.vertx_4_0.server;
+
+import datadog.appsec.api.blocking.BlockingException;
+import datadog.trace.api.gateway.BlockResponseFunction;
+import datadog.trace.api.gateway.Flow;
+import datadog.trace.api.gateway.RequestContext;
+import datadog.trace.api.http.MultipartContentDecoder;
+import io.vertx.ext.web.FileUpload;
+import java.io.FileInputStream;
+import java.util.List;
+import java.util.function.BiFunction;
+
+public class FileUploadHelper {
+
+  public static BlockingException commitBlockingResponse(
+      BiFunction<RequestContext, List<String>, Flow<Void>> cb,
+      RequestContext reqCtx,
+      List<String> data,
+      String reason) {
+    Flow<Void> flow = cb.apply(reqCtx, data);
+    Flow.Action action = flow.getAction();
+    if (action instanceof Flow.Action.RequestBlockingAction) {
+      BlockResponseFunction brf = reqCtx.getBlockResponseFunction();
+      if (brf != null) {
+        brf.tryCommitBlockingResponse(
+            reqCtx.getTraceSegment(), (Flow.Action.RequestBlockingAction) action);
+        return new BlockingException(reason);
+      }
+    }
+    return null;
+  }
+
+  public static String readUploadContent(FileUpload upload, int maxBytes) {
+    try {
+      String path = upload.uploadedFileName();
+      if (path == null || path.isEmpty()) {
+        return "";
+      }
+      String charSet = upload.charSet();
+      String contentType =
+          charSet != null && !charSet.isEmpty()
+              ? upload.contentType() + "; charset=" + charSet
+              : upload.contentType();
+      try (FileInputStream fis = new FileInputStream(path)) {
+        return MultipartContentDecoder.readInputStream(fis, maxBytes, contentType);
+      }
+    } catch (Exception ignored) {
+      return "";
+    }
+  }
+}