Native to Java calls WIP

DEVELOPING_OPAL/validate/src/test/resources/llvm/multilingual/taint/TaintTest.java → DEVELOPING_OPAL/validate/src/test/resources/llvm/cross_language/taint/TaintTest.java

@@ -30,9 +30,9 @@ public static void main (String[] args)
             demo.test_native_zero_no_flow();
             demo.test_native_array_tainted_flow();
             demo.test_native_array_untainted_no_flow();
-            /*demo.test_native_call_java_sink_flow();
+            demo.test_native_call_java_sink_flow();
             demo.test_native_call_java_source_flow();
-            demo.test_native_call_java_sanitize_no_flow();*/
+            demo.test_native_call_java_sanitize_no_flow();
             System.out.println("done");
         }
 
@@ -107,7 +107,7 @@ public void test_native_array_untainted_no_flow() {
             this.native_array_untainted();
         }
 
-        /*public void test_native_call_java_sink_flow() {
+        public void test_native_call_java_sink_flow() {
             System.out.println("native call java sink");
             this.propagate_to_java_sink(source());
         }
@@ -120,7 +120,7 @@ public void test_native_call_java_source_flow() {
         public void test_native_call_java_sanitize_no_flow() {
             System.out.println("native call java sanitize");
             this.sink(this.propagate_java_sanitize(this.source()));
-        }*/
+        }
 
         public int indirect_source() {
             return source();

DEVELOPING_OPAL/validate/src/test/scala/org/opalj/ll/MultilingualForwardTaintAnalysisTest.scala → DEVELOPING_OPAL/validate/src/test/scala/org/opalj/ll/CrossLanguageForwardTaintAnalysisTest.scala

@@ -6,7 +6,7 @@ import org.opalj.br.analyses.Project
 import org.opalj.br.fpcf.FPCFAnalysesManagerKey
 import org.opalj.ifds
 import org.opalj.ifds.IFDSProperty
-import org.opalj.ll.fpcf.analyses.ifds.LLVMStatement
+import org.opalj.ll.fpcf.analyses.ifds.{LLVMFunction, LLVMStatement}
 import org.opalj.ll.fpcf.analyses.ifds.taint.{JavaForwardTaintAnalysisScheduler, NativeFact, NativeForwardTaintAnalysisScheduler, NativeNullFact}
 import org.opalj.ll.llvm.value.Function
 import org.opalj.log.GlobalLogContext
@@ -16,18 +16,18 @@ import org.opalj.tac.fpcf.analyses.ifds.taint.{Fact, FlowFact, NullFact}
 import org.scalatest.funspec.AnyFunSpec
 import org.scalatest.matchers.should.Matchers
 
-class MultilingualForwardIFDSTaintAnalysisTests extends AnyFunSpec with Matchers {
+class CrossLanguageForwardIFDSTaintAnalysisTests extends AnyFunSpec with Matchers {
     describe("MultilingualForwardTaintAnalysis") {
         implicit val config = BaseConfig.withValue(ifds.ConfigKeyPrefix+"debug", ConfigValueFactory.fromAnyRef(true))
         val project =
             Project(
-                new java.io.File("./DEVELOPING_OPAL/validate/src/test/resources/llvm/multilingual/taint"),
+                new java.io.File("./DEVELOPING_OPAL/validate/src/test/resources/llvm/cross_language/taint"),
                 GlobalLogContext,
                 config
             )
 
         project.updateProjectInformationKeyInitializationData(LLVMProjectKey)(
-            current ⇒ List("./DEVELOPING_OPAL/validate/src/test/resources/llvm/multilingual/taint/TaintTest.ll")
+            current ⇒ List("./DEVELOPING_OPAL/validate/src/test/resources/llvm/cross_language/taint/TaintTest.ll")
         )
         project.get(LLVMProjectKey)
         project.get(RTACallGraphKey)
@@ -61,7 +61,7 @@ class MultilingualForwardIFDSTaintAnalysisTests extends AnyFunSpec with Matchers
         }
 
         val function: Function = project.get(LLVMProjectKey).function("Java_TaintTest_native_1array_1tainted").get
-        val debugData = ps((function, NativeNullFact), NativeForwardTaintAnalysisScheduler.property.key).ub.asInstanceOf[IFDSProperty[LLVMStatement, NativeFact]].debugData
+        val debugData = ps((LLVMFunction(function), NativeNullFact), NativeForwardTaintAnalysisScheduler.property.key).ub.asInstanceOf[IFDSProperty[LLVMStatement, NativeFact]].debugData
         for {
             bb ← function.basicBlocks
             instruction ← bb.instructions

OPAL/ifds/src/main/scala/org/opalj/ifds/ICFG.scala

@@ -3,7 +3,7 @@ package org.opalj.ifds
 
 import scala.collection.{Set ⇒ SomeSet}
 
-abstract class ICFG[IFDSFact <: AbstractIFDSFact, C <: AnyRef, S <: Statement[C, _]] {
+abstract class ICFG[IFDSFact <: AbstractIFDSFact, C <: AnyRef, S <: Statement[_ <: C, _]] {
     /**
      * Determines the statements at which the analysis starts.
      *

OPAL/ifds/src/main/scala/org/opalj/ifds/IFDSAnalysis.scala

@@ -49,7 +49,7 @@ object Dependees {
  * that is the fact reaches the statement as an input.
  * Source fact is the fact within the analysis entity.
  */
-case class PathEdges[IFDSFact <: AbstractIFDSFact, S <: Statement[C, _], C]() {
+case class PathEdges[IFDSFact <: AbstractIFDSFact, S <: Statement[_ <: C, _], C]() {
     var edges = Map.empty[S, Either[Set[IFDSFact], Map[S, Set[IFDSFact]]]]
 
     /**
@@ -115,7 +115,7 @@ case class PathEdges[IFDSFact <: AbstractIFDSFact, S <: Statement[C, _], C]() {
  * @param source The callable and input fact for which the callable is analyzed.
  * @param endSummaries Output facts of the analyzed callable as pairs of exit statement and fact
  */
-protected class IFDSState[IFDSFact <: AbstractIFDSFact, C <: AnyRef, S <: Statement[C, _], Work](
+protected class IFDSState[IFDSFact <: AbstractIFDSFact, C <: AnyRef, S <: Statement[_ <: C, _], Work](
         val source:        (C, IFDSFact),
         val dependees:     Dependees[Work]           = Dependees[Work](),
         val pathEdges:     PathEdges[IFDSFact, S, C] = PathEdges[IFDSFact, S, C](),
@@ -141,7 +141,7 @@ protected class ProjectFPCFAnalysis(val project: SomeProject) extends FPCFAnalys
  * @param propertyKey Provides the concrete property key that must be unique for every distinct concrete analysis and the lower bound for the IFDSProperty.
  * @tparam IFDSFact
  */
-class IFDSAnalysis[IFDSFact <: AbstractIFDSFact, C <: AnyRef, S <: Statement[C, _]](
+class IFDSAnalysis[IFDSFact <: AbstractIFDSFact, C <: AnyRef, S <: Statement[_ <: C, _]](
         implicit
         project:         SomeProject,
         val ifdsProblem: IFDSProblem[IFDSFact, C, S],
@@ -414,7 +414,7 @@ class IFDSAnalysis[IFDSFact <: AbstractIFDSFact, C <: AnyRef, S <: Statement[C,
     }
 }
 
-abstract class IFDSAnalysisScheduler[IFDSFact <: AbstractIFDSFact, C <: AnyRef, S <: Statement[C, _]]
+abstract class IFDSAnalysisScheduler[IFDSFact <: AbstractIFDSFact, C <: AnyRef, S <: Statement[_ <: C, _]]
     extends FPCFLazyAnalysisScheduler {
     final override type InitializationData = IFDSAnalysis[IFDSFact, C, S]
     def property: IFDSPropertyMetaInformation[S, IFDSFact]

OPAL/ifds/src/main/scala/org/opalj/ifds/IFDSProblem.scala

@@ -11,7 +11,7 @@ import org.opalj.ifds.Dependees.Getter
  * @author Mario Trageser
  * @author Marc Clement
  */
-abstract class IFDSProblem[IFDSFact <: AbstractIFDSFact, C <: AnyRef, S <: Statement[C, _]](val icfg: ICFG[IFDSFact, C, S]) {
+abstract class IFDSProblem[IFDSFact <: AbstractIFDSFact, C <: AnyRef, S <: Statement[_ <: C, _]](val icfg: ICFG[IFDSFact, C, S]) {
     type Work = (S, IFDSFact, Option[S])
 
     /**

OPAL/ll/src/main/scala/org/opalj/ll/fpcf/analyses/ifds/Callable.scala

@@ -3,7 +3,11 @@ package org.opalj.ll.fpcf.analyses.ifds
 import org.opalj.ifds.Callable
 import org.opalj.ll.llvm.value.Function
 
-case class LLVMFunction(val function: Function) extends Callable {
+abstract class NativeFunction extends Callable {
+    def name: String
+}
+
+case class LLVMFunction(function: Function) extends NativeFunction {
     override def name: String = function.name
     override def signature: String = function.name // TODO: add signature
 }

OPAL/ll/src/main/scala/org/opalj/ll/fpcf/analyses/ifds/NativeForwardICFG.scala

@@ -2,19 +2,22 @@
 package org.opalj.ll.fpcf.analyses.ifds
 
 import org.opalj.ifds.{AbstractIFDSFact, ICFG}
-import org.opalj.ll.llvm.value.{Call, Function, Instruction, Ret, Terminator}
+import org.opalj.ll.llvm.{FunctionType, PointerType}
+import org.opalj.ll.llvm.value.{Call, Function, Instruction, Ret, Terminator, Value}
 
-class NativeForwardICFG[IFDSFact <: AbstractIFDSFact] extends ICFG[IFDSFact, Function, LLVMStatement] {
+class NativeForwardICFG[IFDSFact <: AbstractIFDSFact] extends ICFG[IFDSFact, NativeFunction, LLVMStatement] {
     /**
      * Determines the statements at which the analysis starts.
      *
      * @param callable The analyzed callable.
      * @return The statements at which the analysis starts.
      */
-    override def startStatements(callable: Function): Set[LLVMStatement] = {
-        if (callable.basicBlockCount == 0)
-            throw new IllegalArgumentException(s"${callable} does not contain any basic blocks and likely should not be in scope of the analysis")
-        Set(LLVMStatement(callable.entryBlock.firstInstruction))
+    override def startStatements(callable: NativeFunction): Set[LLVMStatement] = callable match {
+        case LLVMFunction(function) ⇒ {
+            if (function.basicBlockCount == 0)
+                throw new IllegalArgumentException(s"${callable} does not contain any basic blocks and likely should not be in scope of the analysis")
+            Set(LLVMStatement(function.entryBlock.firstInstruction))
+        }
     }
 
     /**
@@ -35,18 +38,27 @@ class NativeForwardICFG[IFDSFact <: AbstractIFDSFact] extends ICFG[IFDSFact, Fun
      * @return All callables possibly called at the statement or None, if the statement does not
      *         contain a call.
      */
-    override def getCalleesIfCallStatement(statement: LLVMStatement): Option[collection.Set[Function]] = {
+    override def getCalleesIfCallStatement(statement: LLVMStatement): Option[collection.Set[NativeFunction]] = {
         statement.instruction match {
-            case call: Call ⇒ call.calledValue match {
-                case function: Function ⇒ Some(Set(function))
-                case _                  ⇒ Some(Set()) // TODO
-            }
-            case _ ⇒ None
+            case call: Call ⇒ Some(resolveCallee(call.calledValue))
+            case _          ⇒ None
         }
     }
 
     override def isExitStatement(statement: LLVMStatement): Boolean = statement.instruction match {
         case Ret(_) ⇒ true
         case _      ⇒ false
     }
+
+    private def resolveCallee(calledValue: Value): Set[NativeFunction] = calledValue match {
+        case function: Function ⇒ Set(LLVMFunction(function))
+        case _ ⇒ calledValue.typ match {
+            case p: PointerType ⇒ {
+                val functionType = p.element.asInstanceOf[FunctionType]
+                println(functionType.repr())
+                Set()
+            }
+            case _ ⇒ Set()
+        }
+    }
 }

OPAL/ll/src/main/scala/org/opalj/ll/fpcf/analyses/ifds/NativeIFDSAnalysis.scala

@@ -3,11 +3,8 @@
 package org.opalj.ll.fpcf.analyses.ifds
 
 import org.opalj.br.analyses.{ProjectInformationKeys, SomeProject}
-import org.opalj.ifds.{IFDSAnalysis, IFDSAnalysisScheduler, IFDSProblem, Statement}
-import org.opalj.ifds.{AbstractIFDSFact, IFDSPropertyMetaInformation}
+import org.opalj.ifds.{AbstractIFDSFact, IFDSAnalysis, IFDSAnalysisScheduler, IFDSProblem, IFDSPropertyMetaInformation}
 import org.opalj.ll.LLVMProjectKey
-import org.opalj.ll.llvm.value.{BasicBlock, Instruction}
-import org.opalj.ll.llvm.value
 
 /**
  *
@@ -17,24 +14,11 @@ import org.opalj.ll.llvm.value
  */
 class NativeIFDSAnalysis[IFDSFact <: AbstractIFDSFact](
         project:     SomeProject,
-        ifdsProblem: IFDSProblem[IFDSFact, value.Function, LLVMStatement],
+        ifdsProblem: IFDSProblem[IFDSFact, NativeFunction, LLVMStatement],
         propertyKey: IFDSPropertyMetaInformation[LLVMStatement, IFDSFact]
 )
-    extends IFDSAnalysis[IFDSFact, value.Function, LLVMStatement]()(project, ifdsProblem, propertyKey)
+    extends IFDSAnalysis[IFDSFact, NativeFunction, LLVMStatement]()(project, ifdsProblem, propertyKey)
 
-/**
- * A statement that is passed to the concrete analysis.
- *
- * @param instruction The LLVM instruction.
- */
-case class LLVMStatement(instruction: Instruction) extends Statement[value.Function, BasicBlock] {
-    def function: value.Function = instruction.function
-    def basicBlock: BasicBlock = instruction.parent
-    override def node: BasicBlock = basicBlock
-    override def callable: value.Function = function
-    override def toString: String = s"${function.name}\n\t${instruction}\n\t${function}"
-}
-
-abstract class NativeIFDSAnalysisScheduler[IFDSFact <: AbstractIFDSFact] extends IFDSAnalysisScheduler[IFDSFact, value.Function, LLVMStatement] {
+abstract class NativeIFDSAnalysisScheduler[IFDSFact <: AbstractIFDSFact] extends IFDSAnalysisScheduler[IFDSFact, NativeFunction, LLVMStatement] {
     override def requiredProjectInformation: ProjectInformationKeys = Seq(LLVMProjectKey)
 }

OPAL/ll/src/main/scala/org/opalj/ll/fpcf/analyses/ifds/NativeIFDSProblem.scala

@@ -7,16 +7,16 @@ import org.opalj.fpcf.PropertyStore
 import org.opalj.ifds.Dependees.Getter
 import org.opalj.ifds.{AbstractIFDSFact, IFDSProblem}
 import org.opalj.ll.LLVMProjectKey
-import org.opalj.ll.llvm.value.Function
 
-abstract class NativeIFDSProblem[Fact <: AbstractIFDSFact](project: SomeProject) extends IFDSProblem[Fact, Function, LLVMStatement](new NativeForwardICFG[Fact]) {
+abstract class NativeIFDSProblem[Fact <: AbstractIFDSFact](project: SomeProject) extends IFDSProblem[Fact, NativeFunction, LLVMStatement](new NativeForwardICFG[Fact]) {
     final implicit val propertyStore: PropertyStore = project.get(PropertyStoreKey)
     val llvmProject = project.get(LLVMProjectKey)
 
-    override def outsideAnalysisContext(callee: Function): Option[(LLVMStatement, LLVMStatement, Fact, Getter) ⇒ Set[Fact]] = {
-        callee.basicBlockCount match {
-            case 0 ⇒ Some((_: LLVMStatement, _: LLVMStatement, in: Fact, _: Getter) ⇒ Set(in))
-            case _ ⇒ None
-        }
+    override def outsideAnalysisContext(callee: NativeFunction): Option[(LLVMStatement, LLVMStatement, Fact, Getter) ⇒ Set[Fact]] = callee match {
+        case LLVMFunction(function) ⇒
+            function.basicBlockCount match {
+                case 0 ⇒ Some((_: LLVMStatement, _: LLVMStatement, in: Fact, _: Getter) ⇒ Set(in))
+                case _ ⇒ None
+            }
     }
 }

OPAL/ll/src/main/scala/org/opalj/ll/fpcf/analyses/ifds/Statement.scala

@@ -0,0 +1,18 @@
+/* BSD 2-Clause License - see OPAL/LICENSE for details. */
+package org.opalj.ll.fpcf.analyses.ifds
+
+import org.opalj.ifds.Statement
+import org.opalj.ll.llvm.value.{BasicBlock, Instruction}
+
+/**
+ * A statement that is passed to the concrete analysis.
+ *
+ * @param instruction The LLVM instruction.
+ */
+case class LLVMStatement(instruction: Instruction) extends Statement[LLVMFunction, BasicBlock] {
+    def function: LLVMFunction = LLVMFunction(instruction.function)
+    def basicBlock: BasicBlock = instruction.parent
+    override def node: BasicBlock = basicBlock
+    override def callable: LLVMFunction = function
+    override def toString: String = s"${function.name}\n\t${instruction}\n\t${function}"
+}