diff --git a/Test.jar b/Test.jar new file mode 100644 index 00000000..624def7f Binary files /dev/null and b/Test.jar differ diff --git a/boomerangPDS/src/main/java/boomerang/QueryGraph.java b/boomerangPDS/src/main/java/boomerang/QueryGraph.java index a41a7a6d..e4e6a826 100644 --- a/boomerangPDS/src/main/java/boomerang/QueryGraph.java +++ b/boomerangPDS/src/main/java/boomerang/QueryGraph.java @@ -94,7 +94,12 @@ public void onOutTransitionAdded( WeightedPAutomaton, W> weightedPAutomaton) { if (t.getStart() instanceof GeneratedState && callee != null) { Edge callSiteLabel = t.getLabel(); - getSolver(child).allowUnbalanced(callee, callSiteLabel); + getSolver(child) + .allowUnbalanced( + callee, + (parent instanceof BackwardQuery + ? callSiteLabel.getTarget() + : callSiteLabel.getStart())); } if (t.getTarget() instanceof GeneratedState) { getSolver(parent) diff --git a/boomerangPDS/src/main/java/boomerang/WeightedBoomerang.java b/boomerangPDS/src/main/java/boomerang/WeightedBoomerang.java index 8c226ba3..2a0a080b 100644 --- a/boomerangPDS/src/main/java/boomerang/WeightedBoomerang.java +++ b/boomerangPDS/src/main/java/boomerang/WeightedBoomerang.java @@ -623,6 +623,10 @@ public DefaultValueMap> getBackwardSol return queryToBackwardSolvers; } + public QueryGraph getQueryGraph() { + return queryGraph; + } + private final class EmptyFieldListener extends WPAStateListener>, W> { @@ -967,6 +971,85 @@ public BackwardBoomerangResults solve(BackwardQuery query, boolean timing) { query, timedout, this.queryToSolvers, backwardSolverIns, getStats(), analysisWatch); } + public BackwardBoomerangResults solveUnderScope( + BackwardQuery query, Node triggeringNode, Query parentQuery) { + if (!options.allowMultipleQueries() && solving) { + throw new RuntimeException( + "One cannot re-use the same Boomerang solver for more than one query, unless option allowMultipleQueries is enabled. If allowMultipleQueries is enabled, ensure to call unregisterAllListeners() on this instance upon termination of all queries."); + } + solving = true; + if (!analysisWatch.isRunning()) { + analysisWatch.start(); + } + boolean timedout = false; + try { + + LOGGER.trace("Starting backward analysis of: {}", query); + backwardSolve(query); + queryGraph.addEdge(parentQuery, triggeringNode, query); + this.debugOutput(); + } catch (BoomerangTimeoutException e) { + timedout = true; + LOGGER.info("Timeout ({}) of query: {} ", analysisWatch, query); + } + if (analysisWatch.isRunning()) { + analysisWatch.stop(); + } + return new BackwardBoomerangResults( + query, timedout, this.queryToSolvers, backwardSolverIns, getStats(), analysisWatch); + } + + public ForwardBoomerangResults solveUnderScope( + ForwardQuery query, Node triggeringNode, Query parentQuery) { + if (!options.allowMultipleQueries() && solving) { + throw new RuntimeException( + "One cannot re-use the same Boomerang solver for more than one query, unless option allowMultipleQueries is enabled. If allowMultipleQueries is enabled, ensure to call unregisterAllListeners() on this instance upon termination of all queries."); + } + solving = true; + if (!analysisWatch.isRunning()) { + analysisWatch.start(); + } + boolean timedout = false; + try { + LOGGER.trace("Starting forward analysis of: {}", query); + forwardSolve(query); + LOGGER.trace( + "Query terminated in {} ({}), visited methods {}", + analysisWatch, + query, + visitedMethods.size()); + queryGraph.addEdge(parentQuery, triggeringNode, query); + } catch (BoomerangTimeoutException e) { + timedout = true; + LOGGER.trace( + "Timeout ({}) of query: {}, visited methods {}", + analysisWatch, + query, + visitedMethods.size()); + } catch (Throwable e) { + LOGGER.error("Solving query crashed in {}", e); + } + if (!options.allowMultipleQueries()) { + unregisterAllListeners(); + } + + if (analysisWatch.isRunning()) { + analysisWatch.stop(); + } + return new ForwardBoomerangResults( + query, + icfg(), + cfg(), + timedout, + this.queryToSolvers, + getStats(), + analysisWatch, + visitedMethods, + options.trackDataFlowPath(), + options.prunePathConditions(), + options.trackImplicitFlows()); + } + public void debugOutput() { if (LOGGER.isTraceEnabled()) { LOGGER.trace("Query Graph \n{}", queryGraph.toDotString()); diff --git a/boomerangPDS/src/main/java/boomerang/guided/DemandDrivenGuidedAnalysis.java b/boomerangPDS/src/main/java/boomerang/guided/DemandDrivenGuidedAnalysis.java new file mode 100644 index 00000000..1b00f183 --- /dev/null +++ b/boomerangPDS/src/main/java/boomerang/guided/DemandDrivenGuidedAnalysis.java @@ -0,0 +1,302 @@ +package boomerang.guided; + +import boomerang.BackwardQuery; +import boomerang.Boomerang; +import boomerang.DefaultBoomerangOptions; +import boomerang.ForwardQuery; +import boomerang.Query; +import boomerang.QueryGraph; +import boomerang.callgraph.ObservableICFG; +import boomerang.guided.Specification.Parameter; +import boomerang.guided.Specification.QueryDirection; +import boomerang.guided.Specification.QuerySelector; +import boomerang.guided.Specification.SootMethodWithSelector; +import boomerang.results.AbstractBoomerangResults.Context; +import boomerang.results.BackwardBoomerangResults; +import boomerang.results.ForwardBoomerangResults; +import boomerang.scene.AllocVal; +import boomerang.scene.ControlFlowGraph.Edge; +import boomerang.scene.DataFlowScope; +import boomerang.scene.Method; +import boomerang.scene.SootDataFlowScope; +import boomerang.scene.Statement; +import boomerang.scene.Val; +import boomerang.scene.jimple.IntAndStringBoomerangOptions; +import boomerang.scene.jimple.JimpleStatement; +import boomerang.scene.jimple.SootCallGraph; +import boomerang.solver.ForwardBoomerangSolver; +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import com.google.common.collect.Table; +import com.google.common.collect.Table.Cell; +import java.util.Collection; +import java.util.LinkedList; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; +import soot.Scene; +import soot.jimple.Stmt; +import sync.pds.solver.nodes.Node; +import wpds.impl.Weight.NoWeight; + +public class DemandDrivenGuidedAnalysis { + + private final DefaultBoomerangOptions customBoomerangOptions; + private final Specification spec; + private final DataFlowScope scope; + private final SootCallGraph callGraph; + private final LinkedList queryQueue = Lists.newLinkedList(); + private final Set visited = Sets.newHashSet(); + + public DemandDrivenGuidedAnalysis(Specification specification) { + spec = specification; + callGraph = new SootCallGraph(); + scope = SootDataFlowScope.make(Scene.v()); + customBoomerangOptions = + new IntAndStringBoomerangOptions() { + @Override + public Optional getAllocationVal( + Method m, Statement stmt, Val fact, ObservableICFG icfg) { + if (stmt.isAssign() && stmt.getLeftOp().equals(fact) && isStringOrIntAllocation(stmt)) { + return Optional.of(new AllocVal(stmt.getLeftOp(), stmt, stmt.getRightOp())); + } + return super.getAllocationVal(m, stmt, fact, icfg); + } + + @Override + public int analysisTimeoutMS() { + return 1999999; + } + + @Override + public boolean allowMultipleQueries() { + return true; + } + }; + } + + public Collection run(Query query) { + queryQueue.add(new QueryWithContext(query)); + Boomerang bSolver = new Boomerang(callGraph, scope, customBoomerangOptions); + Collection finalAllocationSites = Sets.newHashSet(); + while (!queryQueue.isEmpty()) { + QueryWithContext pop = queryQueue.pop(); + if (pop.query instanceof ForwardQuery) { + ForwardBoomerangResults results; + ForwardQuery currentQuery = (ForwardQuery) pop.query; + if (pop.parentQuery == null) { + results = bSolver.solve(currentQuery); + } else { + results = bSolver.solveUnderScope(currentQuery, pop.triggeringNode, pop.parentQuery); + } + + Table forwardResults = + results.asStatementValWeightTable((ForwardQuery) pop.query); + // Any ForwardQuery may trigger additional ForwardQuery under its own scope. + triggerNewForwardQueries(forwardResults, currentQuery); + triggerNewBackwardQueries(forwardResults, currentQuery, QueryDirection.FORWARD); + } else { + BackwardBoomerangResults results; + if (pop.parentQuery == null) { + results = bSolver.solve((BackwardQuery) pop.query); + } else { + results = + bSolver.solveUnderScope( + (BackwardQuery) pop.query, pop.triggeringNode, pop.parentQuery); + } + Table backwardResults = + bSolver.getBackwardSolvers().get(query).asStatementValWeightTable(); + + triggerNewBackwardQueries(backwardResults, pop.query, QueryDirection.BACKWARD); + Map allocationSites = results.getAllocationSites(); + + for (Entry entry : allocationSites.entrySet()) { + ForwardQuery forwardQuery = entry.getKey(); + Statement start = forwardQuery.cfgEdge().getStart(); + if (isStringOrIntAllocation(start)) { + finalAllocationSites.add(entry.getKey()); + } + + triggerNewBackwardQueries( + results.asStatementValWeightTable(entry.getKey()), + entry.getKey(), + QueryDirection.FORWARD); + } + // Any ForwardQuery may trigger additional ForwardQuery under its own scope. + for (ForwardBoomerangSolver solver : bSolver.getSolvers().values()) { + triggerNewForwardQueries(solver.asStatementValWeightTable(), solver.getQuery()); + } + } + } + + QueryGraph queryGraph = bSolver.getQueryGraph(); + System.out.println(queryGraph.toDotString()); + bSolver.unregisterAllListeners(); + return finalAllocationSites; + } + + private void triggerNewBackwardQueries( + Table backwardResults, Query lastQuery, QueryDirection direction) { + for (Cell cell : backwardResults.cellSet()) { + Edge triggeringEdge = cell.getRowKey(); + Statement stmt = triggeringEdge.getStart(); + Val fact = cell.getColumnKey(); + if (stmt.containsInvokeExpr()) { + Set selectors = + spec.getMethodAndQueries().stream() + .filter(x -> isInOnList(x, stmt, fact, direction)) + .collect(Collectors.toSet()); + for (SootMethodWithSelector sel : selectors) { + Collection queries = createNewQueries(sel, stmt); + for (Query q : queries) { + addToQueue(new QueryWithContext(q, new Node<>(triggeringEdge, fact), lastQuery)); + } + } + } + } + } + + private Collection createNewQueries(SootMethodWithSelector sel, Statement stmt) { + Set results = Sets.newHashSet(); + Method method = stmt.getMethod(); + for (QuerySelector qSel : sel.getGo()) { + Optional parameterVal = getParameterVal(stmt, qSel.argumentSelection); + if (parameterVal.isPresent()) { + if (qSel.direction == QueryDirection.BACKWARD) { + for (Statement pred : method.getControlFlowGraph().getPredsOf(stmt)) { + results.add(BackwardQuery.make(new Edge(pred, stmt), parameterVal.get())); + } + } else if (qSel.direction == QueryDirection.FORWARD) { + for (Statement succ : method.getControlFlowGraph().getSuccsOf(stmt)) { + results.add( + new ForwardQuery( + new Edge(stmt, succ), + new AllocVal(parameterVal.get(), stmt, parameterVal.get()))); + } + } + } + } + return results; + } + + public boolean isInOnList( + SootMethodWithSelector methodSelector, Statement stmt, Val fact, QueryDirection direction) { + if (stmt instanceof JimpleStatement) { + // This only works for Soot propagations + Stmt jimpleStmt = ((JimpleStatement) stmt).getDelegate(); + if (jimpleStmt + .getInvokeExpr() + .getMethod() + .getSignature() + .equals(methodSelector.getSootMethod())) { + Collection on = methodSelector.getOn(); + return isInList(on, direction, stmt, fact); + } + } + return false; + } + + private boolean isInList( + Collection list, QueryDirection direction, Statement stmt, Val fact) { + return list.stream() + .anyMatch( + sel -> (sel.direction == direction && isParameter(stmt, fact, sel.argumentSelection))); + } + + private boolean isParameter(Statement stmt, Val fact, Parameter argumentSelection) { + if (stmt.getInvokeExpr().isInstanceInvokeExpr() && argumentSelection.equals(Parameter.base())) { + return stmt.getInvokeExpr().getBase().equals(fact); + } + if (argumentSelection.equals(Parameter.returnParam())) { + return stmt.isAssign() && stmt.getLeftOp().equals(fact); + } + return stmt.getInvokeExpr().getArgs().size() > argumentSelection.getValue() + && argumentSelection.getValue() >= 0 + && stmt.getInvokeExpr().getArg(argumentSelection.getValue()).equals(fact); + } + + private Optional getParameterVal(Statement stmt, Parameter selector) { + if (stmt.containsInvokeExpr() + && !stmt.getInvokeExpr().isStaticInvokeExpr() + && selector.equals(Parameter.base())) { + return Optional.of(stmt.getInvokeExpr().getBase()); + } + if (stmt.isAssign() && selector.equals(Parameter.returnParam())) { + return Optional.of(stmt.getLeftOp()); + } + if (stmt.getInvokeExpr().getArgs().size() > selector.getValue() && selector.getValue() >= 0) { + return Optional.of(stmt.getInvokeExpr().getArg(selector.getValue())); + } + return Optional.empty(); + } + + private void triggerNewForwardQueries( + Table forwardResults, Query currentQuery) { + for (Cell cell : forwardResults.cellSet()) { + Val reachingVariable = cell.getColumnKey(); + Edge edge = cell.getRowKey(); + Collection newQueries = createNextQuery(edge, reachingVariable); + for (Query newQuery : newQueries) { + addToQueue( + new QueryWithContext(newQuery, new Node<>(edge, reachingVariable), currentQuery)); + } + } + } + + private void addToQueue(QueryWithContext nextQuery) { + if (visited.add(nextQuery.query)) { + queryQueue.add(nextQuery); + } + } + + private boolean isStringOrIntAllocation(Statement stmt) { + return stmt.isAssign() + && (stmt.getRightOp().isIntConstant() || stmt.getRightOp().isStringConstant()); + } + + private boolean isInSourceList(Statement stmt) { + return stmt.getInvokeExpr() + .getMethod() + .getDeclaringClass() + .getFullyQualifiedName() + .equals("java.lang.String") + && stmt.getInvokeExpr().getMethod().getName().equals(""); + } + + private Collection createNextQuery(Edge edge, Val reachingVariable) { + Statement potentialCallSite = edge.getTarget(); + Method method = potentialCallSite.getMethod(); + if (potentialCallSite.containsInvokeExpr() && isInSourceList(potentialCallSite)) { + if (potentialCallSite.getInvokeExpr().getArgs().contains(reachingVariable)) { + Set res = Sets.newHashSet(); + for (Statement succ : method.getControlFlowGraph().getSuccsOf(potentialCallSite)) { + Val base = potentialCallSite.getInvokeExpr().getBase(); + res.add( + new ForwardQuery( + new Edge(potentialCallSite, succ), new AllocVal(base, potentialCallSite, base))); + } + + return res; + } + } + return Sets.newHashSet(); + } + + private static class QueryWithContext { + private QueryWithContext(Query query) { + this.query = query; + } + + private QueryWithContext(Query query, Node triggeringNode, Query parentQuery) { + this.query = query; + this.parentQuery = parentQuery; + this.triggeringNode = triggeringNode; + } + + Query query; + Query parentQuery; + Node triggeringNode; + } +} diff --git a/boomerangPDS/src/main/java/boomerang/guided/Specification.java b/boomerangPDS/src/main/java/boomerang/guided/Specification.java new file mode 100644 index 00000000..a59e45dc --- /dev/null +++ b/boomerangPDS/src/main/java/boomerang/guided/Specification.java @@ -0,0 +1,188 @@ +package boomerang.guided; + +import com.google.common.base.Objects; +import com.google.common.collect.Sets; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.Collection; +import java.util.Set; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.stream.Collectors; + +public class Specification { + private static final String ON_SELECTOR = "ON"; + private static final String GO_SELECTOR = "GO"; + private static final String BACKWARD = "{B}"; + private static final String FORWARD = "{F}"; + + public enum QueryDirection { + FORWARD, + BACKWARD + } + + private final Set methodAndQueries; + + private Specification(Collection spec) { + methodAndQueries = spec.stream().map(x -> parse(x)).collect(Collectors.toSet()); + } + + private SootMethodWithSelector parse(String input) { + Pattern arguments = Pattern.compile("\\((.*?)\\)"); + Matcher argumentMatcher = arguments.matcher(input); + Set on = Sets.newHashSet(); + Set go = Sets.newHashSet(); + + // Handle arguments + if (argumentMatcher.find()) { + String group = argumentMatcher.group(1); + String[] args = group.split(","); + for (int i = 0; i < args.length; i++) { + createQuerySelector(args[i], Parameter.of(i), on, go); + } + } + + // Handle base variable + Pattern base = Pattern.compile("<(.*?):"); + Matcher baseMatcher = base.matcher(input); + if (baseMatcher.find()) { + String group = baseMatcher.group(1); + createQuerySelector(group, Parameter.base(), on, go); + } + + // Handle return + String[] s = input.split(" "); + createQuerySelector(s[1], Parameter.returnParam(), on, go); + + String sootMethod = + input + .replace(FORWARD, "") + .replace(BACKWARD, "") + .replace(ON_SELECTOR, "") + .replace(GO_SELECTOR, ""); + + // Assert parsing successful + long backwardQueryCount = + on.stream().filter(x -> x.direction == QueryDirection.BACKWARD).count() + + go.stream().filter(x -> x.direction == QueryDirection.BACKWARD).count(); + long forwardQueryCount = + on.stream().filter(x -> x.direction == QueryDirection.FORWARD).count() + + go.stream().filter(x -> x.direction == QueryDirection.FORWARD).count(); + if (input.length() + != sootMethod.length() + + (on.size() * ON_SELECTOR.length() + + go.size() * GO_SELECTOR.length() + + backwardQueryCount * BACKWARD.length() + + forwardQueryCount * FORWARD.length())) { + throw new RuntimeException("Parsing Specification failed. Please check your specification"); + } + + return new SootMethodWithSelector(sootMethod, on, go); + } + + private void createQuerySelector( + String arg, Parameter p, Set on, Set go) { + if (arg.startsWith(ON_SELECTOR)) { + on.add( + new QuerySelector( + arg.contains(FORWARD) ? QueryDirection.FORWARD : QueryDirection.BACKWARD, p)); + } + if (arg.startsWith(GO_SELECTOR)) { + go.add( + new QuerySelector( + arg.contains(FORWARD) ? QueryDirection.FORWARD : QueryDirection.BACKWARD, p)); + } + } + + public static class SootMethodWithSelector { + SootMethodWithSelector( + String sootMethod, Collection on, Collection go) { + this.sootMethod = sootMethod; + this.on = on; + this.go = go; + } + + private String sootMethod; + private Collection on; + private Collection go; + + public Collection getOn() { + return on; + } + + public Collection getGo() { + return go; + } + + public String getSootMethod() { + return sootMethod; + } + } + + public static class Parameter { + private final int value; + + private Parameter(final int newValue) { + value = newValue; + } + + public static Parameter returnParam() { + return new Parameter(-2); + } + + public static Parameter base() { + return new Parameter(-1); + } + + public static Parameter of(int integer) { + if (integer < 0) { + throw new RuntimeException("Parameter index must be > 0"); + } + return new Parameter(integer); + } + + public int getValue() { + return value; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + Parameter parameter = (Parameter) o; + return value == parameter.value; + } + + @Override + public int hashCode() { + return Objects.hashCode(value); + } + } + + public class QuerySelector { + QuerySelector(QueryDirection direction, Parameter argumentSelection) { + this.direction = direction; + this.argumentSelection = argumentSelection; + } + + QueryDirection direction; + Parameter argumentSelection; + } + + public static Specification loadFrom(String filePath) throws IOException { + return new Specification(Files.lines(Paths.get(filePath)).collect(Collectors.toSet())); + } + + public static Specification create(String... spec) { + return new Specification(Sets.newHashSet(spec)); + } + + public Set getMethodAndQueries() { + return methodAndQueries; + } +} diff --git a/boomerangPDS/src/main/java/boomerang/results/AbstractBoomerangResults.java b/boomerangPDS/src/main/java/boomerang/results/AbstractBoomerangResults.java index cbc84c63..7146b738 100644 --- a/boomerangPDS/src/main/java/boomerang/results/AbstractBoomerangResults.java +++ b/boomerangPDS/src/main/java/boomerang/results/AbstractBoomerangResults.java @@ -7,10 +7,7 @@ import boomerang.solver.AbstractBoomerangSolver; import boomerang.solver.ForwardBoomerangSolver; import boomerang.util.DefaultValueMap; -import com.google.common.base.Stopwatch; -import com.google.common.collect.HashBasedTable; import com.google.common.collect.Table; -import java.util.Map.Entry; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import sync.pds.solver.nodes.GeneratedState; @@ -62,22 +59,7 @@ public void computeUnmatchedOpeningContext( } public Table asStatementValWeightTable(ForwardQuery query) { - final Table results = HashBasedTable.create(); - Stopwatch sw = Stopwatch.createStarted(); - LOGGER.trace("Computing final weighted results for {}", query); - WeightedPAutomaton, W> callAut = - queryToSolvers.getOrCreate(query).getCallAutomaton(); - for (Entry>, W> e : - callAut.getTransitionsToFinalWeights().entrySet()) { - Transition> t = e.getKey(); - W w = e.getValue(); - if (t.getLabel().equals(new Edge(Statement.epsilon(), Statement.epsilon()))) continue; - if (t.getStart().fact().isLocal() - && !t.getLabel().getMethod().equals(t.getStart().fact().m())) continue; - results.put(t.getLabel(), t.getStart().fact(), w); - } - LOGGER.trace("Computed final weighted results for {} in {}", query, sw); - return results; + return queryToSolvers.getOrCreate(query).asStatementValWeightTable(); } private static class OpeningCallStackExtracter diff --git a/boomerangPDS/src/main/java/boomerang/results/BackwardBoomerangResults.java b/boomerangPDS/src/main/java/boomerang/results/BackwardBoomerangResults.java index 22fa7874..af9b76a0 100644 --- a/boomerangPDS/src/main/java/boomerang/results/BackwardBoomerangResults.java +++ b/boomerangPDS/src/main/java/boomerang/results/BackwardBoomerangResults.java @@ -5,7 +5,6 @@ import boomerang.Query; import boomerang.Util; import boomerang.scene.ControlFlowGraph.Edge; -import boomerang.scene.Field; import boomerang.scene.Statement; import boomerang.scene.Type; import boomerang.scene.Val; @@ -20,7 +19,6 @@ import java.util.Map; import java.util.Map.Entry; import java.util.Set; -import sync.pds.solver.nodes.GeneratedState; import sync.pds.solver.nodes.INode; import sync.pds.solver.nodes.Node; import wpds.impl.Transition; @@ -99,14 +97,8 @@ protected void allocationSiteFound( public boolean aliases(Query el) { for (final ForwardQuery fw : getAllocationSites().keySet()) { if (queryToSolvers.getOrCreate(fw).getReachedStates().contains(el.asNode())) { - for (Transition>> t : - queryToSolvers.getOrCreate(fw).getFieldAutomaton().getTransitions()) { - if (t.getStart() instanceof GeneratedState) { - continue; - } - if (t.getStart().fact().equals(el.asNode()) && t.getLabel().equals(Field.empty())) { - return true; - } + if (queryToSolvers.getOrCreate(fw).reachesNodeWithEmptyField(el.asNode())) { + return true; } } } diff --git a/boomerangPDS/src/main/java/boomerang/solver/AbstractBoomerangSolver.java b/boomerangPDS/src/main/java/boomerang/solver/AbstractBoomerangSolver.java index 690dba9a..ea823fa0 100644 --- a/boomerangPDS/src/main/java/boomerang/solver/AbstractBoomerangSolver.java +++ b/boomerangPDS/src/main/java/boomerang/solver/AbstractBoomerangSolver.java @@ -17,8 +17,6 @@ import boomerang.callgraph.CallerListener; import boomerang.callgraph.ObservableICFG; import boomerang.controlflowgraph.ObservableControlFlowGraph; -import boomerang.controlflowgraph.PredecessorListener; -import boomerang.controlflowgraph.SuccessorListener; import boomerang.scene.AllocVal; import boomerang.scene.ControlFlowGraph; import boomerang.scene.ControlFlowGraph.Edge; @@ -29,6 +27,7 @@ import boomerang.scene.Type; import boomerang.scene.Val; import boomerang.util.RegExAccessPath; +import com.google.common.base.Stopwatch; import com.google.common.collect.HashBasedTable; import com.google.common.collect.HashMultimap; import com.google.common.collect.Lists; @@ -132,6 +131,18 @@ public AbstractBoomerangSolver( this.generatedFieldState = genField; } + public boolean reachesNodeWithEmptyField(Node node) { + for (Transition>> t : getFieldAutomaton().getTransitions()) { + if (t.getStart() instanceof GeneratedState) { + continue; + } + if (t.getStart().fact().equals(node) && t.getLabel().equals(Field.empty())) { + return true; + } + } + return false; + } + private class UnbalancedListener implements WPAUpdateListener, W> { @@ -220,6 +231,22 @@ public void synchedReachable( }); } + public Table asStatementValWeightTable() { + final Table results = HashBasedTable.create(); + Stopwatch sw = Stopwatch.createStarted(); + WeightedPAutomaton, W> callAut = getCallAutomaton(); + for (Entry>, W> e : + callAut.getTransitionsToFinalWeights().entrySet()) { + Transition> t = e.getKey(); + W w = e.getValue(); + if (t.getLabel().equals(new Edge(Statement.epsilon(), Statement.epsilon()))) continue; + if (t.getStart().fact().isLocal() + && !t.getLabel().getMethod().equals(t.getStart().fact().m())) continue; + results.put(t.getLabel(), t.getStart().fact(), w); + } + return results; + } + protected void addPotentialUnbalancedFlow( Method callee, Transition> trans, W weight) { if (unbalancedDataFlows.put(callee, new UnbalancedDataFlow<>(callee, trans))) { @@ -241,23 +268,7 @@ public Method getObservedCallee() { @Override public void onCallerAdded(Statement n, Method m) { - if (AbstractBoomerangSolver.this instanceof ForwardBoomerangSolver) { - cfg.addPredsOfListener( - new PredecessorListener(n) { - @Override - public void getPredecessor(Statement pred) { - propagateUnbalancedToCallSite(new Edge(pred, n), trans); - } - }); - } else if (AbstractBoomerangSolver.this instanceof BackwardBoomerangSolver) { - cfg.addSuccsOfListener( - new SuccessorListener(n) { - @Override - public void getSuccessor(Statement succ) { - propagateUnbalancedToCallSite(new Edge(n, succ), trans); - } - }); - } + propagateUnbalancedToCallSite(n, trans); } }); } @@ -267,22 +278,40 @@ protected boolean forceUnbalanced(INode iNode, Collection> colle return false; } - public void allowUnbalanced(Method callee, Edge callSiteEdge) { + public void allowUnbalanced(Method callee, Statement callSite) { if (dataFlowScope.isExcluded(callee)) { return; } - UnbalancedDataFlowListener l = new UnbalancedDataFlowListener(callee, callSiteEdge); + UnbalancedDataFlowListener l = new UnbalancedDataFlowListener(callee, callSite); if (unbalancedDataFlowListeners.put(callee, l)) { - LOGGER.trace( - "Allowing unbalanced propagation from {} to {} of {}", callee, callSiteEdge, this); + LOGGER.trace("Allowing unbalanced propagation from {} to {} of {}", callee, callSite, this); for (UnbalancedDataFlow e : Lists.newArrayList(unbalancedDataFlows.get(callee))) { - propagateUnbalancedToCallSite(callSiteEdge, e.getReturningTransition()); + propagateUnbalancedToCallSite(callSite, e.getReturningTransition()); } } } + protected void assertCalleeCallerRelation(Statement callSite, Method method) { + Set callsitesOfCall = Sets.newHashSet(); + icfg.addCallerListener( + new CallerListener() { + @Override + public Method getObservedCallee() { + return method; + } + + @Override + public void onCallerAdded(Statement statement, Method method) { + callsitesOfCall.add(statement); + } + }); + if (!callsitesOfCall.contains(callSite)) { + throw new RuntimeException("Invalid pair of callSite and method for unbalanced return"); + } + } + protected abstract void propagateUnbalancedToCallSite( - Edge callSiteEdge, Transition> transInCallee); + Statement callSiteEdge, Transition> transInCallee); @Override protected boolean preventCallTransitionAdd( @@ -623,14 +652,14 @@ public boolean equals(Object obj) { private static class UnbalancedDataFlowListener { private Method callee; - private Edge callSite; + private Statement callSite; - public UnbalancedDataFlowListener(Method callee, Edge callSite) { + public UnbalancedDataFlowListener(Method callee, Statement callSite) { this.callee = callee; this.callSite = callSite; } - public Edge getCallSiteEdge() { + public Statement getCallSiteEdge() { return callSite; } diff --git a/boomerangPDS/src/main/java/boomerang/solver/BackwardBoomerangSolver.java b/boomerangPDS/src/main/java/boomerang/solver/BackwardBoomerangSolver.java index 45f8021f..0b788f3e 100644 --- a/boomerangPDS/src/main/java/boomerang/solver/BackwardBoomerangSolver.java +++ b/boomerangPDS/src/main/java/boomerang/solver/BackwardBoomerangSolver.java @@ -17,6 +17,7 @@ import boomerang.callgraph.ObservableICFG; import boomerang.controlflowgraph.ObservableControlFlowGraph; import boomerang.controlflowgraph.PredecessorListener; +import boomerang.controlflowgraph.SuccessorListener; import boomerang.scene.AllocVal; import boomerang.scene.ControlFlowGraph; import boomerang.scene.ControlFlowGraph.Edge; @@ -50,6 +51,7 @@ import wpds.impl.NestedWeightedPAutomatons; import wpds.impl.Transition; import wpds.impl.Weight; +import wpds.interfaces.Location; import wpds.interfaces.State; public abstract class BackwardBoomerangSolver extends AbstractBoomerangSolver { @@ -227,6 +229,18 @@ protected Collection computeCallFlow( return out; } + @Override + public void processPush( + Node curr, Location location, PushNode succ, PDSSystem system) { + if (PDSSystem.CALLS == system) { + if (!((PushNode) succ).location().getTarget().equals(curr.stmt().getStart()) + || !(curr.stmt().getStart().containsInvokeExpr())) { + throw new RuntimeException("Invalid push rule"); + } + } + super.processPush(curr, location, succ, system); + } + @Override protected Collection computeNormalFlow(Method method, Edge currEdge, Val fact) { // BW data-flow inverses, therefore we @@ -335,30 +349,42 @@ public void applyCallSummary( @Override protected void propagateUnbalancedToCallSite( - Edge callSite, Transition> transInCallee) { + Statement callSite, Transition> transInCallee) { GeneratedState target = (GeneratedState) transInCallee.getTarget(); - cfg.addPredsOfListener( - new PredecessorListener(callSite.getStart()) { + + if (!callSite.containsInvokeExpr()) { + throw new RuntimeException("Invalid propagate Unbalanced return"); + } + assertCalleeCallerRelation(callSite, transInCallee.getLabel().getMethod()); + cfg.addSuccsOfListener( + new SuccessorListener(callSite) { @Override - public void getPredecessor(Statement pred) { - Node curr = new Node<>(callSite, query.var()); + public void getSuccessor(Statement succ) { + cfg.addPredsOfListener( + new PredecessorListener(callSite) { + @Override + public void getPredecessor(Statement pred) { + Node curr = + new Node<>(new Edge(callSite, succ), query.var()); - Transition> callTrans = - new Transition<>( - wrap(curr.fact()), - curr.stmt(), - generateCallState(wrap(curr.fact()), curr.stmt())); - callAutomaton.addTransition(callTrans); - callAutomaton.addUnbalancedState( - generateCallState(wrap(curr.fact()), curr.stmt()), target); + Transition> callTrans = + new Transition<>( + wrap(curr.fact()), + curr.stmt(), + generateCallState(wrap(curr.fact()), curr.stmt())); + callAutomaton.addTransition(callTrans); + callAutomaton.addUnbalancedState( + generateCallState(wrap(curr.fact()), curr.stmt()), target); - State s = - new PushNode<>( - target.location(), - target.node().fact(), - new Edge(pred, callSite.getStart()), - PDSSystem.CALLS); - propagate(curr, s); + State s = + new PushNode<>( + target.location(), + target.node().fact(), + new Edge(pred, callSite), + PDSSystem.CALLS); + propagate(curr, s); + } + }); } }); } diff --git a/boomerangPDS/src/main/java/boomerang/solver/ForwardBoomerangSolver.java b/boomerangPDS/src/main/java/boomerang/solver/ForwardBoomerangSolver.java index cbeddd70..014c429f 100644 --- a/boomerangPDS/src/main/java/boomerang/solver/ForwardBoomerangSolver.java +++ b/boomerangPDS/src/main/java/boomerang/solver/ForwardBoomerangSolver.java @@ -17,6 +17,7 @@ import boomerang.callgraph.CalleeListener; import boomerang.callgraph.ObservableICFG; import boomerang.controlflowgraph.ObservableControlFlowGraph; +import boomerang.controlflowgraph.PredecessorListener; import boomerang.controlflowgraph.SuccessorListener; import boomerang.scene.AllocVal; import boomerang.scene.ControlFlowGraph; @@ -50,6 +51,7 @@ import wpds.impl.Transition; import wpds.impl.Weight; import wpds.impl.WeightedPAutomaton; +import wpds.interfaces.Location; import wpds.interfaces.State; import wpds.interfaces.WPAStateListener; @@ -82,6 +84,18 @@ public ForwardBoomerangSolver( this.query = query; } + @Override + public void processPush( + Node curr, Location location, PushNode succ, PDSSystem system) { + if (PDSSystem.CALLS == system) { + if (!((PushNode) succ).location().getStart().equals(curr.stmt().getTarget()) + || !curr.stmt().getTarget().containsInvokeExpr()) { + throw new RuntimeException("Invalid push rule"); + } + } + super.processPush(curr, location, succ, system); + } + private final class OverwriteAtFieldStore extends WPAStateListener>, W> { private final Edge nextStmt; @@ -190,33 +204,44 @@ private ForwardBoomerangSolver getEnclosingInstance() { @Override protected void propagateUnbalancedToCallSite( - Edge callSiteEdge, Transition> transInCallee) { + Statement callSite, Transition> transInCallee) { GeneratedState target = (GeneratedState) transInCallee.getTarget(); + if (!callSite.containsInvokeExpr()) { + throw new RuntimeException("Invalid propagate Unbalanced return"); + } + assertCalleeCallerRelation(callSite, transInCallee.getLabel().getMethod()); cfg.addSuccsOfListener( - new SuccessorListener(callSiteEdge.getTarget()) { + new SuccessorListener(callSite) { @Override public void getSuccessor(Statement succ) { - Node curr = new Node<>(callSiteEdge, query.var()); - /** - * Transition>> fieldTrans = new Transition<>(new - * SingleNode<>(curr), emptyField(), new SingleNode<>(curr)); - * fieldAutomaton.addTransition(fieldTrans);* - */ - Transition> callTrans = - new Transition<>( - wrap(curr.fact()), - curr.stmt(), - generateCallState(wrap(curr.fact()), curr.stmt())); - callAutomaton.addTransition(callTrans); - callAutomaton.addUnbalancedState( - generateCallState(wrap(curr.fact()), curr.stmt()), target); - State s = - new PushNode<>( - target.location(), - target.node().fact(), - new Edge(callSiteEdge.getTarget(), succ), - PDSSystem.CALLS); - propagate(curr, s); + cfg.addPredsOfListener( + new PredecessorListener(callSite) { + @Override + public void getPredecessor(Statement pred) { + Node curr = + new Node<>(new Edge(pred, callSite), query.var()); + /** + * Transition>> fieldTrans = new + * Transition<>(new SingleNode<>(curr), emptyField(), new SingleNode<>(curr)); + * fieldAutomaton.addTransition(fieldTrans);* + */ + Transition> callTrans = + new Transition<>( + wrap(curr.fact()), + curr.stmt(), + generateCallState(wrap(curr.fact()), curr.stmt())); + callAutomaton.addTransition(callTrans); + callAutomaton.addUnbalancedState( + generateCallState(wrap(curr.fact()), curr.stmt()), target); + State s = + new PushNode<>( + target.location(), + target.node().fact(), + new Edge(callSite, succ), + PDSSystem.CALLS); + propagate(curr, s); + } + }); } }); } diff --git a/boomerangPDS/src/main/resources/log4j.properties b/boomerangPDS/src/main/resources/log4j.properties index d2e7a621..cdc20f7f 100644 --- a/boomerangPDS/src/main/resources/log4j.properties +++ b/boomerangPDS/src/main/resources/log4j.properties @@ -3,6 +3,10 @@ log4j.rootLogger=info, A1 # A1 is set to be a ConsoleAppender. log4j.appender.A1=org.apache.log4j.ConsoleAppender +#log4j.category.boomerang.WeightedBoomerang=TRACE +#log4j.category.boomerang.scene.jimple.SootCallGraph=TRACE + + # A1 uses PatternLayout. log4j.appender.A1.layout=org.apache.log4j.PatternLayout diff --git a/boomerangPDS/src/test/java/boomerang/guided/DemandDrivenGuidedAnalysisTest.java b/boomerangPDS/src/test/java/boomerang/guided/DemandDrivenGuidedAnalysisTest.java new file mode 100644 index 00000000..9009ed80 --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/DemandDrivenGuidedAnalysisTest.java @@ -0,0 +1,301 @@ +package boomerang.guided; + +import boomerang.BackwardQuery; +import boomerang.ForwardQuery; +import boomerang.guided.targets.BasicTarget; +import boomerang.guided.targets.BranchingAfterNewStringTest; +import boomerang.guided.targets.BranchingTest; +import boomerang.guided.targets.ContextSensitiveTarget; +import boomerang.guided.targets.LeftUnbalancedTarget; +import boomerang.guided.targets.NestedContextAndBranchingTarget; +import boomerang.guided.targets.NestedContextTarget; +import boomerang.guided.targets.PingPongInterproceduralTarget; +import boomerang.guided.targets.PingPongTarget; +import boomerang.guided.targets.WrappedInNewStringInnerTarget; +import boomerang.guided.targets.WrappedInNewStringTarget; +import boomerang.guided.targets.WrappedInStringTwiceTest; +import boomerang.scene.AllocVal; +import boomerang.scene.ControlFlowGraph.Edge; +import boomerang.scene.Method; +import boomerang.scene.Statement; +import boomerang.scene.Val; +import boomerang.scene.jimple.BoomerangPretransformer; +import boomerang.scene.jimple.JimpleMethod; +import boomerang.guided.targets.ContextSensitiveAndLeftUnbalancedTarget; +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Collection; +import java.util.List; +import java.util.stream.Collectors; +import org.junit.Assert; +import org.junit.Ignore; +import org.junit.Test; +import soot.G; +import soot.PackManager; +import soot.Scene; +import soot.SootClass; +import soot.SootMethod; +import soot.options.Options; + +public class DemandDrivenGuidedAnalysisTest { + + public static String CG = "cha"; + + @Test + public void basicTarget() { + setupSoot(BasicTarget.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(query, "bar"); + } + + @Test + @Ignore("We need additional logic to tell the analysis to continue at some unknown parent context") + public void leftUnbalancedTargetTest() { + setupSoot(LeftUnbalancedTarget.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(query, "bar"); + } + + @Test + public void contextSensitiveTest() { + setupSoot(ContextSensitiveTarget.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(query, "bar"); + } + + @Test + public void nestedContextTest() { + setupSoot(NestedContextTarget.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(query, "bar"); + } + + @Test + public void nestedContextAndBranchingTest() { + setupSoot(NestedContextAndBranchingTarget.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(query, "bar", "foo"); + } + + @Test + public void contextSensitiveAndLeftUnbalancedTest() { + setupSoot(ContextSensitiveAndLeftUnbalancedTarget.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(query, "bar"); + } + + @Test + public void wrappedInNewStringTest() { + setupSoot(WrappedInNewStringTarget.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(query, "bar"); + } + + @Test + public void wrappedInNewStringInnerTest() { + setupSoot(WrappedInNewStringInnerTarget.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(query, "bar"); + } + + @Test + public void wrappedInNewStringTwiceTest() { + setupSoot(WrappedInStringTwiceTest.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(query, "bar"); + } + + @Test + public void branchingTest() { + setupSoot(BranchingTest.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(query, "bar", "foo"); + } + + @Test + public void branchingAfterNewTest() { + setupSoot(BranchingAfterNewStringTest.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(query, "bar", "foo"); + } + + @Test + public void pingPongTest() { + setupSoot(PingPongTarget.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(getPingPongSpecification(), query, "hello", "world"); + } + + @Test + public void pingPongInterpoceduralTest() { + setupSoot(PingPongInterproceduralTarget.class); + SootMethod m = + Scene.v() + .getMethod( + ""); + BackwardQuery query = selectFirstFileInitArgument(m); + + runAnalysis(getPingPongSpecification(), query, "hello", "world"); + } + + private Specification getPingPongSpecification() { + return Specification.create( + "", + "", + "", + ""); + } + + public static BackwardQuery selectFirstFileInitArgument(SootMethod m) { + Method method = JimpleMethod.of(m); + method.getStatements().stream().filter(x -> x.containsInvokeExpr()).forEach(x -> x.toString()); + Statement newFileStatement = + method.getStatements().stream() + .filter(x -> x.containsInvokeExpr()) + .filter( + x -> { + x.toString(); + return true; + }) + .filter( + x -> + x.getInvokeExpr().getMethod().getName().equals("") + && x.getInvokeExpr() + .getMethod() + .getDeclaringClass() + .getFullyQualifiedName() + .equals("java.io.File")) + .findFirst() + .get(); + Val arg = newFileStatement.getInvokeExpr().getArg(0); + + Statement predecessor = + method.getControlFlowGraph().getPredsOf(newFileStatement).stream().findFirst().get(); + Edge cfgEdge = new Edge(predecessor, newFileStatement); + return BackwardQuery.make(cfgEdge, arg); + } + + protected void runAnalysis(BackwardQuery query, String... expectedValues) { + Specification specification = + Specification.create( + "(ON{F}java.lang.String)>", + "(GO{B}java.lang.String)>"); + runAnalysis(specification, query, expectedValues); + } + + protected void runAnalysis( + Specification specification, BackwardQuery query, String... expectedValues) { + DemandDrivenGuidedAnalysis demandDrivenGuidedAnalysis = + new DemandDrivenGuidedAnalysis(specification); + Collection res = demandDrivenGuidedAnalysis.run(query); + Assert.assertEquals( + Sets.newHashSet(expectedValues), + res.stream() + .map(t -> ((AllocVal) t.var()).getAllocVal()) + .filter(x -> x.isStringConstant()) + .map(x -> x.getStringValue()) + .collect(Collectors.toSet())); + } + + protected void setupSoot(Class cls) { + G.v().reset(); + setupSoot(); + setApplicationClass(cls); + PackManager.v().runPacks(); + BoomerangPretransformer.v().reset(); + BoomerangPretransformer.v().apply(); + } + + private void setupSoot() { + Options.v().set_whole_program(true); + Options.v().setPhaseOption("cg." + CG, "on"); + Options.v().setPhaseOption("cg." + CG, "verbose:true"); + Options.v().set_output_format(Options.output_format_none); + Options.v().set_no_bodies_for_excluded(true); + Options.v().set_allow_phantom_refs(true); + Options.v().setPhaseOption("jb", "use-original-names:true"); + Options.v().set_keep_line_number(true); + Options.v().set_prepend_classpath(true); + Options.v().set_process_dir(getProcessDir()); + } + + private void setApplicationClass(Class cls) { + Scene.v().loadNecessaryClasses(); + List eps = Lists.newArrayList(); + for (SootClass sootClass : Scene.v().getClasses()) { + if (sootClass.toString().equals(cls.getName()) + || (sootClass.toString().contains(cls.getName() + "$"))) { + sootClass.setApplicationClass(); + eps.addAll(sootClass.getMethods()); + } + } + Scene.v().setEntryPoints(eps); + } + + private List getProcessDir() { + Path path = Paths.get("target/test-classes"); + return Lists.newArrayList(path.toAbsolutePath().toString()); + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/SpecificationParserTest.java b/boomerangPDS/src/test/java/boomerang/guided/SpecificationParserTest.java new file mode 100644 index 00000000..db96cc50 --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/SpecificationParserTest.java @@ -0,0 +1,21 @@ +package boomerang.guided; + +import boomerang.guided.Specification; +import org.junit.Test; + +public class SpecificationParserTest { + + @Test + public void specificationParserTest1() { + Specification specification = + Specification.create("(ON{F}java.lang.String)>"); + assert specification.getMethodAndQueries().size() == 1; + } + + @Test + public void specificationParserTest2() { + Specification specification = + Specification.create("(GO{B}java.lang.String)>)"); + assert specification.getMethodAndQueries().size() == 1; + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/BasicTarget.java b/boomerangPDS/src/test/java/boomerang/guided/targets/BasicTarget.java new file mode 100644 index 00000000..62c39ff4 --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/BasicTarget.java @@ -0,0 +1,12 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class BasicTarget { + + public static void main(String... args) { + String x = "bar"; + new File(x); + ; + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/BranchingAfterNewStringTest.java b/boomerangPDS/src/test/java/boomerang/guided/targets/BranchingAfterNewStringTest.java new file mode 100644 index 00000000..215bfe11 --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/BranchingAfterNewStringTest.java @@ -0,0 +1,20 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class BranchingAfterNewStringTest { + + public static void main(String... args) { + String x = new String("bar"); + String y = new String("foo"); + String bar = doPassArgument(Math.random() > 0 ? x : y); + new File(bar); + ; + } + + public static String doPassArgument(String param) { + String x = new String(param); + System.out.println(x); + return x; + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/BranchingTest.java b/boomerangPDS/src/test/java/boomerang/guided/targets/BranchingTest.java new file mode 100644 index 00000000..7efa92b2 --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/BranchingTest.java @@ -0,0 +1,19 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class BranchingTest { + + public static void main(String... args) { + String x = new String(Math.random() > 0 ? "bar" : "foo"); + String bar = doPassArgument(x); + new File(bar); + ; + } + + public static String doPassArgument(String param) { + String x = new String(param); + System.out.println(x); + return x; + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/ContextSensitiveAndLeftUnbalancedTarget.java b/boomerangPDS/src/test/java/boomerang/guided/targets/ContextSensitiveAndLeftUnbalancedTarget.java new file mode 100644 index 00000000..0a41a67f --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/ContextSensitiveAndLeftUnbalancedTarget.java @@ -0,0 +1,23 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class ContextSensitiveAndLeftUnbalancedTarget { + + public static void main(String... args) { + context("bar"); + } + + private static void context(String barParam) { + String bar = doPassArgument(barParam); + String foo = doPassArgument("foo"); + String quz = doPassArgument("quz"); + new File(bar); + new File(foo); + new File(quz); + } + + private static String doPassArgument(String param) { + return new String(param); + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/ContextSensitiveTarget.java b/boomerangPDS/src/test/java/boomerang/guided/targets/ContextSensitiveTarget.java new file mode 100644 index 00000000..d924ba09 --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/ContextSensitiveTarget.java @@ -0,0 +1,19 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class ContextSensitiveTarget { + + public static void main(String... args) { + String bar = doPassArgument("bar"); + String foo = doPassArgument("foo"); + String quz = doPassArgument("quz"); + new File(bar); + new File(foo); + new File(quz); + } + + private static String doPassArgument(String param) { + return new String(param); + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/LeftUnbalancedTarget.java b/boomerangPDS/src/test/java/boomerang/guided/targets/LeftUnbalancedTarget.java new file mode 100644 index 00000000..a00976ed --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/LeftUnbalancedTarget.java @@ -0,0 +1,15 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class LeftUnbalancedTarget { + + public static void main(String... args) { + bar("bar"); + } + + private static void bar(String param) { + String x = new String(param); + File file = new File(new String(param)); + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/NestedContextAndBranchingTarget.java b/boomerangPDS/src/test/java/boomerang/guided/targets/NestedContextAndBranchingTarget.java new file mode 100644 index 00000000..144fa864 --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/NestedContextAndBranchingTarget.java @@ -0,0 +1,26 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class NestedContextAndBranchingTarget { + + public static void main(String... args) { + String bar = doPassArgument("bar"); + new File(bar); + } + + private static String doPassArgument(String level0) { + return wrappedWayDeeper(new String(level0)); + } + + private static String wrappedWayDeeper(String level1) { + if (Math.random() > 0) { + return "foo"; + } + return andMoreStacks(level1); + } + + private static String andMoreStacks(String level2) { + return level2; + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/NestedContextTarget.java b/boomerangPDS/src/test/java/boomerang/guided/targets/NestedContextTarget.java new file mode 100644 index 00000000..2f2a9612 --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/NestedContextTarget.java @@ -0,0 +1,23 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class NestedContextTarget { + + public static void main(String... args) { + String bar = doPassArgument("bar"); + new File(bar); + } + + private static String doPassArgument(String level0) { + return wrappedWayDeeper(new String(level0)); + } + + private static String wrappedWayDeeper(String level1) { + return andMoreStacks(level1); + } + + private static String andMoreStacks(String level2) { + return level2; + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/PingPongInterproceduralTarget.java b/boomerangPDS/src/test/java/boomerang/guided/targets/PingPongInterproceduralTarget.java new file mode 100644 index 00000000..adf74365 --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/PingPongInterproceduralTarget.java @@ -0,0 +1,22 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class PingPongInterproceduralTarget { + + public static void main(String... args) { + StringBuilder sb = new StringBuilder(); + final String result = doCreateFileName(sb); + File file = new File(result); + } + + private static String doCreateFileName(StringBuilder sb) { + sb.append("hello"); + appendMe(sb, "world"); + return sb.toString(); + } + + private static void appendMe(StringBuilder sb, String world) { + sb.append(world); + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/PingPongTarget.java b/boomerangPDS/src/test/java/boomerang/guided/targets/PingPongTarget.java new file mode 100644 index 00000000..fe296adc --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/PingPongTarget.java @@ -0,0 +1,14 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class PingPongTarget { + + public static void main(String... args) { + final StringBuilder sb = new StringBuilder(); + final String hello = "hello"; + sb.append(hello).append("world"); + final String result = sb.toString(); + File file = new File(result); + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/WrappedInNewStringInnerTarget.java b/boomerangPDS/src/test/java/boomerang/guided/targets/WrappedInNewStringInnerTarget.java new file mode 100644 index 00000000..d17446a2 --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/WrappedInNewStringInnerTarget.java @@ -0,0 +1,19 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class WrappedInNewStringInnerTarget { + + public static void main(String... args) { + String x = "bar"; + String bar = doPassArgument(x); + new File(bar); + ; + } + + public static String doPassArgument(String param) { + String x = new String(param); + System.out.println(x); + return x; + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/WrappedInNewStringTarget.java b/boomerangPDS/src/test/java/boomerang/guided/targets/WrappedInNewStringTarget.java new file mode 100644 index 00000000..26672836 --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/WrappedInNewStringTarget.java @@ -0,0 +1,18 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class WrappedInNewStringTarget { + + public static void main(String... args) { + + String x = new String("bar"); + String bar = doPassArgument(x); + new File(bar); + ; + } + + public static String doPassArgument(String param) { + return param; + } +} diff --git a/boomerangPDS/src/test/java/boomerang/guided/targets/WrappedInStringTwiceTest.java b/boomerangPDS/src/test/java/boomerang/guided/targets/WrappedInStringTwiceTest.java new file mode 100644 index 00000000..bdb5e2a6 --- /dev/null +++ b/boomerangPDS/src/test/java/boomerang/guided/targets/WrappedInStringTwiceTest.java @@ -0,0 +1,19 @@ +package boomerang.guided.targets; + +import java.io.File; + +public class WrappedInStringTwiceTest { + + public static void main(String... args) { + String x = new String("bar"); + String bar = doPassArgument(x); + new File(bar); + ; + } + + public static String doPassArgument(String param) { + String x = new String(param); + System.out.println(x); + return x; + } +} diff --git a/boomerangPDS/src/test/java/test/cases/bugfixes/Repro.java b/boomerangPDS/src/test/java/test/cases/bugfixes/Repro.java new file mode 100644 index 00000000..0dedfa8a --- /dev/null +++ b/boomerangPDS/src/test/java/test/cases/bugfixes/Repro.java @@ -0,0 +1,130 @@ +package test.cases.bugfixes; + +import boomerang.Boomerang; +import boomerang.BoomerangOptions; +import boomerang.ForwardQuery; +import boomerang.results.ForwardBoomerangResults; +import boomerang.scene.*; +import boomerang.scene.ControlFlowGraph.Edge; +import boomerang.scene.jimple.*; +import com.google.common.collect.Sets; +import java.util.Arrays; +import java.util.Collections; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import org.junit.Test; +import soot.*; +import soot.options.Options; +import wpds.impl.Weight.NoWeight; + +/** + * This code was added to test https://github.com/CodeShield-Security/SPDS/issues/5. + * Thanks @copumpkin for sharing code for testing purpose. + */ +public class Repro { + static BoomerangOptions opts = new IntAndStringBoomerangOptions(); + + @Test + public void excludeFoo() { + G.reset(); + setupSoot("src/test/resources/Test.jar", true); + analyze("", "", "()>"); + } + + @Test + public void includeFoo() { + G.reset(); + setupSoot("src/test/resources/Test.jar", false); + analyze( + "", + "", + "()>", + "()>"); + } + + private static void setupSoot(String classPath, boolean excludeFoo) { + Options.v().set_whole_program(true); + Options.v().setPhaseOption("cg.spark", "on"); + Options.v().set_no_bodies_for_excluded(true); + Options.v().set_allow_phantom_refs(true); + Options.v().set_keep_line_number(true); + + /* ********* Uncomment this line to see methods invoked on Foo! ********* */ + if (excludeFoo) { + Options.v().set_exclude(Collections.singletonList("Foo")); + } + + Options.v().setPhaseOption("jb", "use-original-names:true"); + Options.v().set_soot_classpath(classPath); + Options.v().set_prepend_classpath(true); + Options.v().set_process_dir(Arrays.asList(classPath.split(":"))); + Scene.v().loadNecessaryClasses(); + } + + private static void analyze(String... expectedCallSignatureOnFoo) { + PackManager.v() + .getPack("wjtp") + .add(new Transform("wjtp.repro", new ReproTransformer(expectedCallSignatureOnFoo))); + PackManager.v().getPack("cg").apply(); + PackManager.v().getPack("wjtp").apply(); + } + + private static Map getMethodsInvokedFromInstanceInStatement( + Statement queryStatement) { + Val var = new AllocVal(queryStatement.getLeftOp(), queryStatement, queryStatement.getRightOp()); + ForwardQuery fwq = + new ForwardQuery( + new Edge( + queryStatement, + queryStatement.getMethod().getControlFlowGraph().getSuccsOf(queryStatement).stream() + .findFirst() + .get()), + var); + Boomerang solver = new Boomerang(new SootCallGraph(), SootDataFlowScope.make(Scene.v()), opts); + ForwardBoomerangResults results = solver.solve(fwq); + return results.getInvokedMethodOnInstance(); + } + + static class ReproTransformer extends SceneTransformer { + + Set expectedCalledMethodsOnFoo; + + public ReproTransformer(String... expectedCallSignatureOnFoo) { + expectedCalledMethodsOnFoo = Sets.newHashSet(expectedCallSignatureOnFoo); + } + + @Override + protected void internalTransform(String name, Map options) { + BoomerangPretransformer.v().reset(); + BoomerangPretransformer.v().apply(); + + SootMethod m = Scene.v().getMethod(""); + Method method = JimpleMethod.of(m); + + System.out.println("All method units:"); + for (Statement s : method.getControlFlowGraph().getStatements()) { + System.out.println("\t" + s.toString()); + } + + Statement newFoo = + method.getControlFlowGraph().getStatements().stream() + .filter(x -> x.toString().contains("$stack2 = new Foo")) + .findFirst() + .get(); + + // This will only show results if set_exclude above gets uncommented + System.out.println("\nFoo invoked methods:"); + Set> entries = + getMethodsInvokedFromInstanceInStatement(newFoo).entrySet(); + Set methodCalledOnFoo = Sets.newHashSet(); + for (Map.Entry e : entries) { + System.out.println("\t" + e.getKey().toString()); + System.out.println("\t\t" + e.getValue().toString()); + methodCalledOnFoo.add(e.getValue().toString()); + } + + assert methodCalledOnFoo.equals(Sets.newHashSet(expectedCalledMethodsOnFoo)); + } + } +} diff --git a/boomerangPDS/src/test/java/test/cases/threading/InnerClassWithThreadTest.java b/boomerangPDS/src/test/java/test/cases/threading/InnerClassWithThreadTest.java index 20825d30..af7690db 100644 --- a/boomerangPDS/src/test/java/test/cases/threading/InnerClassWithThreadTest.java +++ b/boomerangPDS/src/test/java/test/cases/threading/InnerClassWithThreadTest.java @@ -17,6 +17,7 @@ import test.core.AbstractBoomerangTest; import test.core.selfrunning.AllocatedObject; +@Ignore public class InnerClassWithThreadTest extends AbstractBoomerangTest { private static Alloc param; diff --git a/boomerangPDS/src/test/resources/Test.jar b/boomerangPDS/src/test/resources/Test.jar new file mode 100644 index 00000000..624def7f Binary files /dev/null and b/boomerangPDS/src/test/resources/Test.jar differ diff --git a/boomerangPDS/src/test/resources/specification.txt b/boomerangPDS/src/test/resources/specification.txt new file mode 100644 index 00000000..c5568bb4 --- /dev/null +++ b/boomerangPDS/src/test/resources/specification.txt @@ -0,0 +1,2 @@ +(ON{F}java.lang.String)> +(GO{B}java.lang.String)> \ No newline at end of file diff --git a/boomerangScope/src/main/java/boomerang/scene/jimple/SootCallGraph.java b/boomerangScope/src/main/java/boomerang/scene/jimple/SootCallGraph.java index 1af96564..91606cc3 100644 --- a/boomerangScope/src/main/java/boomerang/scene/jimple/SootCallGraph.java +++ b/boomerangScope/src/main/java/boomerang/scene/jimple/SootCallGraph.java @@ -16,6 +16,7 @@ public SootCallGraph() { if (e.src().hasActiveBody() && e.tgt().hasActiveBody() && e.srcStmt() != null) { Statement callSite = JimpleStatement.create(e.srcStmt(), JimpleMethod.of(e.src())); if (callSite.containsInvokeExpr()) { + LOGGER.trace("Call edge from {} to target method {}", callSite, e.tgt()); this.addEdge(new Edge(callSite, JimpleMethod.of(e.tgt()))); } } diff --git a/testCore/src/main/java/test/core/selfrunning/AbstractTestingFramework.java b/testCore/src/main/java/test/core/selfrunning/AbstractTestingFramework.java index 60642559..cc899303 100644 --- a/testCore/src/main/java/test/core/selfrunning/AbstractTestingFramework.java +++ b/testCore/src/main/java/test/core/selfrunning/AbstractTestingFramework.java @@ -110,13 +110,14 @@ private void initializeSootWithEntryPoint() { Options.v().set_exclude(excludedPackages()); // JAVA VERSION 8 - if(getJavaVersion() < 9) { + if (getJavaVersion() < 9) { Options.v().set_prepend_classpath(true); Options.v().set_soot_classpath(getSootClassPath()); } // JAVA VERSION 9 - else if(getJavaVersion() >= 9) { - Options.v().set_soot_classpath("VIRTUAL_FS_FOR_JDK" + File.pathSeparator + getSootClassPath()); + else if (getJavaVersion() >= 9) { + Options.v() + .set_soot_classpath("VIRTUAL_FS_FOR_JDK" + File.pathSeparator + getSootClassPath()); } // Options.v().set_main_class(this.getTargetClass()); @@ -161,7 +162,7 @@ protected String getSootClassPath() { throw new RuntimeException("Could not get property java.home!"); String sootCp = userdir + "/target/test-classes"; - if(getJavaVersion() < 9) { + if (getJavaVersion() < 9) { sootCp += File.pathSeparator + javaHome + "/lib/rt.jar"; sootCp += File.pathSeparator + javaHome + "/lib/jce.jar"; } @@ -240,11 +241,14 @@ protected boolean staticallyUnknown() { private static int getJavaVersion() { String version = System.getProperty("java.version"); - if(version.startsWith("1.")) { + if (version.startsWith("1.")) { version = version.substring(2, 3); } else { int dot = version.indexOf("."); - if(dot != -1) { version = version.substring(0, dot); } - } return Integer.parseInt(version); + if (dot != -1) { + version = version.substring(0, dot); + } + } + return Integer.parseInt(version); } }