Architectural: Add Wala Framework Setup

pom.xml

@@ -166,6 +166,11 @@
             <artifactId>byte-buddy-agent</artifactId>
             <version>1.14.19</version>
         </dependency>
+        <dependency>
+            <groupId>com.ibm.wala</groupId>
+            <artifactId>com.ibm.wala.core</artifactId>
+            <version>1.6.7</version>
+        </dependency>
     </dependencies>
     <build>
         <plugins>

src/main/java/de/tum/cit/ase/ares/api/architecture/ArchitectureSecurityTestCase.java

@@ -39,5 +39,5 @@ public interface ArchitectureSecurityTestCase {
      *
      * @param classes a set of {@link JavaClasses} representing the codebase to which the test case will be applied.
      */
-    void executeArchitectureTestCase(JavaClasses classes);
+    void executeArchitectureTestCase(Object classes);
 }

src/main/java/de/tum/cit/ase/ares/api/architecture/java/archunit/JavaArchUnitSecurityTestCase.java

@@ -74,32 +74,39 @@ public String writeArchitectureTestCase() {
      * Runs the architecture test case in the Java programming language.
      */
     @Override
-    public void executeArchitectureTestCase(JavaClasses classes) {
+    public void executeArchitectureTestCase(Object classes) {
+        // check if instance of object
+        if (!(classes instanceof JavaClasses javaClasses)) {
+            throw new IllegalArgumentException(localized("security.archunit.invalid.argument"));
+        }
+
         try {
             switch (this.javaArchitectureTestCaseSupported) {
                 case PACKAGE_IMPORT ->
                         JavaArchitectureTestCaseCollection
                                 .noClassesShouldImportForbiddenPackages(allowedPackages)
-                                .check(classes);
+                                .check(javaClasses);
                 case FILESYSTEM_INTERACTION ->
                         JavaArchitectureTestCaseCollection
                                 .NO_CLASS_SHOULD_ACCESS_FILE_SYSTEM
-                                .check(classes);
+                                .check(javaClasses);
                 case NETWORK_CONNECTION ->
                         JavaArchitectureTestCaseCollection
                                 .NO_CLASSES_SHOULD_ACCESS_NETWORK
-                                .check(classes);
+                                .check(javaClasses);
                 case THREAD_CREATION ->
-                        JavaArchitectureTestCaseCollection.NO_CLASSES_SHOULD_CREATE_THREADS.check(classes);
+                        JavaArchitectureTestCaseCollection.NO_CLASSES_SHOULD_CREATE_THREADS.check(javaClasses);
                 case COMMAND_EXECUTION ->
-                        JavaArchitectureTestCaseCollection.NO_CLASSES_SHOULD_EXECUTE_COMMANDS.check(classes);
+                        JavaArchitectureTestCaseCollection.NO_CLASSES_SHOULD_EXECUTE_COMMANDS.check(javaClasses);
                 default -> throw new UnsupportedOperationException("Not implemented yet");
             }
         } catch (AssertionError e) {
+            String[] split = null;
             if (e.getMessage() == null || e.getMessage().split("\n").length < 2) {
                 throw new SecurityException(localized("security.archunit.illegal.execution", e.getMessage()));
             }
-            throw new SecurityException(localized("security.archunit.illegal.execution", e.getMessage().split("\n")[1]));
+            split = e.getMessage().split("\n");
+            throw new SecurityException(localized("security.archunit.violation.error", split[0].replaceAll(".*?'(.*?)'.*", "$1"), split[1]));
         }
     }
     //</editor-fold>

src/main/java/de/tum/cit/ase/ares/api/architecture/java/archunit/postcompile/CustomClassResolver.java

@@ -1,11 +1,25 @@
 package de.tum.cit.ase.ares.api.architecture.java.archunit.postcompile;
 
 //<editor-fold desc="Imports">
+
+import com.ibm.wala.classLoader.IClass;
+import com.ibm.wala.core.java11.Java9AnalysisScopeReader;
+import com.ibm.wala.ipa.callgraph.AnalysisScope;
+import com.ibm.wala.ipa.cha.ClassHierarchy;
+import com.ibm.wala.ipa.cha.ClassHierarchyException;
+import com.ibm.wala.ipa.cha.ClassHierarchyFactory;
+import com.ibm.wala.types.ClassLoaderReference;
+import com.ibm.wala.types.TypeReference;
 import com.tngtech.archunit.core.domain.JavaClass;
 import com.tngtech.archunit.core.importer.ClassFileImporter;
 
+import java.io.File;
+import java.io.IOException;
 import java.net.URL;
+import java.util.Collections;
 import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
 //</editor-fold>
 
 /**
@@ -23,6 +37,23 @@ private CustomClassResolver() {
      */
     private static final ClassFileImporter classFileImporter = new ClassFileImporter();
 
+    private static final ClassHierarchy classHierarchy;
+
+    static {
+        try {
+            AnalysisScope scope = Java9AnalysisScopeReader.instance.makeJavaBinaryAnalysisScope(
+                    System.getProperty("java.class.path"),
+                    new File("src/main/java/de/tum/cit/ase/ares/api/architecture/java/archunit/postcompile/exclusions.txt")
+            );
+
+            // Build the class hierarchy
+            classHierarchy = ClassHierarchyFactory.make(scope);
+        } catch (ClassHierarchyException | IOException e) {
+            throw new SecurityException("Could not create class hierarchy for student submission", e); // $NON-NLS-1$
+        }
+    }
+
+
     /**
      * Try to resolve the class by the given type name.
      *
@@ -44,4 +75,42 @@ public static Optional<JavaClass> tryResolve(String typeName) {
             return Optional.empty();
         }
     }
+
+    /**
+     * Get the immediate subclasses of the given type name.
+     *
+     * @param typeName The type name of the class to get the immediate subclasses.
+     * @return The immediate subclasses of the given type name.
+     */
+    public static Set<JavaClass> getImmediateSubclasses(String typeName) {
+        TypeReference reference = TypeReference.find(ClassLoaderReference.Application, convertTypeName(typeName));
+        if (reference == null) {
+            return Collections.emptySet();
+        }
+        IClass clazz = classHierarchy.lookupClass(reference);
+        if (clazz == null) {
+            return Collections.emptySet();
+        }
+        return classHierarchy
+                .getImmediateSubclasses(clazz)
+                .stream()
+                .map(IClass::getName)
+                .map(Object::toString)
+                .map(CustomClassResolver::tryResolve)
+                .filter(Optional::isPresent)
+                .map(Optional::get).collect(Collectors.toSet());
+    }
+
+    /**
+     * Convert the type name to the format that can be used in the class file.
+     *
+     * @param typeName The type name to convert.
+     * @return The converted type name.
+     */
+    public static String convertTypeName(String typeName) {
+        if (typeName == null || typeName.isEmpty()) {
+            throw new IllegalArgumentException("Type name cannot be null or empty");
+        }
+        return "L" + typeName.replace('.', '/');
+    }
 }

src/main/java/de/tum/cit/ase/ares/api/architecture/java/archunit/postcompile/JavaArchitectureTestCaseCollection.java

@@ -26,7 +26,7 @@ public class JavaArchitectureTestCaseCollection {
      * This method checks if any class in the given package accesses the file system.
      */
     public static final ArchRule NO_CLASS_SHOULD_ACCESS_FILE_SYSTEM = createNoClassShouldHaveMethodRule(
-            "accesses file system",
+            "Accesses file system",
             FileHandlerConstants.JAVA_FILESYSTEM_INTERACTION_METHODS
     );
     //</editor-fold>
@@ -36,7 +36,7 @@ public class JavaArchitectureTestCaseCollection {
      * This method checks if any class in the given package accesses the network.
      */
     public static final ArchRule NO_CLASSES_SHOULD_ACCESS_NETWORK = createNoClassShouldHaveMethodRule(
-            "accesses network",
+            "Accesses network",
             FileHandlerConstants.JAVA_NETWORK_ACCESS_METHODS
     );
     //</editor-fold>
@@ -47,7 +47,7 @@ public class JavaArchitectureTestCaseCollection {
      * This method checks if any class in the given package uses the command line.
      */
     public static final ArchRule NO_CLASSES_SHOULD_TERMINATE_JVM = createNoClassShouldHaveMethodRule(
-            "terminates JVM",
+            "Terminates JVM",
             FileHandlerConstants.JAVA_JVM_TERMINATION_METHODS
     );
     //</editor-fold>
@@ -126,7 +126,8 @@ public boolean test(JavaAccess<?> javaAccess) {
                                                 .startsWith(method)
                                 );
                     }
-                }));
+                }))
+                .as(ruleName);
     }
     //</editor-fold>
 
@@ -135,21 +136,21 @@ public boolean test(JavaAccess<?> javaAccess) {
      * This method checks if any class in the given package uses reflection.
      */
     public static final ArchRule NO_CLASSES_SHOULD_USE_REFLECTION = createNoClassShouldHaveMethodRule(
-            "uses Reflection",
+            "Uses Reflection",
             FileHandlerConstants.JAVA_REFLECTION_METHODS
     );
     //</editor-fold>
 
     //<editor-fold desc="Command Execution related rule">
     public static final ArchRule NO_CLASSES_SHOULD_EXECUTE_COMMANDS = createNoClassShouldHaveMethodRule(
-            "executes commands",
+            "Executes commands",
             FileHandlerConstants.JAVA_COMMAND_EXECUTION_METHODS
     );
     //</editor-fold>
 
     //<editor-fold desc="Thread Creation related rule">
     public static final ArchRule NO_CLASSES_SHOULD_CREATE_THREADS = createNoClassShouldHaveMethodRule(
-            "creates threads",
+            "Manipulates threads",
             FileHandlerConstants.JAVA_THREAD_CREATION_METHODS
     );
     //</editor-fold>

src/main/java/de/tum/cit/ase/ares/api/architecture/java/archunit/postcompile/TransitivelyAccessesMethodsCondition.java

@@ -1,6 +1,7 @@
 package de.tum.cit.ase.ares.api.architecture.java.archunit.postcompile;
 
 //<editor-fold desc="Imports">
+
 import com.tngtech.archunit.base.DescribedPredicate;
 import com.tngtech.archunit.core.domain.JavaClass;
 import com.tngtech.archunit.core.domain.JavaAccess;
@@ -14,11 +15,11 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.HashSet;
-import java.util.Collections;
 
 import static com.tngtech.archunit.lang.ConditionEvent.createMessage;
 import static com.tngtech.archunit.thirdparty.com.google.common.base.Preconditions.checkNotNull;
 import static com.tngtech.archunit.thirdparty.com.google.common.collect.Iterables.getLast;
+import static de.tum.cit.ase.ares.api.architecture.java.archunit.postcompile.CustomClassResolver.getImmediateSubclasses;
 import static java.util.stream.Collectors.joining;
 import static java.util.stream.Collectors.toSet;
 //</editor-fold>
@@ -40,11 +41,12 @@ public class TransitivelyAccessesMethodsCondition extends ArchCondition<JavaClas
     //</editor-fold>
 
     //<editor-fold desc="Constructor">
+
     /**
      * @param conditionPredicate Predicate to match the accessed methods
      */
     public TransitivelyAccessesMethodsCondition(DescribedPredicate<? super JavaAccess<?>> conditionPredicate) {
-        super("transitively depend on classes that " + conditionPredicate.getDescription());
+        super(conditionPredicate.getDescription());
         this.conditionPredicate = checkNotNull(conditionPredicate);
     }
     //</editor-fold>
@@ -54,17 +56,12 @@ public TransitivelyAccessesMethodsCondition(DescribedPredicate<? super JavaAcces
      */
     @Override
     public void check(JavaClass item, ConditionEvents events) {
-        boolean hastTransitiveAccess = false;
         for (JavaAccess<?> target : item.getAccessesFromSelf()) {
             List<JavaAccess<?>> dependencyPath = transitiveAccessPath.findPathTo(target);
             if (!dependencyPath.isEmpty()) {
                 events.add(newTransitiveAccessPathFoundEvent(target, dependencyPath));
-                hastTransitiveAccess = true;
             }
         }
-        if (!hastTransitiveAccess) {
-            events.add(newNoTransitiveDependencyPathFoundEvent(item));
-        }
     }
 
     /**
@@ -85,13 +82,6 @@ private static ConditionEvent newTransitiveAccessPathFoundEvent(JavaAccess<?> ja
         return SimpleConditionEvent.satisfied(javaClass, createMessage(javaClass, message));
     }
 
-    /**
-     * @return a violated event if no transitive dependency path was found
-     */
-    private static ConditionEvent newNoTransitiveDependencyPathFoundEvent(JavaClass javaClass) {
-        return SimpleConditionEvent.violated(javaClass, createMessage(javaClass, "does not transitively depend on any matching class"));
-    }
-
     private class TransitiveAccessPath {
         /**
          * @return some outgoing transitive dependency path to the supplied class or empty if there is none
@@ -131,26 +121,23 @@ private boolean addAccessesToPathFrom(
 
         /**
          * We are currently using CHA, which resolves all the subclasses of a given class
+         *
          * @return all accesses to the same target as the supplied item that are not in the analyzed classes
          */
         private Set<JavaAccess<?>> getDirectAccessTargetsOutsideOfAnalyzedClasses(JavaAccess<?> item) {
             // Get all subclasses of the target owner including the target owner
             JavaClass resolvedTarget = resolveTargetOwner(item.getTargetOwner());
 
-            // Match the accesses to the target
-            Set<JavaClass> subclasses = resolvedTarget.getSubclasses().stream().map(this::resolveTargetOwner).collect(toSet());
-            subclasses.add(resolvedTarget);
-
             /**
-             * If the number of subclasses is more than 20, return an empty set.
-             * These classes are always generic interfaces or abstract classes
-             * TODO: Check if this is also the case for foreign packages
+             * We are currently using CHA, which resolves all the subclasses of a given class
+             * @return all accesses to the same target as the supplied item that are not in the analyzed classes
+             * Resolves immediate subclasses of the target class to find potential method implementations
+             * @param item The access to analyze + * @return all accesses to the same target as the supplied item from immediate subclasses
              */
-            if (subclasses.size() > 20 || isExceptionOrError(resolvedTarget)) {
-                return Collections.emptySet();
-            }
+            Set<JavaClass> directSubclasses = new HashSet<>(getImmediateSubclasses(item.getTargetOwner().getFullName()));
+            directSubclasses.add(resolvedTarget);
 
-            return subclasses.stream()
+            return directSubclasses.stream()
                     .map(javaClass ->
                             getAccessesFromClass(javaClass, item.getTarget().getFullName().substring(item.getTargetOwner().getFullName().length())))
                     .flatMap(Set::stream)
@@ -172,9 +159,5 @@ private JavaClass resolveTargetOwner(JavaClass targetOwner) {
             Optional<JavaClass> resolvedTarget = CustomClassResolver.tryResolve(targetOwner.getFullName());
             return resolvedTarget.orElse(targetOwner);
         }
-
-        private boolean isExceptionOrError(JavaClass javaClass) {
-            return javaClass.isAssignableTo(Exception.class) || javaClass.isAssignableTo(Error.class);
-        }
     }
 }

src/main/java/de/tum/cit/ase/ares/api/architecture/java/archunit/postcompile/exclusions.txt

@@ -0,0 +1,39 @@
+java/awt/.*
+java/beans/.*
+java/io/.*
+java/lang/Character.*
+java/lang/Class.*
+java/lang/ClassLoader.*
+java/lang/Compiler.*
+java/lang/Enum.*
+java/lang/Invoke.*
+java/lang/Module.*
+java/lang/Package.*
+java/lang/Process.*
+java/lang/ProcessBuilder.*
+java/lang/Runtime.*
+java/lang/RuntimePermission.*
+java/lang/SecurityManager.*
+java/lang/StackTraceElement.*
+java/lang/String.*
+java/lang/StringBuffer.*
+java/lang/StringBuilder.*
+java/lang/System.*
+java/lang/Thread.*
+java/lang/ThreadGroup.*
+java/lang/ThreadLocal.*
+java/lang/Throwable.*
+java/lang/Void.*
+java/math/.*
+java/net/.*
+java/nio/.*
+java/rmi/.*
+java/security/.*
+java/sql/.*
+java/text/.*
+java/time/.*
+java/util/.*
+javax/.*
+sun/.*
+com/sun/.*
+jdk/.*