Readd some not so obsolete Files and adapt to new IFDS Analysis

- Commented out Backward analyses for now.
- Moved forward class for name analysis to new IFDS Analysis
- Moved VTA Analysis Test (including its matchers) to the new IFDS Analysis

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/tac/fpcf/analyses/taint/BackwardClassForNameTaintAnalysisScheduler.scala

@@ -0,0 +1,154 @@
+/* BSD 2-Clause License - see OPAL/LICENSE for details. */
+package org.opalj.tac.fpcf.analyses.taint
+/*  TODO Fix as soon as backwards analysis is implemented
+import org.opalj.br.analyses.SomeProject
+import org.opalj.br.{DeclaredMethod, DefinedMethod, Method}
+import org.opalj.fpcf.{EPS, FinalEP, PropertyStore}
+import org.opalj.ifds.IFDSPropertyMetaInformation
+import org.opalj.tac.cg.RTACallGraphKey
+import org.opalj.tac.fpcf.analyses.ifds.JavaMethod
+import org.opalj.tac.fpcf.analyses.ifds.old.taint.BackwardTaintProblem
+import org.opalj.tac.fpcf.analyses.ifds.old._
+import org.opalj.tac.fpcf.analyses.ifds.taint._
+import org.opalj.tac.fpcf.properties.OldTaint
+
+import java.io.File
+
+/**
+ * A backward IFDS taint analysis, which tracks the String parameters of all methods of the rt.jar,
+ * * which are callable from outside the library, to calls of Class.forName.
+ *
+ * @author Mario Trageser
+ */
+class BackwardClassForNameTaintAnalysisScheduler private (implicit val project: SomeProject)
+    extends BackwardIFDSAnalysis(new BackwardClassForNameTaintProblem(project), OldTaint)
+
+class BackwardClassForNameTaintProblem(p: SomeProject) extends BackwardTaintProblem(p) {
+
+    /**
+     * The string parameters of all public methods are entry points.
+     */
+    override val entryPoints: Seq[(DeclaredMethod, TaintFact)] =
+        p.allProjectClassFiles.filter(classFile =>
+            classFile.thisType.fqn == "java/lang/Class")
+            .flatMap(classFile => classFile.methods)
+            .filter(_.name == "forName")
+            .map(method => declaredMethods(method) -> Variable(-2))
+
+    /**
+     * There is no sanitizing in this analysis.
+     */
+    override protected def sanitizesReturnValue(callee: DeclaredMethod): Boolean = false
+
+    /**
+     * There is no sanitizing in this analysis.
+     */
+    override protected def sanitizesParameter(call: DeclaredMethodJavaStatement, in: TaintFact): Boolean = false
+
+    /**
+     * Do not perform unbalanced return for methods, which can be called from outside the library.
+     */
+    override def shouldPerformUnbalancedReturn(source: (DeclaredMethod, TaintFact)): Boolean = {
+        super.shouldPerformUnbalancedReturn(source) &&
+            (!canBeCalledFromOutside(source._1) ||
+                // The source is callable from outside, but should create unbalanced return facts.
+                entryPoints.contains(source))
+    }
+
+    /**
+     * This analysis does not create FlowFacts at calls.
+     * Instead, FlowFacts are created at the start node of methods.
+     */
+    override protected def createFlowFactAtCall(call: DeclaredMethodJavaStatement, in: Set[TaintFact],
+                                                source: (DeclaredMethod, TaintFact)): Option[FlowFact] = None
+
+    /**
+     * This analysis does not create FlowFacts at returns.
+     * Instead, FlowFacts are created at the start node of methods.
+     */
+    protected def applyFlowFactFromCallee(
+        calleeFact: FlowFact,
+        source:     (DeclaredMethod, TaintFact)
+    ): Option[FlowFact] = None
+
+    /**
+     * If we analyzed a transitive caller of the sink, which is callable from outside the library,
+     * and a formal parameter is tainted, we create a FlowFact.
+     */
+    override protected def createFlowFactAtBeginningOfMethod(
+        in:     Set[TaintFact],
+        source: (DeclaredMethod, TaintFact)
+    ): Option[FlowFact] = {
+        if (source._2.isInstanceOf[UnbalancedReturnFact[TaintFact @unchecked]] &&
+            canBeCalledFromOutside(source._1) && in.exists {
+                // index < 0 means, that it is a parameter.
+                case Variable(index) if index < 0            => true
+                case ArrayElement(index, _) if index < 0     => true
+                case InstanceField(index, _, _) if index < 0 => true
+                case _                                       => false
+            }) {
+            Some(FlowFact(currentCallChain(source).map(JavaMethod(_))))
+        } else None
+    }
+}
+
+object BackwardClassForNameTaintAnalysisScheduler extends IFDSAnalysisScheduler[TaintFact] {
+
+    override def init(p: SomeProject, ps: PropertyStore): BackwardClassForNameTaintAnalysisScheduler = {
+        p.get(RTACallGraphKey)
+        new BackwardClassForNameTaintAnalysisScheduler()(p)
+    }
+
+    override def property: IFDSPropertyMetaInformation[DeclaredMethodJavaStatement, TaintFact] = OldTaint
+}
+
+class BackwardClassForNameTaintAnalysisRunner extends AbsractIFDSAnalysisRunner {
+
+    override def analysisClass: BackwardClassForNameTaintAnalysisScheduler.type = BackwardClassForNameTaintAnalysisScheduler
+
+    override def printAnalysisResults(analysis: AbstractIFDSAnalysis[_], ps: PropertyStore): Unit = {
+        val propertyKey = BackwardClassForNameTaintAnalysisScheduler.property.key
+        val flowFactsAtSources = ps.entities(propertyKey).collect {
+            case EPS((m: DefinedMethod, inputFact)) if canBeCalledFromOutside(m, ps) =>
+                (m, inputFact)
+        }.flatMap(ps(_, propertyKey) match {
+            case FinalEP(_, OldTaint(result, _)) =>
+                result.values.fold(Set.empty)((acc, facts) => acc ++ facts).filter {
+                    case FlowFact(_) => true
+                    case _           => false
+                }
+            case _ => Seq.empty
+        })
+        for {
+            fact <- flowFactsAtSources
+        } {
+            fact match {
+                case FlowFact(flow) => println(s"flow: "+flow.asInstanceOf[Seq[Method]].map(_.toJava).mkString(", "))
+                case _              =>
+            }
+        }
+    }
+}
+
+object BackwardClassForNameTaintAnalysisRunner {
+    def main(args: Array[String]): Unit = {
+        if (args.contains("--help")) {
+            println("Potential parameters:")
+            println(" -seq (to use the SequentialPropertyStore)")
+            println(" -l2 (to use the l2 domain instead of the default l1 domain)")
+            println(" -delay (for a three seconds delay before the taint flow analysis is started)")
+            println(" -debug (for debugging mode in the property store)")
+            println(" -evalSchedulingStrategies (evaluates all available scheduling strategies)")
+            println(" -f <file> (Stores the average runtime to this file)")
+        } else {
+            val fileIndex = args.indexOf("-f")
+            new BackwardClassForNameTaintAnalysisRunner().run(
+                args.contains("-debug"),
+                args.contains("-l2"),
+                args.contains("-delay"),
+                args.contains("-evalSchedulingStrategies"),
+                if (fileIndex >= 0) Some(new File(args(fileIndex + 1))) else None
+            )
+        }
+    }
+}*/ 

DEVELOPING_OPAL/demos/src/main/scala/org/opalj/tac/fpcf/analyses/taint/ForwardClassForNameTaintAnalysisScheduler.scala

@@ -0,0 +1,149 @@
+/* BSD 2-Clause License - see OPAL/LICENSE for details. */
+package org.opalj.tac.fpcf.analyses.taint
+
+import org.opalj.br.analyses.{DeclaredMethodsKey, ProjectInformationKeys, SomeProject}
+import org.opalj.br.fpcf.PropertyStoreKey
+import org.opalj.br.{DeclaredMethod, Method, ObjectType}
+import org.opalj.fpcf.{FinalEP, PropertyBounds, PropertyStore}
+import org.opalj.ifds.{IFDSAnalysis, IFDSAnalysisScheduler, IFDSProperty, IFDSPropertyMetaInformation}
+import org.opalj.tac.cg.{RTACallGraphKey, TypeIteratorKey}
+import org.opalj.tac.fpcf.analyses.ifds.taint.{FlowFact, ForwardTaintProblem, TaintFact, TaintProblem, Variable}
+import org.opalj.tac.fpcf.analyses.ifds.*
+import org.opalj.tac.fpcf.properties.{TACAI, Taint}
+import org.opalj.tac.fpcf.properties.cg.Callers
+
+import java.io.File
+
+/**
+ * A forward IFDS taint analysis, which tracks the String parameters of all methods of the rt.jar,
+ * which are callable from outside the library, to calls of Class.forName.
+ *
+ * @author Dominik Helm
+ * @author Mario Trageser
+ * @author Michael Eichberg
+ */
+class ForwardClassForNameTaintAnalysis(project: SomeProject)
+    extends IFDSAnalysis()(project,new ForwardClassForNameTaintProblem(project),Taint)
+
+class ForwardClassForNameTaintProblem(project: SomeProject)
+    extends ForwardTaintProblem(project) with TaintProblem[Method, JavaStatement, TaintFact] {
+    private val propertyStore = project.get(PropertyStoreKey)
+    /**
+     * Returns all methods, that can be called from outside the library.
+     * The call graph must be computed, before this method may be invoked.
+     *
+     * @return All methods, that can be called from outside the library.
+     */
+    protected def methodsCallableFromOutside: Set[DeclaredMethod] = {
+        declaredMethods.declaredMethods.filter(canBeCalledFromOutside).toSet
+    }
+
+    /**
+     * Checks, if some `method` can be called from outside the library.
+     * The call graph must be computed, before this method may be invoked.
+     *
+     * @param method The method, which may be callable from outside.
+     * @return True, if `method` can be called from outside the library.
+     */
+    protected def canBeCalledFromOutside(method: DeclaredMethod): Boolean = {
+        val FinalEP(_, callers) = propertyStore(method, Callers.key)
+        callers.hasCallersWithUnknownContext
+    }
+    /**
+     * The string parameters of all public methods are entry points.
+     */
+    override def entryPoints: Seq[(Method, TaintFact)] = for {
+        m <- methodsCallableFromOutside.toSeq
+        if !m.definedMethod.isNative
+        index <- m.descriptor.parameterTypes.zipWithIndex.collect {
+            case (pType, index) if pType == ObjectType.String => index
+        }
+    } yield (m.definedMethod, Variable(-2 - index))
+
+    /**
+     * There is no sanitizing in this analysis.
+     */
+    override protected def sanitizesReturnValue(callee: Method): Boolean = false
+
+    /**
+     * There is no sanitizing in this analysis.
+     */
+    override protected def sanitizesParameter(call: JavaStatement, in: TaintFact): Boolean = false
+
+    /**
+     * This analysis does not create new taints on the fly.
+     * Instead, the string parameters of all public methods are tainted in the entry points.
+     */
+    override protected def createTaints(callee: Method, call: JavaStatement): Set[TaintFact] =
+        Set.empty
+
+    /**
+     * Create a FlowFact, if Class.forName is called with a tainted variable for the first parameter.
+     */
+    override protected def createFlowFact(callee: Method, call: JavaStatement,
+                                          in: TaintFact): Option[FlowFact] = {
+        if (isClassForName(declaredMethods(callee)) && in == Variable(-2))
+            Some(FlowFact(Seq(JavaMethod(call.method))))
+        else None
+    }
+
+    /**
+     * Checks, if a `method` is Class.forName.
+     *
+     * @param method The method.
+     * @return True, if the method is Class.forName.
+     */
+    private def isClassForName(method: DeclaredMethod): Boolean =
+        method.declaringClassType == ObjectType.Class && method.name == "forName"
+}
+
+object ForwardClassForNameTaintAnalysisScheduler extends IFDSAnalysisScheduler[TaintFact,Method,JavaStatement] {
+
+    override def init(p: SomeProject, ps: PropertyStore) = new ForwardClassForNameTaintAnalysis(p)
+
+    override def property: IFDSPropertyMetaInformation[JavaStatement, TaintFact] = Taint
+
+    override def requiredProjectInformation: ProjectInformationKeys = Seq(DeclaredMethodsKey, TypeIteratorKey, PropertyStoreKey,RTACallGraphKey)
+
+    override def uses: Set[PropertyBounds] =  Set(PropertyBounds.finalP(TACAI), PropertyBounds.finalP(Callers))
+}
+
+class ForwardClassForNameAnalysisRunner extends EvaluationRunner {
+
+    override def analysisClass: ForwardClassForNameTaintAnalysisScheduler.type = ForwardClassForNameTaintAnalysisScheduler
+
+    override def printAnalysisResults(analysis: IFDSAnalysis[?,?,?], ps: PropertyStore): Unit =
+        for {
+            e <- analysis.ifdsProblem.entryPoints
+            flows = ps(e, ForwardClassForNameTaintAnalysisScheduler.property.key)
+            fact <- flows.ub.asInstanceOf[IFDSProperty[JavaStatement, TaintFact]].flows.values.flatten.toSet[TaintFact]
+        } {
+            fact match {
+                case FlowFact(flow) => println(s"flow: "+flow.asInstanceOf[Set[Method]].map(_.toJava).mkString(", "))
+                case _              =>
+            }
+        }
+}
+
+object ForwardClassForNameAnalysisRunner {
+    def main(args: Array[String]): Unit = {
+        if (args.contains("--help")) {
+            println("Potential parameters:")
+            println(" -seq (to use the SequentialPropertyStore)")
+            println(" -l2 (to use the l2 domain instead of the default l1 domain)")
+            println(" -delay (for a three seconds delay before the taint flow analysis is started)")
+            println(" -debug (for debugging mode in the property store)")
+            println(" -evalSchedulingStrategies (evaluates all available scheduling strategies)")
+            println(" -f <file> (Stores the average runtime to this file)")
+        } else {
+            val fileIndex = args.indexOf("-f")
+            new ForwardClassForNameAnalysisRunner().run(
+                args.contains("-debug"),
+                args.contains("-l2"),
+                args.contains("-delay"),
+                args.contains("-evalSchedulingStrategies"),
+                if (fileIndex >= 0) Some(new File(args(fileIndex + 1))) else None
+            )
+        }
+    }
+}

DEVELOPING_OPAL/validate/src/test/scala/org/opalj/fpcf/ifds/VTATest.scala

@@ -0,0 +1,42 @@
+/* BSD 2-Clause License - see OPAL/LICENSE for details. */
+package org.opalj.fpcf.ifds
+
+import org.opalj.ai.domain.l2
+import org.opalj.ai.fpcf.properties.AIDomainFactoryKey
+import org.opalj.br.analyses.Project
+import org.opalj.fpcf.PropertiesTest
+import org.opalj.fpcf.properties.vta.{ExpectedCallee, ExpectedType}
+import org.opalj.tac.cg.RTACallGraphKey
+import org.opalj.tac.fpcf.analyses.ifds.VTANullFact
+import org.opalj.tac.fpcf.analyses.ifds.IFDSBasedVariableTypeAnalysisScheduler
+
+import java.net.URL
+
+class VTATest extends PropertiesTest {
+
+    override def init(p: Project[URL]): Unit = {
+        p.updateProjectInformationKeyInitializationData(
+            AIDomainFactoryKey
+        )(
+            (_: Option[Set[Class[_ <: AnyRef]]]) =>
+                Set[Class[_ <: AnyRef]](
+                    classOf[l2.DefaultPerformInvocationsDomainWithCFGAndDefUse[URL]]
+                )
+        )
+        p.get(RTACallGraphKey)
+    }
+
+    describe("Test the ExpectedType annotations") {
+        val testContext = executeAnalyses(new IFDSBasedVariableTypeAnalysisScheduler)
+        val project = testContext.project
+        //        val declaredMethods = project.get(DeclaredMethodsKey)
+        val eas = methodsWithAnnotations(project).map {
+            case (method, entityString, annotations) =>
+                ((method, VTANullFact), entityString, annotations)
+        }
+        testContext.propertyStore.shutdown()
+        validateProperties(testContext, eas, Set(ExpectedType.PROPERTY_VALIDATOR_KEY))
+        validateProperties(testContext, eas, Set(ExpectedCallee.PROPERTY_VALIDATOR_KEY))
+    }
+
+}

DEVELOPING_OPAL/validate/src/test/scala/org/opalj/fpcf/properties/taint/BackwardFlowPathMatcher.scala

@@ -1,12 +1,13 @@
 /* BSD 2-Clause License - see OPAL/LICENSE for details. */
 package org.opalj.fpcf.properties.taint
 
+/*  TODO Fix as soon as backwards analysis is implemented
 import org.opalj.br._
 import org.opalj.br.analyses.SomeProject
 import org.opalj.br.fpcf.PropertyStoreKey
 import org.opalj.fpcf.properties.AbstractPropertyMatcher
 import org.opalj.fpcf.{EPS, Entity, FinalEP, Property}
-import org.opalj.tac.fpcf.analyses.ifds.taint.old.BackwardTaintAnalysisFixtureScheduler
+import org.opalj.tac.fpcf.analyses.ifds.taint.BackwardTaintAnalysisFixtureScheduler
 import org.opalj.tac.fpcf.analyses.ifds.taint.{TaintFact, FlowFact}
 import org.opalj.tac.fpcf.properties.OldTaint
 
@@ -48,3 +49,4 @@ class BackwardFlowPathMatcher extends AbstractPropertyMatcher {
         }
     }
 }
+*/