Now user can control the Post processing of the result

Author: ranjithkris

de.fraunhofer.iem.secucheck.analysis.configuration/src/main/java/de/fraunhofer/iem/secucheck/analysis/configuration/SecucheckAnalysisConfiguration.java

@@ -62,6 +62,14 @@ public interface SecucheckAnalysisConfiguration {
      */
     void setListener(AnalysisResultListener resultListener);
 
+    /**
+     * Sets the isPostProcess result. If set, then it process the result and add the taintflow path to the result.
+     * For now, it PostProcess result is available only to Boomerang3 solver
+     *
+     * @param isPostProcessResult is Post Process result
+     */
+    void setIsPostProcessResult(boolean isPostProcessResult);
+
     OS getOs();
 
     Solver getSolver();
@@ -76,4 +84,6 @@ public interface SecucheckAnalysisConfiguration {
 
     AnalysisResultListener getListener();
 
+    boolean isPostProcessResult();
+
 }

de.fraunhofer.iem.secucheck.analysis.configuration/src/main/java/de/fraunhofer/iem/secucheck/analysis/configuration/SecucheckAnalysisDefaultConfiguration.java

@@ -20,6 +20,7 @@ public class SecucheckAnalysisDefaultConfiguration implements SecucheckAnalysisC
     private List<EntryPoint> entryPoints;
     private List<MethodImpl> generalPropagators;
     private AnalysisResultListener resultListener;
+    private boolean isPostProcess;
 
     @Override
     public void setOs(OS os) {
@@ -56,6 +57,11 @@ public void setListener(AnalysisResultListener resultListener) {
         this.resultListener = resultListener;
     }
 
+    @Override
+    public void setIsPostProcessResult(boolean isPostProcessResult) {
+        this.isPostProcess = isPostProcessResult;
+    }
+
     @Override
     public OS getOs() {
         return this.os;
@@ -90,4 +96,9 @@ public List<MethodImpl> getAnalysisGeneralPropagators() {
     public AnalysisResultListener getListener() {
         return this.resultListener;
     }
+
+    @Override
+    public boolean isPostProcessResult() {
+        return isPostProcess;
+    }
 }

de.fraunhofer.iem.secucheck.analysis.implementation/src/main/java/de/fraunhofer/iem/secucheck/analysis/implementation/SingleFlowTaintAnalysis/BoomerangSolver/BoomerangSingleFlowAnalysis.java

@@ -9,11 +9,9 @@
 import de.fraunhofer.iem.secucheck.analysis.SingleFlowAnalysis.SingleFlowAnalysis;
 import de.fraunhofer.iem.secucheck.analysis.configuration.SecucheckAnalysisConfiguration;
 import de.fraunhofer.iem.secucheck.analysis.datastructures.DifferentTypedPair;
-import de.fraunhofer.iem.secucheck.analysis.datastructures.SameTypedPair;
 import de.fraunhofer.iem.secucheck.analysis.implementation.SingleFlowTaintAnalysis.BoomerangSolver.guided.SecucheckBoomerangDemandDrivenAnalysis;
 import de.fraunhofer.iem.secucheck.analysis.query.TaintFlow;
 import de.fraunhofer.iem.secucheck.analysis.query.TaintFlowImpl;
-import de.fraunhofer.iem.secucheck.analysis.result.LocationDetails;
 import de.fraunhofer.iem.secucheck.analysis.result.SingleTaintFlowAnalysisResult;
 import de.fraunhofer.iem.secucheck.analysis.result.TaintFlowResult;
 import soot.PackManager;

de.fraunhofer.iem.secucheck.analysis.implementation/src/main/java/de/fraunhofer/iem/secucheck/analysis/implementation/SingleFlowTaintAnalysis/BoomerangSolver/guided/BoomerangGPHandler.java

@@ -243,44 +243,53 @@ public Collection<Query> onForwardFlow(ForwardQuery query, ControlFlowGraph.Edge
         Statement stmt = dataFlowEdge.getStart();
         ArrayList<Query> out = new ArrayList<Query>();
 
-        //TODO: check isPostProcessing enabled
-        BoomerangTaintFlowPath parentNode = (BoomerangTaintFlowPath) TaintFlowPathUtility.findNodeUsingDFS(tempPath, query);
+        BoomerangTaintFlowPath parentNode = null;
+        if (secucheckAnalysisConfiguration.isPostProcessResult()) {
+            parentNode = (BoomerangTaintFlowPath) TaintFlowPathUtility.findNodeUsingDFS(tempPath, query);
+        }
 
         if (stmt.containsInvokeExpr()) {
             BackwardQuery sinkQuery = isSink(stmt, dataFlowEdge, dataFlowVal);
             if (sinkQuery != null) {
-                //TODO: check isPostProcessing enabled
-                BoomerangTaintFlowPath finalSinkNode = new BoomerangTaintFlowPath(
-                        sinkQuery, parentNode, false, true);
-                parentNode.addNewChild(finalSinkNode);
-                BoomerangTaintFlowPath singleTaintFlowPath = TaintFlowPathUtility.createSinglePathFromRootNode(finalSinkNode);
+                BoomerangTaintFlowPath singleTaintFlowPath = null;
+                if (secucheckAnalysisConfiguration.isPostProcessResult()) {
+                    BoomerangTaintFlowPath finalSinkNode = new BoomerangTaintFlowPath(
+                            sinkQuery, parentNode, false, true);
+                    parentNode.addNewChild(finalSinkNode);
+                    singleTaintFlowPath = TaintFlowPathUtility.createSinglePathFromRootNode(finalSinkNode);
+                }
+
                 DifferentTypedPair<BackwardQuery, BoomerangTaintFlowPath> res = new DifferentTypedPair<>(sinkQuery, singleTaintFlowPath);
                 foundSinks.add(res);
                 return Collections.emptyList();
             }
 
             Collection<Query> prop = isPropogator(singleFlow.getThrough(), stmt, dataFlowEdge, dataFlowVal);
 
-            for (Query propQuery : prop) {
-                //TODO: check isPostProcessing enabled
-                BoomerangTaintFlowPath finalSinkNode = new BoomerangTaintFlowPath(
-                        propQuery, parentNode, false, false);
-                parentNode.addNewChild(finalSinkNode);
-                out.add(propQuery);
+            if (secucheckAnalysisConfiguration.isPostProcessResult()) {
+                for (Query propQuery : prop) {
+                    BoomerangTaintFlowPath finalSinkNode = new BoomerangTaintFlowPath(
+                            propQuery, parentNode, false, false);
+                    parentNode.addNewChild(finalSinkNode);
+                }
             }
 
+            out.addAll(prop);
+
             if (out.size() > 0)
                 return out;
 
             Collection<Query> generalProp = isPropogator(secucheckAnalysisConfiguration.getAnalysisGeneralPropagators(), stmt, dataFlowEdge, dataFlowVal);
 
-            for (Query generalPropQuery : generalProp) {
-                //TODO: check isPostProcessing enabled
-                BoomerangTaintFlowPath finalSinkNode = new BoomerangTaintFlowPath(
-                        generalPropQuery, parentNode, false, false);
-                parentNode.addNewChild(finalSinkNode);
-                out.add(generalPropQuery);
+            if (secucheckAnalysisConfiguration.isPostProcessResult()) {
+                for (Query generalPropQuery : generalProp) {
+                    BoomerangTaintFlowPath finalSinkNode = new BoomerangTaintFlowPath(
+                            generalPropQuery, parentNode, false, false);
+                    parentNode.addNewChild(finalSinkNode);
+                }
             }
+
+            out.addAll(generalProp);
         }
 
         return out;

de.fraunhofer.iem.secucheck.analysis.implementation/src/main/java/de/fraunhofer/iem/secucheck/analysis/implementation/SingleFlowTaintAnalysis/BoomerangSolver/guided/SecucheckBoomerangDemandDrivenAnalysis.java

@@ -63,10 +63,11 @@ public List<DifferentTypedPair<TaintFlowImpl, SingleTaintFlowAnalysisResult>> ru
 
             for (DifferentTypedPair<BackwardQuery, BoomerangTaintFlowPath> sinkNode : boomerangGPHandler.getFoundSinks()) {
                 BackwardQuery sink = sinkNode.getFirst();
-                TaintFlowPathUtility.print(sinkNode.getSecond());
+                
                 SingleTaintFlowAnalysisResult res = new SingleTaintFlowAnalysisResult(
                         new DifferentTypedPair<>(singleFlow, getLocationDetailsPair(source, sink)),
-                        sinkNode.getSecond()
+                        sinkNode.getSecond(),
+                        secucheckAnalysisConfiguration.isPostProcessResult()
                 );
                 reachMap.add(new DifferentTypedPair<>(singleFlow, res));
             }

de.fraunhofer.iem.secucheck.analysis.implementation/src/main/java/de/fraunhofer/iem/secucheck/analysis/implementation/SingleFlowTaintAnalysis/FlowDroidSolver/FlowDroidSingleFlowAnalysis.java

@@ -156,7 +156,8 @@ public TaintFlowResult run() throws Exception {
                     SameTypedPair<LocationDetails> locationPair = getLocationDetailsPair(singleFlow, dataFlowResult);
                     SingleTaintFlowAnalysisResult res = new SingleTaintFlowAnalysisResult(
                             new DifferentTypedPair<>(singleFlow, locationPair),
-                            null
+                            null,
+                            false
                     );
                     reachMap.add(new DifferentTypedPair<>(singleFlow, res));
                 }
@@ -219,7 +220,10 @@ public TaintFlowResult run() throws Exception {
 
                         originalReachMap.add(new
                                 DifferentTypedPair<TaintFlowImpl, SingleTaintFlowAnalysisResult>
-                                (singleFlow, new SingleTaintFlowAnalysisResult(new DifferentTypedPair<>(singleFlow, stichedPair), null)));
+                                (singleFlow, new SingleTaintFlowAnalysisResult(
+                                        new DifferentTypedPair<>(singleFlow, stichedPair),
+                                        null,
+                                        false)));
                     }
                 }
 

de.fraunhofer.iem.secucheck.analysis.result/src/main/java/de/fraunhofer/iem/secucheck/analysis/result/SingleTaintFlowAnalysisResult.java

@@ -12,13 +12,16 @@
  */
 public class SingleTaintFlowAnalysisResult {
     private final DifferentTypedPair<TaintFlowImpl, SameTypedPair<LocationDetails>> resultMap;
+    private final boolean isTaintFlowPathIncluded;
     private final TaintFlowPath path;
 
     public SingleTaintFlowAnalysisResult(
             DifferentTypedPair<TaintFlowImpl, SameTypedPair<LocationDetails>> resultMap,
-            TaintFlowPath path) {
+            TaintFlowPath path,
+            boolean isTaintFlowPathIncluded) {
         this.resultMap = resultMap;
         this.path = path;
+        this.isTaintFlowPathIncluded = isTaintFlowPathIncluded;
     }
 
 
@@ -29,4 +32,8 @@ public DifferentTypedPair<TaintFlowImpl, SameTypedPair<LocationDetails>> getLoca
     public TaintFlowPath getPath() {
         return path;
     }
+
+    public boolean isTaintFlowPathIncluded() {
+        return  isTaintFlowPathIncluded;
+    }
 }