Implement a java agent based file interceptor

Signed-off-by: Gulshan <[email protected]>

Author: kumargu

libs/agent-sm/agent/src/main/java/org/opensearch/javaagent/Agent.java

@@ -10,6 +10,9 @@
 
 import org.opensearch.javaagent.bootstrap.AgentPolicy;
 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
 import java.lang.instrument.Instrumentation;
 import java.nio.channels.SocketChannel;
 import java.util.Map;
@@ -56,11 +59,28 @@ public static void agentmain(String agentArguments, Instrumentation instrumentat
     private static AgentBuilder createAgentBuilder(Instrumentation inst) throws Exception {
         final Junction<TypeDescription> systemType = ElementMatchers.isSubTypeOf(SocketChannel.class);
 
-        final AgentBuilder.Transformer transformer = (b, typeDescription, classLoader, module, pd) -> b.visit(
+        final Junction<TypeDescription> fileType = ElementMatchers.isSubTypeOf(File.class);
+        final Junction<TypeDescription> fileInputStreamType = ElementMatchers.isSubTypeOf(FileInputStream.class);
+        final Junction<TypeDescription> fileOutputStreamType = ElementMatchers.isSubTypeOf(FileOutputStream.class);
+
+        final AgentBuilder.Transformer socketTransformer = (b, typeDescription, classLoader, module, pd) -> b.visit(
             Advice.to(SocketChannelInterceptor.class)
                 .on(ElementMatchers.named("connect").and(ElementMatchers.not(ElementMatchers.isAbstract())))
         );
 
+        final AgentBuilder.Transformer fileTransformer = (b, typeDescription, classLoader, module, pd) -> b.visit(
+            Advice.to(FileInterceptor.class)
+                .on(
+                    ElementMatchers.named("delete")
+                        .or(ElementMatchers.named("createNewFile"))
+                        .or(ElementMatchers.named("renameTo"))
+                        .or(ElementMatchers.named("mkdirs"))
+                        .or(ElementMatchers.named("mkdir"))
+                        .or(ElementMatchers.named("open"))
+                        .or(ElementMatchers.isConstructor())
+                )
+        );
+
         ClassInjector.UsingUnsafe.ofBootLoader()
             .inject(
                 Map.of(
@@ -72,15 +92,15 @@ private static AgentBuilder createAgentBuilder(Instrumentation inst) throws Exce
             );
 
         final ByteBuddy byteBuddy = new ByteBuddy().with(Implementation.Context.Disabled.Factory.INSTANCE);
-        final AgentBuilder agentBuilder = new AgentBuilder.Default(byteBuddy).with(AgentBuilder.InitializationStrategy.NoOp.INSTANCE)
+        return new AgentBuilder.Default(byteBuddy).with(AgentBuilder.InitializationStrategy.NoOp.INSTANCE)
             .with(AgentBuilder.RedefinitionStrategy.REDEFINITION)
             .with(AgentBuilder.RedefinitionStrategy.Listener.StreamWriting.toSystemError())
             .with(AgentBuilder.TypeStrategy.Default.REDEFINE)
             .ignore(ElementMatchers.none())
             .type(systemType)
-            .transform(transformer);
-
-        return agentBuilder;
+            .transform(socketTransformer)
+            .type(fileType.or(fileInputStreamType).or(fileOutputStreamType))
+            .transform(fileTransformer);
     }
 
     private static void initAgent(Instrumentation instrumentation) throws Exception {

libs/agent-sm/agent/src/main/java/org/opensearch/javaagent/FileInterceptor.java

@@ -0,0 +1,87 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.javaagent;
+
+import org.opensearch.javaagent.bootstrap.AgentPolicy;
+
+import java.io.File;
+import java.io.FilePermission;
+import java.lang.reflect.Method;
+import java.security.Policy;
+import java.security.ProtectionDomain;
+import java.util.List;
+
+import net.bytebuddy.asm.Advice;
+import net.bytebuddy.asm.Advice.Origin;
+
+/**
+ * FileInterceptor
+ */
+public class FileInterceptor {
+    /**
+     * FileInterceptor
+     */
+    public FileInterceptor() {}
+
+    /**
+     * Intercepts file operations
+     * @param args arguments
+     * @param method method
+     * @throws Exception exceptions
+     */
+    @Advice.OnMethodEnter
+    @SuppressWarnings("removal")
+    public static void intercept(@Advice.AllArguments Object[] args, @Origin Method method) throws Exception {
+        final Policy policy = AgentPolicy.getPolicy();
+        if (policy == null) {
+            return; /* noop */
+        }
+
+        String filePath = null;
+        if (args.length > 0 && args[0] instanceof String path) {
+            filePath = path;
+        } else if (args.length > 0 && args[0] instanceof File file) {
+            filePath = file.getAbsolutePath();
+        }
+
+        if (filePath == null) {
+            return; // No valid file path found
+        }
+
+        final StackWalker walker = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE);
+        final List<ProtectionDomain> callers = walker.walk(new StackCallerChainExtractor());
+
+        boolean isMutating = method.getName().startsWith("write")
+            || method.getName().equals("createNewFile")
+            || method.getName().equals("mkdirs")
+            || method.getName().equals("mkdir")
+            || method.getName().equals("setWritable");
+        boolean isDelete = method.getName().equals("delete");
+
+        // Check each permission separately
+        for (final ProtectionDomain domain : callers) {
+            // FileInputStream operations
+            if (!policy.implies(domain, new FilePermission(filePath, "read"))) {
+                throw new SecurityException("Denied READ access to file: " + filePath + ", domain: " + domain);
+            }
+            // FileOutputStream operations
+            if (!policy.implies(domain, new FilePermission(filePath, "write"))) {
+                throw new SecurityException("Denied WRITE access to file: " + filePath + ", domain: " + domain);
+            }
+            // File mutating operations
+            if (isMutating && !policy.implies(domain, new FilePermission(filePath, "write"))) {
+                throw new SecurityException("Denied WRITE (mutating) operation to file: " + filePath + ", domain: " + domain);
+            }
+            // File deletion operations
+            if (isDelete && !policy.implies(domain, new FilePermission(filePath, "delete"))) {
+                throw new SecurityException("Denied DELETE access to file: " + filePath + ", domain: " + domain);
+            }
+        }
+    }
+}