file_name stringlengths 6 86 | file_path stringlengths 45 249 | content stringlengths 47 6.26M | file_size int64 47 6.26M | language stringclasses 1 value | extension stringclasses 1 value | repo_name stringclasses 767 values | repo_stars int64 8 14.4k | repo_forks int64 0 1.17k | repo_open_issues int64 0 788 | repo_created_at stringclasses 767 values | repo_pushed_at stringclasses 767 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
TransitiveSinkCaller.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/TransitiveSinkCaller.java | package flow.twist;
import java.util.Set;
import soot.SootMethod;
import soot.Unit;
import com.google.common.collect.Sets;
import flow.twist.config.AnalysisContext;
public class TransitiveSinkCaller {
private Set<SootMethod> transitiveCallers = Sets.newHashSet();
private AnalysisContext context;
public TransitiveSinkCaller(AnalysisContext context) {
this.context = context;
for (Unit sink : context.seedFactory.initialSeeds(context)) {
SootMethod m = context.icfg.getMethodOf(sink);
addTransitiveCallers(m);
}
}
private void addTransitiveCallers(SootMethod m) {
if (transitiveCallers.add(m)) {
for (Unit caller : context.icfg.getCallersOf(m)) {
addTransitiveCallers(context.icfg.getMethodOf(caller));
}
}
}
public boolean isTransitiveCallerOfAnySink(SootMethod m) {
return transitiveCallers.contains(m);
}
}
| 855 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
AbstractAnalysis.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/AbstractAnalysis.java | package flow.twist;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
import soot.Body;
import soot.MethodOrMethodContext;
import soot.PackManager;
import soot.Scene;
import soot.SceneTransformer;
import soot.SootMethod;
import soot.Transform;
import soot.jimple.Jimple;
import soot.jimple.NopStmt;
public abstract class AbstractAnalysis {
public void execute() {
ArrayList<String> argList = createArgs();
AnalysisReporting.setSootArgs(argList);
registerAnalysisTransformer();
soot.Main.main(argList.toArray(new String[0]));
}
protected abstract ArrayList<String> createArgs();
protected abstract void executeAnalysis();
private static void insertNopStatements() {
for (Iterator<MethodOrMethodContext> iter = Scene.v().getReachableMethods().listener(); iter.hasNext();) {
SootMethod m = iter.next().method();
if (m.hasActiveBody()) {
Body b = m.getActiveBody();
NopStmt newNopStmt = Jimple.v().newNopStmt();
newNopStmt.addAllTagsOf(b.getUnits().getFirst());
b.getUnits().addFirst(newNopStmt);
ActiveBodyVerifier.markActive(m);
} else
ActiveBodyVerifier.markInactive(m);
}
}
private void registerAnalysisTransformer() {
PackManager.v().getPack("wjtp").add(new Transform("wjtp.permissionAnalysis", new SceneTransformer() {
protected void internalTransform(String phaseName, @SuppressWarnings("rawtypes") Map options) {
// Stats.print();
insertNopStatements();
executeAnalysis();
}
}));
}
}
| 1,499 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
Stats.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/Stats.java | package flow.twist;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
import soot.MethodOrMethodContext;
import soot.Scene;
import soot.SootClass;
import soot.SootMethod;
import com.google.common.collect.Sets;
import flow.twist.util.AnalysisUtil;
public class Stats {
public static void print() {
Set<SootMethod> _reachableMethods = Sets.newHashSet();
Set<SootMethod> _methods = Sets.newHashSet();
{
int reachable = 0;
int reachableAndCallable = 0;
int concrete = 0;
int reachableAndCallableWithBody = 0;
Set<SootClass> reachableClasses = Sets.newHashSet();
for (Iterator<MethodOrMethodContext> iter = Scene.v().getReachableMethods().listener(); iter.hasNext();) {
SootMethod m = iter.next().method();
if (m.isPhantom())
continue;
reachable++;
if (m.isConcrete()) {
_reachableMethods.add(m);
concrete++;
}
if (AnalysisUtil.methodMayBeCallableFromApplication(m)) {
reachableAndCallable++;
if (m.hasActiveBody())
reachableAndCallableWithBody++;
}
reachableClasses.add(m.getDeclaringClass());
}
writeFile(reachableClasses);
System.out.println("Reachable methods: " + reachable);
System.out.println("Reachable and concrete methods: " + concrete);
System.out.println("Reachable and callable methods: " + reachableAndCallable);
System.out.println("Reachable and callable methods with body: " + reachableAndCallableWithBody);
System.out.println("Reachable classes: " + reachableClasses.size());
}
{
int classes = 0;
int methods = 0;
int callableMethods = 0;
int reachableAndCallableWithBody = 0;
int callableAndConcrete = 0;
int concrete = 0;
for (SootClass c : Scene.v().getClasses()) {
if (c.isPhantomClass())
continue;
classes++;
for (SootMethod m : c.getMethods()) {
if (m.isPhantom())
continue;
if (m.isConcrete()) {
concrete++;
_methods.add(m);
}
methods++;
if (AnalysisUtil.methodMayBeCallableFromApplication(m)) {
callableMethods++;
if (m.hasActiveBody())
reachableAndCallableWithBody++;
if (m.isConcrete())
callableAndConcrete++;
}
}
}
System.out.println("Total methods: " + methods);
System.out.println("Total concrete methods: " + concrete);
System.out.println("Total callable methods: " + callableMethods);
System.out.println("Total callable methods with body: " + reachableAndCallableWithBody);
System.out.println("Total callable concrete methods: " + callableAndConcrete);
System.out.println("Total classes: " + classes);
}
{
int classes = 0;
int methods = 0;
int callableMethods = 0;
for (SootClass c : Scene.v().getLibraryClasses()) {
if (c.isPhantomClass())
continue;
classes++;
for (SootMethod m : c.getMethods()) {
if (m.isPhantom())
continue;
methods++;
if (AnalysisUtil.methodMayBeCallableFromApplication(m)) {
callableMethods++;
}
}
}
System.out.println("Library methods: " + methods);
System.out.println("Library callable methods: " + callableMethods);
System.out.println("Library classes: " + classes);
}
{
int classes = 0;
int methods = 0;
int callableMethods = 0;
for (SootClass c : Scene.v().getApplicationClasses()) {
if (c.isPhantomClass())
continue;
classes++;
for (SootMethod m : c.getMethods()) {
if (m.isPhantom())
continue;
methods++;
if (AnalysisUtil.methodMayBeCallableFromApplication(m)) {
callableMethods++;
}
}
}
System.out.println("Application methods: " + methods);
System.out.println("Application callable methods: " + callableMethods);
System.out.println("Application classes: " + classes);
}
{
int classes = 0;
int methods = 0;
int callableMethods = 0;
for (SootClass c : Scene.v().getPhantomClasses()) {
classes++;
for (SootMethod m : c.getMethods()) {
if (!m.isPhantom())
continue;
methods++;
if (AnalysisUtil.methodMayBeCallableFromApplication(m)) {
callableMethods++;
}
}
}
System.out.println("Phantom methods: " + methods);
System.out.println("Phantom callable methods: " + callableMethods);
System.out.println("Phantom classes: " + classes);
}
// System.out.println("Unreachable methods:");
// int i = 0;
// for (SootMethod m : _methods) {
// if (!_reachableMethods.contains(m)) {
// System.out.println((++i) + " " + m);
// }
// }
}
private static void writeFile(Set<SootClass> reachableClasses) {
try {
TreeSet<String> treeSet = new TreeSet<>();
for (SootClass sootClass : reachableClasses) {
treeSet.add(sootClass.toString());
}
FileWriter writer = new FileWriter(new File("reachableClasses.txt"));
for (String sootClass : treeSet) {
writer.write(sootClass + "\n");
}
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
| 5,063 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
AnalysisReporting.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/AnalysisReporting.java | package flow.twist;
import static java.util.concurrent.TimeUnit.HOURS;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.MINUTES;
import static java.util.concurrent.TimeUnit.SECONDS;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.google.common.base.Predicate;
import com.google.common.base.Stopwatch;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import flow.twist.config.AnalysisContext;
import flow.twist.path.Path;
import flow.twist.reporter.Report;
public class AnalysisReporting {
public static File directory = new File("results");
private static Stopwatch init;
private static List<String> sootArgs;
private static Stopwatch analysis;
private static Map<Object, IfdsData> solverData;
private static Map<AnalysisContext, IfdsData> ifdsContextData;
private static Map<Report, ReportData> reports;
private static Stopwatch combinedPaths;
private static Set<Path> createdCombinedPaths;
private static String statsFile = getStatsFileName();
private static void reset() {
analysis = new Stopwatch();
solverData = Maps.newHashMap();
ifdsContextData = Maps.newHashMap();
reports = Maps.newHashMap();
combinedPaths = new Stopwatch();
createdCombinedPaths = Sets.newHashSet();
}
private static String getStatsFileName() {
return "stats.csv";
}
public static void setSootArgs(List<String> sootArgs) {
init = new Stopwatch();
init.start();
AnalysisReporting.sootArgs = sootArgs;
}
public static void analysisStarted() {
if (init.isRunning())
init.stop();
reset();
analysis.start();
}
public static void analysisFinished() {
analysis.stop();
directory.mkdirs();
writeGeneralInfoFile();
writeSemiPaths();
writeValidPaths();
writeStatistics();
}
public static void ifdsStarting(AnalysisContext context, Object solver) {
if (!solverData.containsKey(solver)) {
IfdsData data = new IfdsData();
data.watch.start();
solverData.put(solver, data);
}
{
IfdsData data = new IfdsData();
data.watch.start();
ifdsContextData.put(context, data);
}
}
public static void ifdsFinished(AnalysisContext context, Object solver, int propagations) {
{
IfdsData data = solverData.get(solver);
if (data.watch.isRunning()) {
data.watch.stop();
data.solver = solver;
data.propagations += propagations;
}
}
{
IfdsData data = ifdsContextData.get(context);
data.solver = solver;
data.watch.stop();
data.propagations = propagations;
System.out.println("IFDS finished (" + context.direction + ") in: " + format(data.watch.elapsed(MILLISECONDS)) + " and " + propagations
+ " propagations.");
}
}
public static void startingPathsFor(Report report) {
ReportData data = new ReportData();
reports.put(report, data);
data.watch.start();
}
public static void finishedPathsFor(Report report, Collection<Path> paths) {
ReportData data = reports.get(report);
data.watch.stop();
data.paths = paths;
}
public static void combinedPathsStarting() {
combinedPaths.start();
}
public static void combinedPathsFinished(Set<Path> validPaths) {
combinedPaths.stop();
createdCombinedPaths = validPaths;
}
private static void writeStatistics() {
try {
BufferedWriter writer = new BufferedWriter(new FileWriter(new File(directory, statsFile), true));
writer.write(String.valueOf(getMaxHeapSize()));
writer.write(";");
writer.write(String.valueOf(analysis.elapsed(MILLISECONDS)));
writer.write(";");
writer.write(String.valueOf(init.elapsed(MILLISECONDS)));
writer.write(";");
writer.write(String.valueOf(totalIfds()));
writer.write(";");
writer.write(String.valueOf(totalPathCreation()));
writer.write(";");
writer.write(String.valueOf(combinedPaths.elapsed(MILLISECONDS)));
writer.write("\n");
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
private static long getMaxHeapSize() {
MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
return memoryBean.getHeapMemoryUsage().getMax();
}
private static void writeGeneralInfoFile() {
try {
BufferedWriter writer = new BufferedWriter(new FileWriter(new File(directory, "stats.txt")));
writer.write("========================================\n");
write(writer, "Soot Initialization", format(init.elapsed(MILLISECONDS)));
write(writer, "Analysis duration", format(analysis.elapsed(MILLISECONDS)));
write(writer, "IFDS duration", format(totalIfds()));
write(writer, "Semi-Path creation", format(totalPathCreation()));
write(writer, "Combined Paths", format(combinedPaths.elapsed(MILLISECONDS)));
writer.write("========================================\n");
write(writer, "IFDS Propagations", totalIFdsPropagations());
write(writer, "Reports", reports.size());
write(writer, "Semi-Paths", totalSemiPaths(reports.keySet()));
write(writer, "Combined Paths", createdCombinedPaths.size());
writer.write("========================================\n");
writer.write("Soot Arguments:\n");
for (String arg : sootArgs) {
writer.write("\t");
writer.write(arg);
writer.write("\n");
}
for (AnalysisContext context : ifdsContextData.keySet()) {
writer.write("========================================\n");
IfdsData data = ifdsContextData.get(context);
write(writer, "Solver", data.solver.getClass().getSimpleName());
writer.write(context.toString());
write(writer, "Duration", format(data.watch.elapsed(MILLISECONDS)));
write(writer, "Propagations", data.propagations);
write(writer, "Reports", Iterables.size(reports(context)));
write(writer, "Semi-Paths", totalSemiPaths(reports(context)));
}
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
private static void writeSemiPaths() {
try {
BufferedWriter writer = new BufferedWriter(new FileWriter(new File(directory, "semi-paths.txt")));
for (ReportData data : reports.values()) {
for (Path path : data.paths) {
writer.write(path.toContextAwareString());
writer.write("\n\n=========================================\n\n");
}
}
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
private static void writeValidPaths() {
try {
BufferedWriter writer = new BufferedWriter(new FileWriter(new File(directory, "combined-paths.txt")));
for (Path path : createdCombinedPaths) {
writer.write(path.toContextAwareString());
writer.write("\n\n=========================================\n\n");
}
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
private static void write(BufferedWriter writer, String label, Object value) throws IOException {
writer.write(String.format("%-25s %s\n", label + ":", String.valueOf(value)));
}
private static Iterable<Report> reports(final AnalysisContext context) {
return Iterables.filter(reports.keySet(), new Predicate<Report>() {
@Override
public boolean apply(Report report) {
return report.context == context;
}
});
}
private static int totalSemiPaths(Iterable<Report> _reports) {
int result = 0;
for (Report report : _reports) {
ReportData data = reports.get(report);
result += data.paths.size();
}
return result;
}
private static int totalIFdsPropagations() {
int result = 0;
for (IfdsData data : solverData.values()) {
result += data.propagations;
}
return result;
}
private static long totalPathCreation() {
long result = 0;
for (ReportData data : reports.values()) {
result += data.watch.elapsed(MILLISECONDS);
}
return result;
}
private static String format(long millis) {
long h = MILLISECONDS.toHours(millis);
millis -= HOURS.toMillis(h);
long m = MILLISECONDS.toMinutes(millis);
millis -= MINUTES.toMillis(m);
long s = MILLISECONDS.toSeconds(millis);
millis -= SECONDS.toMillis(s);
return String.format("%02d:%02d:%02d,%03d", h, m, s, millis);
}
private static long totalIfds() {
long result = 0;
for (IfdsData data : solverData.values()) {
result += data.watch.elapsed(MILLISECONDS);
}
return result;
}
private static class IfdsData {
private Object solver;
private Stopwatch watch = new Stopwatch();
private int propagations;
}
private static class ReportData {
private Collection<Path> paths;
private Stopwatch watch = new Stopwatch();
}
}
| 8,710 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
SolverFactory.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/SolverFactory.java | package flow.twist;
import static flow.twist.config.AnalysisDirection.BACKWARDS;
import static flow.twist.config.AnalysisDirection.FORWARDS;
import heros.solver.BiDiIFDSSolver;
import heros.solver.IFDSSolver;
import heros.solver.PathTrackingIFDSSolver;
import soot.SootMethod;
import soot.Unit;
import soot.jimple.toolkits.ide.icfg.BiDiInterproceduralCFG;
import flow.twist.config.AnalysisConfigurationBuilder;
import flow.twist.config.AnalysisConfigurationBuilder.PropagationReporterDecorator;
import flow.twist.ifds.FlowFunctionFactory;
import flow.twist.ifds.TabulationProblem;
import flow.twist.reporter.DelayingReporter;
import flow.twist.reporter.IfdsReporter;
import flow.twist.trackable.Trackable;
import flow.twist.util.Pair;
public class SolverFactory {
public static void runOneDirectionSolver(AnalysisConfigurationBuilder configBuilder) {
Pair<IfdsReporter, AnalysisConfigurationBuilder> pair = configBuilder.decorateReporter(new PropagationReporterDecorator() {
@Override
public IfdsReporter decorate(IfdsReporter reporter) {
return new DelayingReporter(reporter);
}
});
TabulationProblem problem = createTabulationProblem(pair.second);
IFDSSolver<Unit, Trackable, SootMethod, BiDiInterproceduralCFG<Unit, SootMethod>> solver = createSolver(problem);
AnalysisReporting.analysisStarted();
_runOneDirectionSolver(problem, solver);
pair.first.analysisFinished();
AnalysisReporting.analysisFinished();
}
public static void runInnerToOuterSolver(AnalysisConfigurationBuilder configBuilder) {
Pair<IfdsReporter, AnalysisConfigurationBuilder> pair = configBuilder.decorateReporter(new PropagationReporterDecorator() {
@Override
public IfdsReporter decorate(IfdsReporter reporter) {
return new DelayingReporter(reporter);
}
});
configBuilder = pair.second;
TabulationProblem forwardTabulationProblem = createTabulationProblem(configBuilder.direction(FORWARDS));
IFDSSolver<Unit, Trackable, SootMethod, BiDiInterproceduralCFG<Unit, SootMethod>> forwardSolver = createSolver(forwardTabulationProblem);
TabulationProblem backwardTabulationProblem = createTabulationProblem(configBuilder.direction(BACKWARDS));
IFDSSolver<Unit, Trackable, SootMethod, BiDiInterproceduralCFG<Unit, SootMethod>> backwardSolver = createSolver(backwardTabulationProblem);
AnalysisReporting.analysisStarted();
_runOneDirectionSolver(forwardTabulationProblem, forwardSolver);
_runOneDirectionSolver(backwardTabulationProblem, backwardSolver);
pair.first.analysisFinished();
AnalysisReporting.analysisFinished();
}
protected static void _runOneDirectionSolver(final TabulationProblem tabulationProblem, IFDSSolver<Unit, Trackable, SootMethod, BiDiInterproceduralCFG<Unit, SootMethod>> solver) {
AnalysisReporting.ifdsStarting(tabulationProblem.getContext(), solver);
solver.solve();
AnalysisReporting.ifdsFinished(tabulationProblem.getContext(), solver, FlowFunctionFactory.propCounter.get());
FlowFunctionFactory.propCounter.set(0);
}
private static IFDSSolver<Unit, Trackable, SootMethod, BiDiInterproceduralCFG<Unit, SootMethod>> createSolver(
final TabulationProblem tabulationProblem) {
IFDSSolver<Unit, Trackable, SootMethod, BiDiInterproceduralCFG<Unit, SootMethod>> solver = new PathTrackingIFDSSolver<Unit, Trackable, SootMethod, BiDiInterproceduralCFG<Unit, SootMethod>>(
tabulationProblem) {
@Override
protected String getDebugName() {
if (tabulationProblem.getContext().direction == FORWARDS)
return "FW";
else
return "BW";
}
};
return solver;
}
private static TabulationProblem createTabulationProblem(
AnalysisConfigurationBuilder configBuilder) {
final TabulationProblem tabulationProblem = new TabulationProblem(configBuilder.build());
return tabulationProblem;
}
public static void runBiDirectionSolver(AnalysisConfigurationBuilder configBuilder) {
Pair<IfdsReporter, AnalysisConfigurationBuilder> pair = configBuilder.decorateReporter(new PropagationReporterDecorator() {
@Override
public IfdsReporter decorate(IfdsReporter reporter) {
return new DelayingReporter(reporter);
}
});
configBuilder = pair.second;
TabulationProblem backwardsTabulationProblem = new TabulationProblem(configBuilder.direction(BACKWARDS).build());
TabulationProblem forwardsTabulationProblem = new TabulationProblem(configBuilder.direction(FORWARDS).build());
BiDiIFDSSolver<Unit, Trackable, SootMethod, BiDiInterproceduralCFG<Unit, SootMethod>> biDiIFDSSolver = new BiDiIFDSSolver<Unit, Trackable, SootMethod, BiDiInterproceduralCFG<Unit, SootMethod>>(
forwardsTabulationProblem, backwardsTabulationProblem);
AnalysisReporting.analysisStarted();
AnalysisReporting.ifdsStarting(backwardsTabulationProblem.getContext(), biDiIFDSSolver);
AnalysisReporting.ifdsStarting(forwardsTabulationProblem.getContext(), biDiIFDSSolver);
biDiIFDSSolver.solve();
AnalysisReporting.ifdsFinished(backwardsTabulationProblem.getContext(), biDiIFDSSolver, FlowFunctionFactory.propCounter.get());
AnalysisReporting.ifdsFinished(forwardsTabulationProblem.getContext(), biDiIFDSSolver, FlowFunctionFactory.propCounter.get());
pair.first.analysisFinished();
AnalysisReporting.analysisFinished();
}
}
| 5,255 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
AbstractMainAnalysis.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/AbstractMainAnalysis.java | package flow.twist;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Set;
import soot.SootClass;
import soot.SootMethod;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import flow.twist.path.Path;
import flow.twist.util.AnalysisUtil;
import flow.twist.util.MultipleAnalysisPlotter;
public abstract class AbstractMainAnalysis extends AbstractAnalysis {
private String[] args;
public AbstractMainAnalysis(String[] args) {
this.args = args;
}
@Override
protected ArrayList<String> createArgs() {
ArrayList<String> argList = new ArrayList<String>(Arrays.asList(args));
String jrePath = argList.remove(0);
AnalysisUtil.initRestrictedPackages(jrePath);
argList.add("-w");
argList.add("-f");
argList.add("none");
argList.add("-p");
argList.add("cg");
argList.add("all-reachable:true");
argList.add("-keep-line-number");
argList.add("-include-all");
argList.add("-allow-phantom-refs");
argList.add("-f");
argList.add("none");
argList.add("-pp");
return argList;
}
@Override
protected void executeAnalysis() {
Set<Path> validPaths = _executeAnalysis();
System.out.println("Writing reports...");
writeReportFile(validPaths);
writeResultGraphs(validPaths);
}
private void writeResultGraphs(Set<Path> validPaths) {
HashMultimap<SootClass, Path> paths = HashMultimap.create();
for (Path path : validPaths) {
SootClass declClass = path.context.icfg.getMethodOf(path.getSink()).getDeclaringClass();
paths.put(declClass, path);
}
for (SootClass declClass : paths.keySet()) {
MultipleAnalysisPlotter plotter = new MultipleAnalysisPlotter();
plotter.plotAnalysisResults(paths.get(declClass), "blue");
String filename = "results/graphs/" + declClass.toString().replaceAll("[^\\w]", "_");
plotter.writeFile(filename);
}
}
private void writeReportFile(Set<Path> validPaths) {
Multimap<SootMethod, Path> pathsBySink = HashMultimap.create();
for (Path path : validPaths) {
pathsBySink.put(path.context.icfg.getMethodOf(path.getSink()), path);
}
try {
FileWriter writer = new FileWriter(new File("report.csv"));
for (SootMethod sink : pathsBySink.keySet()) {
writer.write(String.format("%s;%d\n", sink.toString(), pathsBySink.get(sink).size()));
}
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
protected abstract Set<Path> _executeAnalysis();
}
| 2,525 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
FanInFanOutDebugger.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/debugger/FanInFanOutDebugger.java | package flow.twist.debugger;
import java.util.Set;
import soot.SootMethod;
import com.google.common.collect.Sets;
import flow.twist.config.AnalysisContext;
import flow.twist.debugger.Debugger.DebuggerListener;
import flow.twist.ifds.FlowEdge;
import flow.twist.ifds.Propagator;
import flow.twist.ifds.FlowEdge.Call2ReturnEdge;
import flow.twist.ifds.FlowEdge.CallEdge;
import flow.twist.ifds.FlowEdge.NormalEdge;
import flow.twist.ifds.FlowEdge.ReturnEdge;
import flow.twist.reporter.DebugPlotter;
import flow.twist.reporter.Report;
import flow.twist.trackable.Trackable;
import flow.twist.util.CacheMap;
public class FanInFanOutDebugger implements DebuggerListener {
private CacheMap<SootMethod, Set<Trackable>> fanIn = new CacheMap<SootMethod, Set<Trackable>>() {
@Override
protected Set<Trackable> createItem(SootMethod key) {
return Sets.newIdentityHashSet();
}
};
private CacheMap<SootMethod, Set<Trackable>> fanOut = new CacheMap<SootMethod, Set<Trackable>>() {
@Override
protected Set<Trackable> createItem(SootMethod key) {
return Sets.newIdentityHashSet();
}
};
private CacheMap<SootMethod, Set<Trackable>> intra = new CacheMap<SootMethod, Set<Trackable>>() {
@Override
protected Set<Trackable> createItem(SootMethod key) {
return Sets.newIdentityHashSet();
}
};
private AnalysisContext context;
private boolean dirty = true;
@Override
public synchronized void kill(AnalysisContext context, Trackable source, Propagator propagator, FlowEdge edge) {
}
@Override
public synchronized void propagate(final AnalysisContext context, final Trackable source, Set<Trackable> propagatedTaints, FlowEdge edge) {
this.context = context;
edge.accept(new FlowEdge.Visitor<Void>() {
@Override
public Void visit(Call2ReturnEdge call2ReturnEdge) {
intra.getOrCreate(context.icfg.getMethodOf(call2ReturnEdge.callSite)).add(source);
dirty = true;
return null;
}
@Override
public Void visit(ReturnEdge returnEdge) {
if (returnEdge.returnSite == null)
return null;
SootMethod method = context.icfg.getMethodOf(returnEdge.returnSite);
fanOut.getOrCreate(method).add(source);
dirty = true;
return null;
}
@Override
public Void visit(CallEdge callEdge) {
fanIn.getOrCreate(callEdge.destinationMethod).add(source);
dirty = true;
return null;
}
@Override
public Void visit(NormalEdge normalEdge) {
intra.getOrCreate(context.icfg.getMethodOf(normalEdge.curr)).add(source);
dirty = true;
return null;
}
});
}
@Override
public String[] getHeader() {
return new String[] { "Method", "FanIn", "FanOut", "Intra" };
}
@Override
public synchronized Object[][] getData() {
Set<SootMethod> keys = Sets.newHashSet();
keys.addAll(fanIn.keySet());
keys.addAll(fanOut.keySet());
keys.addAll(intra.keySet());
Object[][] result = new Object[keys.size()][4];
int i = 0;
for (SootMethod key : keys) {
result[i][0] = key;
result[i][1] = fanIn.getOrCreate(key).size();
result[i][2] = fanOut.getOrCreate(key).size();
result[i][3] = intra.getOrCreate(key).size();
i++;
}
dirty = false;
return result;
}
@Override
public synchronized void debugCallback(Object[][] data, int row, int col) {
SootMethod key = (SootMethod) data[row][0];
String methodName = (key.getDeclaringClass() + "." + key.getName()).replaceAll("[^\\w\\.]", "_");
plot(fanIn.getOrCreate(key), "debug/" + methodName + "_fanIn");
plot(fanOut.getOrCreate(key), "debug/" + methodName + "_fanOut");
plot(intra.getOrCreate(key), "debug/" + methodName + "_intra");
}
private void plot(Set<Trackable> data, String filename) {
DebugPlotter plotter = new DebugPlotter();
for (Trackable t : data) {
if (t.sourceUnit == null)
continue;
plotter.reportTrackable(new Report(context, t, t.sourceUnit));
}
plotter.writeFile(filename);
}
@Override
public synchronized boolean hasChanged() {
return dirty;
}
}
| 3,963 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
Debugger.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/debugger/Debugger.java | package flow.twist.debugger;
import java.util.List;
import java.util.Set;
import com.google.common.collect.Lists;
import flow.twist.config.AnalysisContext;
import flow.twist.ifds.FlowEdge;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.Trackable;
public class Debugger {
public enum EdgeType {
NORMAL, CALL, CALL2RETURN, RETURN
}
public static interface DebuggerListener {
public void kill(AnalysisContext context, Trackable source, Propagator propagator, FlowEdge edge);
public void propagate(AnalysisContext context, Trackable source, Set<Trackable> propagatedTaints, FlowEdge edge);
public Object[] getHeader();
public Object[][] getData();
public void debugCallback(Object[][] data, int row, int col);
public boolean hasChanged();
}
public static interface Filter {
/**
* @return false if edge should be ignored.
*/
public boolean filter(AnalysisContext context, FlowEdge edge);
}
private List<DebuggerListener> listeners = Lists.newLinkedList();
private boolean paused = false;
private List<Filter> filters = Lists.newLinkedList();
public Debugger() {
}
public void registerListener(DebuggerListener listener) {
listeners.add(listener);
}
public void kill(AnalysisContext context, Trackable source, Propagator propagator, FlowEdge edge) {
checkPause();
for (Filter filter : filters) {
if (!filter.filter(context, edge))
return;
}
for (DebuggerListener listener : listeners) {
listener.kill(context, source, propagator, edge);
}
}
public void propagate(AnalysisContext context, Trackable source, Set<Trackable> propagatedTaints, FlowEdge edge) {
checkPause();
for (Filter filter : filters) {
if (!filter.filter(context, edge))
return;
}
for (DebuggerListener listener : listeners) {
listener.propagate(context, source, propagatedTaints, edge);
}
}
private synchronized void checkPause() {
while (paused) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void pause() {
paused = true;
}
public synchronized void play() {
paused = false;
notifyAll();
}
public void addFilter(Filter filter) {
this.filters.add(filter);
}
}
| 2,230 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
TabularViewer.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/debugger/TabularViewer.java | package flow.twist.debugger;
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Comparator;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableRowSorter;
import flow.twist.debugger.Debugger.DebuggerListener;
public class TabularViewer {
private DebuggerListener listener;
private DefaultTableModel tableModel;
private Object[][] data;
private JButton pauseButton;
private boolean paused = false;
private Debugger debugger;
private JFrame frame;
public TabularViewer(final Debugger debugger, final DebuggerListener listener) {
this.debugger = debugger;
this.listener = listener;
frame = new JFrame();
pauseButton = new JButton("Pause");
pauseButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
if (paused) {
paused = false;
debugger.play();
pauseButton.setText("Pause");
} else {
paused = true;
debugger.pause();
pauseButton.setText("Play");
data = listener.getData();
tableModel.setDataVector(data, listener.getHeader());
}
}
});
frame.add(pauseButton, BorderLayout.NORTH);
tableModel = new DefaultTableModel();
tableModel.setColumnIdentifiers(listener.getHeader());
final JTable table = new JTable(tableModel);
final TableRowSorter<DefaultTableModel> sorter = new TableRowSorter<DefaultTableModel>(tableModel) {
@Override
public Comparator<?> getComparator(int column) {
return new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
if (o1.matches("\\d+") && o2.matches("\\d+")) {
return new Integer(Integer.parseInt(o1)).compareTo(Integer.parseInt(o2));
} else
return o1.compareTo(o2);
}
};
}
};
table.setRowSorter(sorter);
frame.add(new JScrollPane(table));
frame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
frame.setSize(400, 600);
frame.setVisible(true);
table.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
int row = table.rowAtPoint(e.getPoint());
listener.debugCallback(data, sorter.convertRowIndexToModel(row), table.columnAtPoint(e.getPoint()));
}
});
}
public void dispose() {
frame.setVisible(false);
frame.dispose();
}
}
| 2,533 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ConsoleDebugger.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/debugger/ConsoleDebugger.java | package flow.twist.debugger;
import java.util.Set;
import flow.twist.config.AnalysisContext;
import flow.twist.debugger.Debugger.DebuggerListener;
import flow.twist.ifds.FlowEdge;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.Trackable;
public class ConsoleDebugger implements DebuggerListener {
@Override
public void propagate(AnalysisContext context, Trackable source, Set<Trackable> propagatedTaints, FlowEdge edge) {
System.out.println("---Propagating---");
System.out.println("\t" + edge);
System.out.println("\tSource Taint: " + source);
System.out.println("\tNew Taints:");
for (Trackable trackable : propagatedTaints) {
System.out.println("\t\t" + trackable);
}
}
@Override
public void kill(AnalysisContext context, Trackable source, Propagator propagator, FlowEdge edge) {
System.out.println("---Kill---");
System.out.println("\t" + edge);
System.out.println("\tSource Taint: " + source);
System.out.println("\tKilled by: " + propagator.getClass().getName());
}
@Override
public boolean hasChanged() {
return false;
}
@Override
public Object[] getHeader() {
return null;
}
@Override
public Object[][] getData() {
return null;
}
@Override
public void debugCallback(Object[][] data, int row, int col) {
}
}
| 1,288 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ClassNameFilter.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/debugger/ClassNameFilter.java | package flow.twist.debugger;
import soot.Unit;
import flow.twist.config.AnalysisContext;
import flow.twist.ifds.FlowEdge;
import flow.twist.ifds.FlowEdge.Call2ReturnEdge;
import flow.twist.ifds.FlowEdge.CallEdge;
import flow.twist.ifds.FlowEdge.NormalEdge;
import flow.twist.ifds.FlowEdge.ReturnEdge;
import flow.twist.ifds.FlowEdge.Visitor;
public class ClassNameFilter implements Debugger.Filter {
private String[] classNames;
public ClassNameFilter(String[] classNames) {
this.classNames = classNames;
}
private boolean matchesClassName(AnalysisContext context, Unit unit) {
String candidateClassName = context.icfg.getMethodOf(unit).getDeclaringClass().getName();
for (String className : classNames) {
if (className.equals(candidateClassName))
return true;
}
return false;
}
@Override
public boolean filter(final AnalysisContext context, FlowEdge edge) {
return edge.accept(new Visitor<Boolean>() {
@Override
public Boolean visit(NormalEdge normalEdge) {
return matchesClassName(context, normalEdge.curr);
}
@Override
public Boolean visit(CallEdge callEdge) {
return matchesClassName(context, callEdge.callStmt);
}
@Override
public Boolean visit(ReturnEdge returnEdge) {
return matchesClassName(context, returnEdge.exitStmt);
}
@Override
public Boolean visit(Call2ReturnEdge call2ReturnEdge) {
return matchesClassName(context, call2ReturnEdge.callSite);
}
});
}
}
| 1,460 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ShortConsoleDebugger.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/debugger/ShortConsoleDebugger.java | package flow.twist.debugger;
import java.util.Set;
import flow.twist.config.AnalysisContext;
import flow.twist.debugger.Debugger.DebuggerListener;
import flow.twist.ifds.FlowEdge;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.Trackable;
public class ShortConsoleDebugger implements DebuggerListener {
@Override
public void propagate(AnalysisContext context, Trackable source, Set<Trackable> propagatedTaints, FlowEdge edge) {
for (Trackable trackable : propagatedTaints) {
if (source != trackable) {
System.out.println(System.identityHashCode(source) + "\t\t" + source + "\tpropagated over " + edge);
System.out.println("->\t" + System.identityHashCode(trackable) + "\t" + trackable);
}
}
}
@Override
public void kill(AnalysisContext context, Trackable source, Propagator propagator, FlowEdge edge) {
// System.out.println(System.identityHashCode(source) + " " + source +
// "\tkilled");
}
@Override
public boolean hasChanged() {
return false;
}
@Override
public Object[] getHeader() {
return null;
}
@Override
public Object[][] getData() {
return null;
}
@Override
public void debugCallback(Object[][] data, int row, int col) {
}
}
| 1,207 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
AnalysisConfiguration.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/config/AnalysisConfiguration.java | package flow.twist.config;
import flow.twist.debugger.Debugger;
import flow.twist.ifds.PropagatorProvider;
import flow.twist.reporter.IfdsReporter;
import flow.twist.targets.AnalysisTarget;
public class AnalysisConfiguration {
public final Iterable<AnalysisTarget> targets;
public final AnalysisDirection direction;
public final IfdsReporter reporter;
public final Type type;
public final Debugger debugger;
public final SeedFactory seedFactory;
public final PropagatorProvider propagatorProvider;
public AnalysisConfiguration(Iterable<AnalysisTarget> targets, AnalysisDirection direction, Type type, IfdsReporter reporter,
SeedFactory seedFactory, Debugger debugger, PropagatorProvider propagatorProvider) {
this.targets = targets;
this.direction = direction;
this.reporter = reporter;
this.type = type;
this.debugger = debugger;
this.seedFactory = seedFactory;
this.propagatorProvider = propagatorProvider;
}
public AnalysisConfiguration(AnalysisConfiguration config) {
this.targets = config.targets;
this.direction = config.direction;
this.reporter = config.reporter;
this.type = config.type;
this.debugger = config.debugger;
this.seedFactory = config.seedFactory;
this.propagatorProvider = config.propagatorProvider;
}
public static enum Type {
InnerToOuter, ForwardsFromAllParameters, ForwardsFromStringParameters
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Direction: ");
builder.append(direction);
builder.append("\n");
builder.append("Type: ");
builder.append(type);
builder.append("\n");
builder.append("Seed Factory: ");
builder.append(seedFactory == null ? "" : seedFactory.getClass().getSimpleName());
builder.append("\n");
builder.append("Analysis Targets:\n");
for (AnalysisTarget target : targets) {
builder.append("\t");
builder.append(target.getClass().getSimpleName());
builder.append("\n");
}
builder.append("Reporter:\n\t");
builder.append(reporter.toString());
return builder.toString();
}
}
| 2,071 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
AnalysisContext.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/config/AnalysisContext.java | package flow.twist.config;
import soot.SootMethod;
import soot.Unit;
import soot.jimple.toolkits.ide.icfg.BiDiInterproceduralCFG;
import flow.twist.ifds.Propagator;
public class AnalysisContext extends AnalysisConfiguration {
public final BiDiInterproceduralCFG<Unit, SootMethod> icfg;
public AnalysisContext(AnalysisConfiguration config, BiDiInterproceduralCFG<Unit, SootMethod> icfg) {
super(config);
this.icfg = icfg;
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append(super.toString());
builder.append("\n");
builder.append("Propagators:\n");
Propagator[][] propagators = propagatorProvider.provide(this);
for (Propagator[] outer : propagators) {
builder.append("\t{\n");
for (Propagator inner : outer) {
builder.append("\t\tnew ");
builder.append(inner.getClass().getName());
builder.append(",\n");
}
builder.append("\t},\n");
}
return builder.toString();
}
}
| 970 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
SeedFactory.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/config/SeedFactory.java | package flow.twist.config;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import soot.MethodOrMethodContext;
import soot.PatchingChain;
import soot.Scene;
import soot.SootMethod;
import soot.Unit;
import soot.jimple.IdentityStmt;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import flow.twist.ActiveBodyVerifier;
import flow.twist.targets.AnalysisTarget;
import flow.twist.util.AnalysisUtil;
public interface SeedFactory {
public Set<Unit> initialSeeds(AnalysisContext config);
public static class I2OSeedFactory implements SeedFactory {
@Override
public Set<Unit> initialSeeds(AnalysisContext config) {
Set<Unit> res = Sets.newHashSet();
for (Iterator<MethodOrMethodContext> iter = Scene.v().getReachableMethods().listener(); iter.hasNext();) {
SootMethod m = iter.next().method();
if (m.hasActiveBody() && !m.getName().equals("class$")) {
ActiveBodyVerifier.assertActive(m);
PatchingChain<Unit> units = m.getActiveBody().getUnits();
for (Unit u : units) {
Stmt s = (Stmt) u;
if (s.containsInvokeExpr()) {
InvokeExpr ie = s.getInvokeExpr();
if (isSink(config, m, s, ie)) {
res.add(u);
}
}
}
}
}
System.out.println("inner to outer initial seeds for direction " + config.direction + ": " + res.size());
return res;
}
private boolean isSink(AnalysisConfiguration config, SootMethod enclosingMethod, Stmt s, InvokeExpr ie) {
return matchesAtLeastOneTarget(config, enclosingMethod, ie);
}
private boolean matchesAtLeastOneTarget(AnalysisConfiguration config, SootMethod enclosingMethod, InvokeExpr ie) {
for (AnalysisTarget t : config.targets)
if (t.matches(config.direction, enclosingMethod, ie))
return true;
return false;
}
}
public class AllParameterOfTransitiveCallersSeedFactory implements SeedFactory {
@Override
public Set<Unit> initialSeeds(AnalysisContext config) {
List<Unit> worklist = Lists.newLinkedList((new I2OSeedFactory().initialSeeds(config)));
Set<SootMethod> visited = Sets.newHashSet();
Set<Unit> result = Sets.newHashSet();
while (!worklist.isEmpty()) {
Unit current = worklist.remove(0);
SootMethod method = config.icfg.getMethodOf(current);
if (visited.add(method)) {
if (AnalysisUtil.methodMayBeCallableFromApplication(method)) {
PatchingChain<Unit> units = method.getActiveBody().getUnits();
for (Unit u : units) {
if (u instanceof IdentityStmt) {
IdentityStmt idStmt = (IdentityStmt) u;
if (idStmt.getRightOp().toString().contains("@parameter"))
result.add(u);
}
}
} else {
worklist.addAll(config.icfg.getCallersOf(method));
}
}
}
System.out.println("forwards from all transitive callers parameters initial seeds: " + result.size());
return result;
}
}
public class AllParameterOfCallableMethodsSeedFactory implements SeedFactory {
@Override
public Set<Unit> initialSeeds(AnalysisContext config) {
Set<Unit> res = Sets.newHashSet();
for (Iterator<MethodOrMethodContext> iter = Scene.v().getReachableMethods().listener(); iter.hasNext();) {
SootMethod m = iter.next().method();
if (AnalysisUtil.methodMayBeCallableFromApplication(m) && m.hasActiveBody()) {
ActiveBodyVerifier.assertActive(m);
PatchingChain<Unit> units = m.getActiveBody().getUnits();
for (Unit u : units) {
if (u instanceof IdentityStmt) {
IdentityStmt idStmt = (IdentityStmt) u;
if (idStmt.getRightOp().toString().contains("@parameter"))
res.add(u);
}
}
}
}
System.out.println("forwards from all parameters initial seeds: " + res.size());
return res;
}
}
public class StringParameterOfTransitiveCallersSeedFactory implements SeedFactory {
@Override
public Set<Unit> initialSeeds(AnalysisContext config) {
List<Unit> worklist = Lists.newLinkedList((new I2OSeedFactory().initialSeeds(config)));
Set<SootMethod> visited = Sets.newHashSet();
Set<Unit> result = Sets.newHashSet();
while (!worklist.isEmpty()) {
Unit current = worklist.remove(0);
SootMethod method = config.icfg.getMethodOf(current);
if (visited.add(method)) {
if (AnalysisUtil.methodMayBeCallableFromApplication(method)) {
PatchingChain<Unit> units = method.getActiveBody().getUnits();
for (Unit u : units) {
if (u instanceof IdentityStmt) {
IdentityStmt idStmt = (IdentityStmt) u;
if (idStmt.getRightOp().toString().contains("@parameter")
&& idStmt.getRightOp().getType().toString().equals("java.lang.String"))
result.add(u);
}
}
} else {
worklist.addAll(config.icfg.getCallersOf(method));
}
}
}
System.out.println("forwards from string transitive callers parameters initial seeds: " + result.size());
return result;
}
}
public class StringParameterOfCallableMethodsSeedFactory implements SeedFactory {
@Override
public Set<Unit> initialSeeds(AnalysisContext config) {
Set<Unit> res = Sets.newHashSet();
for (Iterator<MethodOrMethodContext> iter = Scene.v().getReachableMethods().listener(); iter.hasNext();) {
SootMethod m = iter.next().method();
if (AnalysisUtil.methodMayBeCallableFromApplication(m) && m.hasActiveBody()) {
ActiveBodyVerifier.assertActive(m);
PatchingChain<Unit> units = m.getActiveBody().getUnits();
for (Unit u : units) {
if (u instanceof IdentityStmt) {
IdentityStmt idStmt = (IdentityStmt) u;
if (idStmt.getRightOp().toString().contains("@parameter")
&& idStmt.getRightOp().getType().toString().equals("java.lang.String"))
res.add(u);
}
}
}
}
System.out.println("forwards from string parameters initial seeds: " + res.size());
return res;
}
}
}
| 5,936 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
AnalysisConfigurationBuilder.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/config/AnalysisConfigurationBuilder.java | package flow.twist.config;
import java.util.ArrayList;
import com.google.common.collect.Lists;
import flow.twist.TransitiveSinkCaller;
import flow.twist.config.AnalysisConfiguration.Type;
import flow.twist.debugger.Debugger;
import flow.twist.ifds.Propagator;
import flow.twist.ifds.PropagatorProvider;
import flow.twist.propagator.JavaUtilKiller;
import flow.twist.propagator.PrimitiveTaintKiller;
import flow.twist.propagator.SpecificMethodKiller;
import flow.twist.propagator.backwards.ArgumentSourceHandler;
import flow.twist.propagator.backwards.ReturnValuePropagator;
import flow.twist.propagator.backwards.SinkHandler;
import flow.twist.propagator.forwards.ClassInstantiationPropagator;
import flow.twist.propagator.forwards.I2OSourceRecognizer;
import flow.twist.propagator.forwards.I2OZeroHandler;
import flow.twist.propagator.forwards.PayloadSourceRecognizer;
import flow.twist.propagator.forwards.ZeroAtParameterHandler;
import flow.twist.reporter.IfdsReporter;
import flow.twist.targets.AnalysisTarget;
import flow.twist.targets.GenericCallerSensitive;
import flow.twist.targets.SimpleClassForNameTarget;
import flow.twist.util.Pair;
public class AnalysisConfigurationBuilder {
private AnalysisConfiguration config;
private AnalysisConfigurationBuilder() {
config = new AnalysisConfiguration(new ArrayList<AnalysisTarget>(), null, null, null, null, null, null);
}
private AnalysisConfigurationBuilder(AnalysisConfiguration config) {
this.config = new AnalysisConfiguration(config);
}
public AnalysisConfiguration build() {
if (config.debugger == null)
throw new IllegalStateException("Debugger not set.");
if (config.direction == null)
throw new IllegalStateException("Analysis direction not set.");
if (config.propagatorProvider == null)
throw new IllegalStateException("PropagatorProvider not set.");
if (config.reporter == null)
throw new IllegalStateException("PropagatorReporter not set.");
if (config.seedFactory == null)
throw new IllegalStateException("SeedFactory not set.");
if (!config.targets.iterator().hasNext())
throw new IllegalStateException("Not a single AnalysisTarget has been set.");
if (config.type == null)
throw new IllegalStateException("No Type of analysis is set.");
return config;
}
public static AnalysisConfigurationBuilder i2oSimpleClassForNameDefaults() {
//@formatter:off
return new AnalysisConfigurationBuilder().targets(new SimpleClassForNameTarget())
.type(Type.InnerToOuter)
.seedFactory(new SeedFactory.I2OSeedFactory())
.debugger(new Debugger())
.propagator(new PropagatorProvider() {
@Override
public Propagator[][] provide(AnalysisContext context) {
TransitiveSinkCaller transitiveSinkCaller = new TransitiveSinkCaller(context);
if(context.direction == AnalysisDirection.FORWARDS) {
return new Propagator[][] {
{
new PrimitiveTaintKiller(),
new JavaUtilKiller(context),
new SpecificMethodKiller(context),
},
{
// new flow.twist.propagator.forwards.PropagateOverTarget(context)
},
{
new I2OZeroHandler(context),
new flow.twist.propagator.forwards.DefaultTaintPropagator(context),
new I2OSourceRecognizer(context, transitiveSinkCaller),
new ClassInstantiationPropagator()
}
};
} else {
return new Propagator[][] {
{
new PrimitiveTaintKiller(),
// new NonStringKiller(),
new JavaUtilKiller(context),
new SpecificMethodKiller(context),
},
{
new flow.twist.propagator.backwards.StringBuilderPropagator(),
new flow.twist.propagator.backwards.ShortcutPropagator(),
new flow.twist.propagator.backwards.PermissionCheckPropagator(),
// new flow.twist.propagator.backwards.PropagateOverTarget(context),
},
{
new SinkHandler(context),
new ReturnValuePropagator(),
new flow.twist.propagator.backwards.DefaultTaintPropagator(context),
new ArgumentSourceHandler(context, transitiveSinkCaller),
}
};
}
}
});
// @formatter:on
}
public static AnalysisConfigurationBuilder i2oGenericCallerSensitiveDefaults() {
//@formatter:off
return new AnalysisConfigurationBuilder().targets(new GenericCallerSensitive())
.type(Type.InnerToOuter)
.seedFactory(new SeedFactory.I2OSeedFactory())
.debugger(new Debugger())
.propagator(new PropagatorProvider() {
@Override
public Propagator[][] provide(AnalysisContext context) {
TransitiveSinkCaller transitiveSinkCaller = new TransitiveSinkCaller(context);
if(context.direction == AnalysisDirection.FORWARDS) {
return new Propagator[][] {
{
new PrimitiveTaintKiller(),
new JavaUtilKiller(context),
new SpecificMethodKiller(context),
},
{
new flow.twist.propagator.forwards.PropagateOverTarget(context)
},
{
new I2OZeroHandler(context),
new flow.twist.propagator.forwards.DefaultTaintPropagator(context),
new I2OSourceRecognizer(context, transitiveSinkCaller),
// new ClassInstantiationPropagator()
}
};
} else {
return new Propagator[][] {
{
new PrimitiveTaintKiller(),
// new NonStringKiller(),
new JavaUtilKiller(context),
new SpecificMethodKiller(context),
},
{
new flow.twist.propagator.backwards.StringBuilderPropagator(),
new flow.twist.propagator.backwards.ShortcutPropagator(),
new flow.twist.propagator.backwards.PermissionCheckPropagator(),
new flow.twist.propagator.backwards.PropagateOverTarget(context),
},
{
new SinkHandler(context),
new ReturnValuePropagator(),
new flow.twist.propagator.backwards.DefaultTaintPropagator(context),
new ArgumentSourceHandler(context, transitiveSinkCaller),
}
};
}
}
});
// @formatter:on
}
public static AnalysisConfigurationBuilder forwardsFromAllParametersDefaults(boolean genericCallerSensitive) {
return forwardsFromParametersDefaults(genericCallerSensitive).type(Type.ForwardsFromAllParameters).direction(AnalysisDirection.FORWARDS)
.seedFactory(new SeedFactory.AllParameterOfTransitiveCallersSeedFactory());
}
public static AnalysisConfigurationBuilder forwardsFromStringParametersDefaults(boolean genericCallerSensitive) {
return forwardsFromParametersDefaults(genericCallerSensitive).type(Type.ForwardsFromStringParameters).direction(AnalysisDirection.FORWARDS)
.seedFactory(new SeedFactory.StringParameterOfTransitiveCallersSeedFactory());
}
private static AnalysisConfigurationBuilder forwardsFromParametersDefaults(boolean genericCallerSensitive) {
AnalysisConfigurationBuilder confBuilder = new AnalysisConfigurationBuilder().debugger(new Debugger());
//@formatter:off
if (genericCallerSensitive)
return confBuilder.targets(new GenericCallerSensitive()).propagator(new PropagatorProvider() {
@Override
public Propagator[][] provide(AnalysisContext context) {
return new Propagator[][] {
{
new PrimitiveTaintKiller(),
new JavaUtilKiller(context),
},
{
new flow.twist.propagator.forwards.StringBuilderPropagator(),
new flow.twist.propagator.forwards.ShortcutPropagator(),
new flow.twist.propagator.forwards.PermissionCheckPropagator(),
new flow.twist.propagator.forwards.PropagateOverTarget(context),
},
{
new ZeroAtParameterHandler(context),
new flow.twist.propagator.forwards.DefaultTaintPropagator(context),
new PayloadSourceRecognizer(context),
}
};
}
});
else
return confBuilder.targets(new SimpleClassForNameTarget()).propagator(new PropagatorProvider() {
@Override
public Propagator[][] provide(AnalysisContext context) {
return new Propagator[][] {
{
new PrimitiveTaintKiller(),
new JavaUtilKiller(context),
},
{
new flow.twist.propagator.forwards.StringBuilderPropagator(),
new flow.twist.propagator.forwards.ShortcutPropagator(),
new flow.twist.propagator.forwards.PermissionCheckPropagator(),
new flow.twist.propagator.forwards.PropagateOverTarget(context),
},
{
new ZeroAtParameterHandler(context),
new flow.twist.propagator.forwards.DefaultTaintPropagator(context),
new PayloadSourceRecognizer(context),
new ClassInstantiationPropagator()
}
};
}
});
// @formatter:on
}
public AnalysisConfigurationBuilder type(Type type) {
return new AnalysisConfigurationBuilder(new AnalysisConfiguration(config.targets, config.direction, type, config.reporter,
config.seedFactory, config.debugger, config.propagatorProvider));
}
public AnalysisConfigurationBuilder seedFactory(SeedFactory seedFactory) {
return new AnalysisConfigurationBuilder(new AnalysisConfiguration(config.targets, config.direction, config.type, config.reporter,
seedFactory, config.debugger, config.propagatorProvider));
}
public AnalysisConfigurationBuilder targets(AnalysisTarget... targets) {
return new AnalysisConfigurationBuilder(new AnalysisConfiguration(Lists.newArrayList(targets), config.direction, config.type,
config.reporter, config.seedFactory, config.debugger, config.propagatorProvider));
}
public AnalysisConfigurationBuilder direction(AnalysisDirection direction) {
return new AnalysisConfigurationBuilder(new AnalysisConfiguration(config.targets, direction, config.type, config.reporter,
config.seedFactory, config.debugger, config.propagatorProvider));
}
public AnalysisConfigurationBuilder reporter(IfdsReporter reporter) {
return new AnalysisConfigurationBuilder(new AnalysisConfiguration(config.targets, config.direction, config.type, reporter,
config.seedFactory, config.debugger, config.propagatorProvider));
}
public Pair<IfdsReporter, AnalysisConfigurationBuilder> decorateReporter(PropagationReporterDecorator decorator) {
IfdsReporter reporter = decorator.decorate(config.reporter);
return Pair.pair(reporter, reporter(reporter));
}
public AnalysisConfigurationBuilder debugger(Debugger debugger) {
return new AnalysisConfigurationBuilder(new AnalysisConfiguration(config.targets, config.direction, config.type, config.reporter,
config.seedFactory, debugger, config.propagatorProvider));
}
public AnalysisConfigurationBuilder propagator(PropagatorProvider propagatorProvider) {
return new AnalysisConfigurationBuilder(new AnalysisConfiguration(config.targets, config.direction, config.type, config.reporter,
config.seedFactory, config.debugger, propagatorProvider));
}
@Override
public String toString() {
return config.toString();
}
public static interface PropagationReporterDecorator {
IfdsReporter decorate(IfdsReporter reporter);
}
}
| 11,173 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ResultForwardingReporter.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/reporter/ResultForwardingReporter.java | package flow.twist.reporter;
import java.util.List;
import com.google.common.collect.Lists;
import flow.twist.transformer.ResultTransformer;
public class ResultForwardingReporter implements IfdsReporter {
private ResultTransformer<Iterable<Report>, ?> transformer;
private List<Report> reports = Lists.newLinkedList();
public ResultForwardingReporter(ResultTransformer<Iterable<Report>, ?> transformer) {
this.transformer = transformer;
}
@Override
public void analysisFinished() {
transformer.transform(reports);
}
@Override
public void reportTrackable(Report report) {
reports.add(report);
}
@Override
public String toString() {
return getClass().getSimpleName() + "\n\t-> " + transformer.toString();
}
}
| 737 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
TrackableGraphPlotter.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/reporter/TrackableGraphPlotter.java | package flow.twist.reporter;
import static flow.twist.config.AnalysisDirection.FORWARDS;
import java.util.IdentityHashMap;
import java.util.Set;
import soot.SootMethod;
import att.grappa.Edge;
import att.grappa.Graph;
import att.grappa.Node;
import att.grappa.Subgraph;
import com.google.common.collect.Sets;
import flow.twist.config.AnalysisContext;
import flow.twist.trackable.PopFromStack;
import flow.twist.trackable.PushOnStack;
import flow.twist.trackable.Trackable;
import flow.twist.trackable.Zero;
import flow.twist.util.CacheMap;
import flow.twist.util.DotHelper;
public class TrackableGraphPlotter implements IfdsReporter {
private Graph graph;
private Set<TaintedEdge> edges = Sets.newHashSet();
private Set<Trackable> visitedNeighbors = Sets.newIdentityHashSet();
private CacheMap<SootMethod, Subgraph> methodSubgraphs = new CacheMap<SootMethod, Subgraph>() {
@Override
protected Subgraph createItem(SootMethod key) {
Subgraph subgraph = new Subgraph(graph, "cluster_" + methodSubgraphs.size());
subgraph.setAttribute("label", "\"" + key + "\"");
subgraph.setAttribute("style", "filled");
subgraph.setAttribute("color", "lightgrey");
return subgraph;
}
};
private IdentityHashMap<Trackable, Node> nodes = new IdentityHashMap<>();
public Node getOrCreateNode(Trackable trackable) {
if (!nodes.containsKey(trackable)) {
Subgraph subgraph = trackable.sourceUnit == null ? graph : methodSubgraphs.getOrCreate(currentContext.icfg
.getMethodOf(trackable.sourceUnit));
Node node = new Node(subgraph);
node.setAttribute("shape", "rectangle");
String label = trackable.sourceUnit + " \\n " + trackable + " " + System.identityHashCode(trackable);
if (trackable instanceof PopFromStack)
label += "\\n Pop: " + ((PopFromStack) trackable).getCallSite();
if (trackable instanceof PushOnStack)
label += "\\n Push: " + ((PushOnStack) trackable).getCallSite();
node.setAttribute("label", label);
if (trackable instanceof Zero) {
node.setAttribute("style", "filled");
node.setAttribute("fillcolor", "green");
}
subgraph.addNode(node);
nodes.put(trackable, node);
}
return nodes.get(trackable);
}
private AnalysisContext currentContext;
public TrackableGraphPlotter() {
graph = new Graph("debug graph");
graph.setAttribute("compound", "true");
}
@Override
public void reportTrackable(Report report) {
this.currentContext = report.context;
Node node = getOrCreateNode(report.trackable);
node.setAttribute("style", "filled");
node.setAttribute("fillcolor", report.context.direction == FORWARDS ? "orangered" : "lightblue");
createNeighborEdges(report.trackable, report.trackable);
}
private void createPredecessorEdges(Trackable trackable) {
if (trackable.predecessor != null) {
TaintedEdge taintedEdge = new TaintedEdge(trackable, trackable.predecessor);
if (edges.add(taintedEdge)) {
Edge edge = new Edge(graph, getOrCreateNode(trackable.predecessor), getOrCreateNode(trackable));
edge.setAttribute("color", (currentContext.direction == FORWARDS) ? "red" : "blue");
graph.addEdge(edge);
createNeighborEdges(trackable, trackable.predecessor);
}
}
}
private void createNeighborEdges(Trackable succ, Trackable trackable) {
if (!visitedNeighbors.add(trackable))
return;
for (Trackable neighbor : trackable.getSelfAndNeighbors()) {
if (trackable != neighbor) {
Edge edge = new Edge(graph, getOrCreateNode(neighbor), getOrCreateNode(succ));
edge.setAttribute("style", "dashed");
edge.setAttribute("color", (currentContext.direction == FORWARDS) ? "red" : "blue");
if (succ == trackable) {
edge.setAttribute("dir", "none");
edge.setAttribute("constraint", "false");
}
}
createPredecessorEdges(neighbor);
}
}
@Override
public void analysisFinished() {
}
public void writeFile(String filename) {
DotHelper.writeFilesForGraph(filename, graph);
}
private static class TaintedEdge {
private Trackable from;
private Trackable to;
public TaintedEdge(Trackable from, Trackable to) {
this.from = from;
this.to = to;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((from == null) ? 0 : System.identityHashCode(from));
result = prime * result + ((to == null) ? 0 : System.identityHashCode(to));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof TaintedEdge))
return false;
TaintedEdge other = (TaintedEdge) obj;
if (from == null) {
if (other.from != null)
return false;
} else if (from != other.from)
return false;
if (to == null) {
if (other.to != null)
return false;
} else if (to != other.to)
return false;
return true;
}
}
}
| 4,886 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ConsoleReporter.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/reporter/ConsoleReporter.java | package flow.twist.reporter;
public class ConsoleReporter implements IfdsReporter {
@Override
public void analysisFinished() {
}
@Override
public void reportTrackable(Report report) {
System.out.println("Reachable source " + report.targetUnit + " in method " + report.context.icfg.getMethodOf(report.targetUnit) + " by taint: "
+ report.trackable);
}
}
| 371 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
DelayingReporter.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/reporter/DelayingReporter.java | package flow.twist.reporter;
import java.util.Set;
import com.google.common.collect.Sets;
public class DelayingReporter implements IfdsReporter {
private IfdsReporter decoratee;
private Set<Report> reports;
public DelayingReporter(IfdsReporter decoratee) {
this.decoratee = decoratee;
reports = Sets.newHashSet();
}
@Override
public synchronized void reportTrackable(Report report) {
reports.add(report);
}
@Override
public void analysisFinished() {
System.out.println("Flushing " + reports.size() + " reports that were delayed.");
int i = 0;
for (Report report : reports) {
decoratee.reportTrackable(report);
}
decoratee.analysisFinished();
}
@Override
public String toString() {
return getClass().getSimpleName() + "\n\t-> " + decoratee.toString().replaceAll("\n", "\n\t");
}
}
| 822 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
CompositeReporter.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/reporter/CompositeReporter.java | package flow.twist.reporter;
public class CompositeReporter implements IfdsReporter {
private final IfdsReporter[] reporter;
public CompositeReporter(IfdsReporter... reporter) {
this.reporter = reporter;
}
@Override
public void analysisFinished() {
for (IfdsReporter r : reporter)
r.analysisFinished();
}
@Override
public void reportTrackable(Report report) {
for (IfdsReporter r : reporter) {
r.reportTrackable(report);
}
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder("[CompositeReporter:\n");
for (IfdsReporter r : reporter) {
builder.append("\t");
builder.append(r.toString().replaceAll("\n", "\n\t"));
builder.append(",\n");
}
builder.append("]\n");
return builder.toString();
}
}
| 771 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
DebugPlotter.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/reporter/DebugPlotter.java | package flow.twist.reporter;
import static flow.twist.config.AnalysisDirection.FORWARDS;
import java.util.Set;
import soot.SootMethod;
import soot.Unit;
import att.grappa.Edge;
import att.grappa.Graph;
import att.grappa.Node;
import att.grappa.Subgraph;
import com.google.common.collect.Sets;
import flow.twist.config.AnalysisContext;
import flow.twist.trackable.ReturnEdgeTaint;
import flow.twist.trackable.Trackable;
import flow.twist.util.AnalysisUtil;
import flow.twist.util.CacheMap;
import flow.twist.util.DotHelper;
public class DebugPlotter implements IfdsReporter {
private Graph graph;
private Set<TaintedEdge> edges = Sets.newHashSet();
private CacheMap<SootMethod, Subgraph> methodSubgraphs = new CacheMap<SootMethod, Subgraph>() {
@Override
protected Subgraph createItem(SootMethod key) {
Subgraph subgraph = new Subgraph(graph, "cluster_" + methodSubgraphs.size());
subgraph.setAttribute("label", "\"" + key.toString() + "\"");
subgraph.setAttribute("style", "filled");
subgraph.setAttribute("color", "lightgrey");
return subgraph;
}
};
private CacheMap<Unit, Node> nodes = new CacheMap<Unit, Node>() {
@Override
protected Node createItem(Unit key) {
SootMethod enclosingMethod = currentContext.icfg.getMethodOf(key);
Subgraph subgraph = methodSubgraphs.getOrCreate(enclosingMethod);
Node node = new Node(subgraph);
node.setAttribute("shape", "rectangle");
node.setAttribute("label", key.toString());
if (AnalysisUtil.isTarget(currentContext.direction, enclosingMethod, key, currentContext.targets)) {
node.setAttribute("style", "filled");
node.setAttribute("fillcolor", "green");
}
subgraph.addNode(node);
return node;
}
};
private AnalysisContext currentContext;
private PlotFilter filter;
public DebugPlotter() {
graph = new Graph("debug graph");
graph.setAttribute("compound", "true");
}
public DebugPlotter(PlotFilter filter) {
this();
this.filter = filter;
}
@Override
public void reportTrackable(Report report) {
this.currentContext = report.context;
for (Trackable neighbor : report.trackable.getSelfAndNeighbors())
createEdges(neighbor, report.targetUnit);
Node sourceNode = nodes.getOrCreate(report.targetUnit);
sourceNode.setAttribute("style", "filled");
sourceNode.setAttribute("fillcolor", report.context.direction == FORWARDS ? "red" : "blue");
}
@Override
public void analysisFinished() {
}
private void createEdges(Trackable trackable, Unit to) {
if (filter != null && !filter.include(currentContext, to))
return;
for (Trackable neighbor : trackable.getSelfAndNeighbors()) {
Unit currentTo = to;
if (neighbor.sourceUnit == null)
continue;
if (neighbor instanceof ReturnEdgeTaint) {
ReturnEdgeTaint retTaint = (ReturnEdgeTaint) neighbor;
createEdge(retTaint.callSite, currentTo, neighbor);
currentTo = retTaint.callSite;
}
if (createEdge(neighbor.sourceUnit, currentTo, neighbor))
createEdges(neighbor.predecessor, neighbor.sourceUnit);
}
}
private boolean createEdge(Unit from, Unit to, Trackable trackable) {
if (hasEdge(from, to, trackable))
return false;
edges.add(new TaintedEdge(from, trackable, to));
Edge edge = new Edge(graph, nodes.getOrCreate(from), nodes.getOrCreate(to));
edge.setAttribute("label", trackable.toString());
edge.setAttribute("color", (currentContext.direction == FORWARDS) ? "red" : "blue");
edge.setAttribute("fontcolor", (currentContext.direction == FORWARDS) ? "red" : "blue");
if (trackable instanceof ReturnEdgeTaint) {
edge.setAttribute("arrowhead", "onormal");
}
graph.addEdge(edge);
return true;
}
private boolean hasEdge(Unit from, Unit to, Trackable trackable) {
return edges.contains(new TaintedEdge(from, trackable, to));
}
public void writeFile(String filename) {
DotHelper.writeFilesForGraph(filename, graph);
}
private static class TaintedEdge {
public final Trackable trackable;
public final Unit source;
public final Unit target;
public TaintedEdge(Unit source, Trackable trackable, Unit target) {
this.source = source;
this.trackable = trackable;
this.target = target;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((source == null) ? 0 : source.hashCode());
result = prime * result + ((target == null) ? 0 : target.hashCode());
result = prime * result + ((trackable == null) ? 0 : System.identityHashCode(trackable));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
TaintedEdge other = (TaintedEdge) obj;
if (source == null) {
if (other.source != null)
return false;
} else if (!source.equals(other.source))
return false;
if (target == null) {
if (other.target != null)
return false;
} else if (!target.equals(other.target))
return false;
if (trackable != other.trackable) {
return false;
}
return true;
}
}
public static interface PlotFilter {
boolean include(AnalysisContext currentContext, Unit to);
}
}
| 5,208 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
IfdsReporter.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/reporter/IfdsReporter.java | package flow.twist.reporter;
public interface IfdsReporter {
void analysisFinished();
void reportTrackable(Report report);
}
| 131 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
Report.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/reporter/Report.java | package flow.twist.reporter;
import soot.Unit;
import flow.twist.config.AnalysisContext;
import flow.twist.trackable.Trackable;
public class Report {
public final AnalysisContext context;
public final Trackable trackable;
public final Unit targetUnit;
public Report(AnalysisContext context, Trackable trackable, Unit unit) {
this.context = context;
this.trackable = trackable;
this.targetUnit = unit;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((context == null) ? 0 : context.hashCode());
result = prime * result + ((trackable == null) ? 0 : System.identityHashCode(trackable));
result = prime * result + ((targetUnit == null) ? 0 : targetUnit.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Report other = (Report) obj;
if (context == null) {
if (other.context != null)
return false;
} else if (!context.equals(other.context))
return false;
if (trackable != other.trackable)
return false;
if (targetUnit == null) {
if (other.targetUnit != null)
return false;
} else if (!targetUnit.equals(other.targetUnit))
return false;
return true;
}
} | 1,322 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ResultTransformer.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/transformer/ResultTransformer.java | package flow.twist.transformer;
public abstract class ResultTransformer<From, To> {
private ResultTransformer<To, ?> successor;
public ResultTransformer(ResultTransformer<To, ?> successor) {
this.successor = successor;
}
public final void transform(From from) {
To to = transformAnalysisResults(from);
if (successor != null)
successor.transform(to);
}
protected abstract To transformAnalysisResults(From from);
@Override
public String toString() {
String debugInformation = debugInformation();
String debugString = debugInformation == null ? "" : " (" + debugInformation + ") ";
return getClass().getSimpleName() + debugString + (successor == null ? "" : "\n\t-> " + successor.toString());
}
protected String debugInformation() {
return null;
}
}
| 782 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PathToConsole.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/transformer/PathToConsole.java | package flow.twist.transformer;
import java.util.Set;
import flow.twist.path.Path;
public class PathToConsole extends ResultTransformer<Set<Path>, Void> {
public PathToConsole() {
super(null);
}
@Override
protected Void transformAnalysisResults(Set<Path> from) {
for (Path path : from) {
System.out.println(path.toContextAwareString());
System.out.println();
}
return null;
}
}
| 403 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
StoreDataTransformer.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/transformer/StoreDataTransformer.java | package flow.twist.transformer;
public class StoreDataTransformer<T> extends ResultTransformer<T, Void> {
private T data;
public StoreDataTransformer() {
super(null);
}
@Override
protected Void transformAnalysisResults(T from) {
this.data = from;
return null;
}
public T getData() {
return data;
}
}
| 322 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
FirstIntroductionSelectorStrategy.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/transformer/path/FirstIntroductionSelectorStrategy.java | package flow.twist.transformer.path;
import java.util.Collection;
import flow.twist.trackable.Trackable;
public abstract class FirstIntroductionSelectorStrategy {
public Iterable<Trackable> firstIntroductionOf(Trackable trackable) {
return firstIntroductionOf(trackable.getSelfAndNeighbors());
}
protected abstract Iterable<Trackable> firstIntroductionOf(Collection<Trackable> selfAndNeighbors);
}
| 408 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PathBuilderResultTransformer.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/transformer/path/PathBuilderResultTransformer.java | package flow.twist.transformer.path;
import java.util.Set;
import com.google.common.collect.Sets;
import fj.data.Option;
import flow.twist.AnalysisReporting;
import flow.twist.config.AnalysisContext;
import flow.twist.path.Path;
import flow.twist.pathchecker.PathChecker;
import flow.twist.reporter.Report;
import flow.twist.targets.AnalysisTarget;
import flow.twist.transformer.ResultTransformer;
public class PathBuilderResultTransformer extends ResultTransformer<Iterable<Report>, Set<Path>> {
private FirstIntroductionSelectorStrategy introductionStrategy;
private PathBuilder pathBuilder;
public PathBuilderResultTransformer(ResultTransformer<Set<Path>, ?> successor, FirstIntroductionSelectorStrategy introductionStrategy) {
super(successor);
this.introductionStrategy = introductionStrategy;
pathBuilder = new PathBuilder(introductionStrategy);
}
@Override
protected Set<Path> transformAnalysisResults(Iterable<Report> from) {
Set<Path> validPaths = Sets.newHashSet();
Set<PathChecker> pathCheckersInUse = Sets.newHashSet();
for (Report report : from) {
AnalysisReporting.startingPathsFor(report);
Set<Path> paths = pathBuilder.createPaths(report);
if (paths.size() == 0) {
System.err.println("0 paths created. BUG!?");
}
for (Path path : paths) {
pathCheckersInUse.addAll(addToMatchingPathChecker(report.context, path));
}
AnalysisReporting.finishedPathsFor(report, paths);
}
AnalysisReporting.combinedPathsStarting();
for (PathChecker checker : pathCheckersInUse) {
validPaths.addAll(checker.getValidPaths());
}
AnalysisReporting.combinedPathsFinished(validPaths);
return validPaths;
}
private Set<PathChecker> addToMatchingPathChecker(AnalysisContext context, Path path) {
Set<PathChecker> pathCheckersInUse = Sets.newHashSet();
for (AnalysisTarget target : context.targets) {
Option<PathChecker> pathChecker = target.getPathChecker(path);
if (pathChecker.isSome()) {
pathCheckersInUse.add(pathChecker.some());
pathChecker.some().addOrDismiss(path);
}
}
return pathCheckersInUse;
}
@Override
protected String debugInformation() {
return introductionStrategy.getClass().getSimpleName();
}
}
| 2,206 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PathBuilder.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/transformer/path/PathBuilder.java | package flow.twist.transformer.path;
import static flow.twist.trackable.Zero.ZERO;
import java.util.List;
import java.util.Set;
import soot.SootMethod;
import soot.Unit;
import soot.jimple.Stmt;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import flow.twist.path.Path;
import flow.twist.path.PathElement;
import flow.twist.reporter.Report;
import flow.twist.trackable.PopFromStack;
import flow.twist.trackable.PushOnStack;
import flow.twist.trackable.Trackable;
import flow.twist.util.AnalysisUtil;
import flow.twist.util.ImmutableHashSet;
import flow.twist.util.ImmutableIdentityHashSet;
public class PathBuilder {
private FirstIntroductionSelectorStrategy introductionStrategy;
private Set<Path> currentResults;
private List<WorklistItem> currentWorklist;
private Report currentReport;
public PathBuilder(FirstIntroductionSelectorStrategy introductionStrategy) {
this.introductionStrategy = introductionStrategy;
}
public Set<Path> createPaths(Report report) {
currentReport = report;
currentResults = Sets.newHashSet();
currentWorklist = initializeWorklist(report);
while (!currentWorklist.isEmpty()) {
processWorklistItem(currentWorklist.remove(0));
}
return currentResults;
}
protected void processWorklistItem(WorklistItem current) {
for (Trackable t : introductionStrategy.firstIntroductionOf(current.getFirstElement().trackable.predecessor)) {
if (t == ZERO) {
addResultingPath(current);
} else {
WorklistItemBuilder itemBuilder = new WorklistItemBuilder(current, t);
if (itemBuilder.isValid())
currentWorklist.add(itemBuilder.create());
}
}
}
protected void addResultingPath(WorklistItem current) {
currentResults.add(new Path(currentReport.context, current.pathElements, current.callStack, current.getFirstElement().from));
}
protected List<WorklistItem> initializeWorklist(Report report) {
List<WorklistItem> worklist = Lists.newLinkedList();
for (Trackable t : introductionStrategy.firstIntroductionOf(report.trackable)) {
WorklistItemBuilder itemBuilder = new WorklistItemBuilder(t, report.targetUnit);
if (itemBuilder.isValid())
worklist.add(itemBuilder.create());
}
return worklist;
}
protected Set<SootMethod> getInitialDeclaration(Unit callSite) {
return AnalysisUtil.getInitialDeclaration(((Stmt) callSite).getInvokeExpr().getMethod());
}
private static class WorklistItem {
private fj.data.List<ImmutableIdentityHashSet<Trackable>> trackables;
private fj.data.List<PathElement> pathElements;
private fj.data.List<Object> callStack;
private ImmutableHashSet<SootMethod> calledHierarchyMethods;
public WorklistItem(fj.data.List<ImmutableIdentityHashSet<Trackable>> trackables, fj.data.List<PathElement> pathElements,
fj.data.List<Object> callStack, ImmutableHashSet<SootMethod> calledHierarchyMethods) {
this.trackables = trackables;
this.pathElements = pathElements;
this.callStack = callStack;
this.calledHierarchyMethods = calledHierarchyMethods;
}
public PathElement getFirstElement() {
return pathElements.head();
}
}
private class WorklistItemBuilder {
private boolean valid;
private fj.data.List<ImmutableIdentityHashSet<Trackable>> trackables;
private fj.data.List<PathElement> pathElements;
private fj.data.List<Object> callStack;
private ImmutableHashSet<SootMethod> calledHierarchyMethods;
private WorklistItemBuilder(Trackable trackable, Unit targetUnit) {
trackables = fj.data.List.<ImmutableIdentityHashSet<Trackable>> single(ImmutableIdentityHashSet.<Trackable> empty());
pathElements = fj.data.List.<PathElement> nil();
callStack = fj.data.List.<Object> nil();
calledHierarchyMethods = ImmutableHashSet.<SootMethod> empty();
valid = add(trackable, targetUnit);
}
private WorklistItemBuilder(WorklistItem item, Trackable trackable) {
trackables = item.trackables;
pathElements = item.pathElements;
callStack = item.callStack;
calledHierarchyMethods = item.calledHierarchyMethods;
valid = add(trackable, item.getFirstElement().from);
}
public boolean isValid() {
return valid;
}
private boolean add(Trackable trackable, Unit targetUnit) {
if (!tryUpdateTrackables(trackable))
return false;
if (!tryUpdateCallStack(trackable))
return false;
if (!tryUpdateCalledHierarchyMethods(trackable))
return false;
updatePathElements(trackable, targetUnit);
return true;
}
public WorklistItem create() {
if (!valid)
throw new IllegalStateException();
return new WorklistItem(trackables, pathElements, callStack, calledHierarchyMethods);
}
private void updatePathElements(Trackable trackable, Unit targetUnit) {
pathElements = pathElements.cons(new PathElement(trackable.sourceUnit, trackable, targetUnit));
}
private boolean tryUpdateTrackables(Trackable trackable) {
if (trackable instanceof PushOnStack) {
ImmutableIdentityHashSet<Trackable> set = ImmutableIdentityHashSet.<Trackable> empty();
trackables = trackables.cons(set);
} else if (trackable instanceof PopFromStack) {
trackables = trackables.tail();
} else {
ImmutableIdentityHashSet<Trackable> set = trackables.head();
if (set.contains(trackable))
return false;
trackables = trackables.tail().cons(set.add(trackable));
}
return true;
}
private boolean tryUpdateCallStack(Trackable trackable) {
if (trackable instanceof PushOnStack) {
callStack = callStack.cons(((PushOnStack) trackable).getCallSite());
}
if (trackable instanceof PopFromStack) {
Unit callSite = ((PopFromStack) trackable).getCallSite();
if (callStack.isNotEmpty() && callStack.head().equals(callSite)) {
callStack = callStack.tail();
} else {
return false;
}
}
return true;
}
private boolean tryUpdateCalledHierarchyMethods(Trackable trackable) {
if (trackable instanceof PushOnStack) {
Set<SootMethod> methods = getInitialDeclaration(((PushOnStack) trackable).getCallSite());
ImmutableHashSet<SootMethod> newCalledHierarchyMethods = calledHierarchyMethods;
for (SootMethod m : methods) {
if (calledHierarchyMethods.contains(m))
return false;
else
newCalledHierarchyMethods = newCalledHierarchyMethods.add(m);
}
calledHierarchyMethods = newCalledHierarchyMethods;
} else if (trackable instanceof PopFromStack) {
Set<SootMethod> methods = getInitialDeclaration(((PopFromStack) trackable).getCallSite());
for (SootMethod m : methods) {
calledHierarchyMethods = calledHierarchyMethods.remove(m);
}
}
return true;
}
}
}
| 6,631 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
MergeEqualSelectorStrategy.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/transformer/path/MergeEqualSelectorStrategy.java | package flow.twist.transformer.path;
import static com.google.common.collect.Sets.newHashSet;
import static flow.twist.trackable.Zero.ZERO;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import com.google.common.base.Function;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import flow.twist.trackable.Trackable;
public class MergeEqualSelectorStrategy extends FirstIntroductionSelectorStrategy {
@Override
protected Iterable<Trackable> firstIntroductionOf(Collection<Trackable> selfAndNeighbors) {
Set<SourceDependentTrackableWrapper> result = newHashSet();
Set<Trackable> visited = Sets.newIdentityHashSet();
List<Trackable> worklist = Lists.newLinkedList(selfAndNeighbors);
while (!worklist.isEmpty()) {
Trackable current = worklist.remove(0);
if (current == ZERO || !current.equals(current.predecessor)) {
result.add(new SourceDependentTrackableWrapper(current));
} else {
for (Trackable t : current.predecessor.getSelfAndNeighbors()) {
if (visited.add(t))
worklist.add(t);
}
}
}
return Iterables.transform(result, new Function<SourceDependentTrackableWrapper, Trackable>() {
@Override
public Trackable apply(SourceDependentTrackableWrapper wrapper) {
return wrapper.trackable;
}
});
}
private static class SourceDependentTrackableWrapper {
private Trackable trackable;
private SourceDependentTrackableWrapper(Trackable trackable) {
this.trackable = trackable;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((trackable == null) ? 0 : trackable.hashCode() + (trackable.predecessor == null ? 0 : trackable.predecessor.hashCode()));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof SourceDependentTrackableWrapper))
return false;
SourceDependentTrackableWrapper other = (SourceDependentTrackableWrapper) obj;
if (trackable == null) {
if (other.trackable != null)
return false;
} else if (!trackable.equals(other.trackable) || trackable.sourceUnit != other.trackable.sourceUnit
|| trackable.predecessor != other.trackable.predecessor)
return false;
return true;
}
}
}
| 2,390 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
MergeIntraproceduralSelectorStrategy.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/transformer/path/MergeIntraproceduralSelectorStrategy.java | package flow.twist.transformer.path;
import static com.google.common.collect.Sets.newHashSet;
import static flow.twist.trackable.Zero.ZERO;
import java.util.Collection;
import java.util.List;
import java.util.Set;
import com.google.common.base.Function;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import flow.twist.trackable.PopFromStack;
import flow.twist.trackable.PushOnStack;
import flow.twist.trackable.Trackable;
public class MergeIntraproceduralSelectorStrategy extends FirstIntroductionSelectorStrategy {
@Override
protected Iterable<Trackable> firstIntroductionOf(Collection<Trackable> selfAndNeighbors) {
Set<SourceDependentTrackableWrapper> result = newHashSet();
Set<Trackable> visited = Sets.newIdentityHashSet();
List<Trackable> worklist = Lists.newLinkedList(selfAndNeighbors);
while (!worklist.isEmpty()) {
Trackable current = worklist.remove(0);
if (current == ZERO || current instanceof PushOnStack || current instanceof PopFromStack) {
result.add(new SourceDependentTrackableWrapper(current));
} else {
for (Trackable t : current.predecessor.getSelfAndNeighbors()) {
if (visited.add(t)) {
if (t == ZERO)
result.add(new SourceDependentTrackableWrapper(current));
else
worklist.add(t);
}
}
}
}
return Iterables.transform(result, new Function<SourceDependentTrackableWrapper, Trackable>() {
@Override
public Trackable apply(SourceDependentTrackableWrapper wrapper) {
return wrapper.trackable;
}
});
}
private static class SourceDependentTrackableWrapper {
private Trackable trackable;
private SourceDependentTrackableWrapper(Trackable trackable) {
this.trackable = trackable;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((trackable == null) ? 0 : trackable.hashCode() + (trackable.predecessor == null ? 0 : trackable.predecessor.hashCode()));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof SourceDependentTrackableWrapper))
return false;
SourceDependentTrackableWrapper other = (SourceDependentTrackableWrapper) obj;
if (trackable == null) {
if (other.trackable != null)
return false;
} else if (!trackable.equals(other.trackable) || trackable.sourceUnit != other.trackable.sourceUnit
|| trackable.predecessor != other.trackable.predecessor)
return false;
return true;
}
}
}
| 2,620 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PackageAccessCheckTarget.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/targets/PackageAccessCheckTarget.java | package flow.twist.targets;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import soot.SootMethod;
import soot.SootMethodRef;
import soot.Value;
import soot.jimple.Constant;
import soot.jimple.InvokeExpr;
import soot.jimple.NullConstant;
import soot.jimple.Stmt;
import fj.data.Option;
import flow.twist.config.AnalysisDirection;
import flow.twist.ifds.Propagator.KillGenInfo;
import flow.twist.path.Path;
import flow.twist.pathchecker.PathChecker;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
public class PackageAccessCheckTarget extends AnalysisTarget {
private boolean enabled;
@Override
public boolean matches(AnalysisDirection direction, SootMethod enclosingMethod, InvokeExpr ie) {
SootMethodRef method = ie.getMethodRef();
boolean matches = (method.declaringClass().getName().equals("sun.reflect.misc.ReflectUtil") || method.declaringClass().getName()
.equals("java.lang.SecurityManager"))
&& method.name().equals("checkPackageAccess");
return matches && !(ie.getArg(0) instanceof Constant);
}
@Override
public KillGenInfo processForwardCallToReturn(Trackable taint, Stmt callSite, InvokeExpr ie, Value left) {
return kill();
}
@Override
public KillGenInfo processBackwardCallToReturn(Trackable taint, Stmt callSite, InvokeExpr ie) {
if (!enabled)
return kill();
Value classNameArg = ie.getArg(0);
if (classNameArg instanceof NullConstant)
return KillGenInfo.kill();
Taint classNameTaint = new Taint(callSite, taint, classNameArg, ie.getMethod().getParameterType(0));
classNameTaint.addPayload("checkPackageAccess");
return KillGenInfo.propagate(classNameTaint);
}
@Override
public Option<PathChecker> getPathChecker(Path path) {
return Option.none();
}
@Override
public void enableIfDeferred() {
enabled = true;
}
}
| 1,831 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
AnalysisTarget.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/targets/AnalysisTarget.java | package flow.twist.targets;
import soot.SootMethod;
import soot.Unit;
import soot.Value;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
import fj.data.Option;
import flow.twist.config.AnalysisContext;
import flow.twist.config.AnalysisDirection;
import flow.twist.config.AnalysisConfiguration.Type;
import flow.twist.ifds.Propagator.KillGenInfo;
import flow.twist.path.Path;
import flow.twist.path.PathElement;
import flow.twist.pathchecker.EmptyCallStackChecker;
import flow.twist.pathchecker.PathChecker;
import flow.twist.pathchecker.StoreAnyPath;
import flow.twist.pathchecker.SubPathRemover;
import flow.twist.pathchecker.TwoPathChecker;
import flow.twist.trackable.Trackable;
public abstract class AnalysisTarget {
protected PathChecker forwardsFromCallablePathChecker;
protected PathChecker i2oPathChecker;
protected AnalysisTarget() {
i2oPathChecker = new TwoPathChecker(new SubPathRemover(new StoreAnyPath(this)));
forwardsFromCallablePathChecker = new EmptyCallStackChecker(new StoreAnyPath(this));
}
public abstract boolean matches(AnalysisDirection direction, SootMethod enclosingMethod, InvokeExpr ie);
public abstract KillGenInfo processForwardCallToReturn(Trackable taint, Stmt callSite, InvokeExpr ie, Value left);
public abstract KillGenInfo processBackwardCallToReturn(Trackable taint, Stmt callSite, InvokeExpr ie);
public Option<PathChecker> getPathChecker(Path path) {
if (path.context.type != Type.InnerToOuter) {
for (PathElement element : path) {
if (matches(path.context, element.from))
return Option.some(forwardsFromCallablePathChecker);
}
} else if (matches(path.context, path.getFirst()))
return Option.some(i2oPathChecker);
return Option.none();
}
protected boolean matches(AnalysisContext context, Unit unit) {
Stmt stmt = (Stmt) unit;
if (stmt.containsInvokeExpr()) {
InvokeExpr ie = stmt.getInvokeExpr();
SootMethod enclosingMethod = context.icfg.getMethodOf(stmt);
return matches(context.direction, enclosingMethod, ie);
} else
return false;
}
public abstract void enableIfDeferred();
} | 2,097 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
MethodInvokeTarget.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/targets/MethodInvokeTarget.java | package flow.twist.targets;
import flow.twist.config.AnalysisDirection;
import flow.twist.ifds.Propagator.KillGenInfo;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import soot.SootMethod;
import soot.Value;
import soot.jimple.InstanceInvokeExpr;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
/*
* Might be interesting to catch things as in Security Explorations Issue 61 - CVE-2013-2460
*/
public class MethodInvokeTarget extends AnalysisTarget {
@Override
public boolean matches(AnalysisDirection direction, SootMethod enclosingMethod, InvokeExpr ie) {
boolean matches = ie.getMethodRef().name().equals("invoke")
&& ie.getMethodRef().declaringClass().getName().equals("java.lang.reflect.Method");
return matches;
}
@Override
public KillGenInfo processForwardCallToReturn(Trackable taint, Stmt callSite, InvokeExpr ie, Value left) {
// TODO: taint invocation result if there is one?
return KillGenInfo.kill();
}
@Override
public KillGenInfo processBackwardCallToReturn(Trackable taint, Stmt callSite, InvokeExpr ie) {
Value methodObject = ((InstanceInvokeExpr) ie).getBase();
Taint methodObjectTaint = new Taint(callSite, taint, methodObject, methodObject.getType());
return KillGenInfo.propagate(methodObjectTaint);
}
@Override
public void enableIfDeferred() {
}
}
| 1,347 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
TargetFactory.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/targets/TargetFactory.java | package flow.twist.targets;
import java.util.ArrayList;
import java.util.List;
public class TargetFactory {
public static Iterable<AnalysisTarget> createTargets() {
List<AnalysisTarget> result = new ArrayList<AnalysisTarget>();
result.add(new SimpleClassForNameTarget());
// result.add(new ExtendedClassForNameTarget());
// result.add(new PackageAccessCheckTarget());
// result.add(new GenericCallerSensitive());
return result;
}
}
| 450 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ExtendedClassForNameTarget.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/targets/ExtendedClassForNameTarget.java | package flow.twist.targets;
import flow.twist.config.AnalysisDirection;
import flow.twist.ifds.Propagator.KillGenInfo;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import soot.SootMethod;
import soot.Value;
import soot.jimple.InvokeExpr;
import soot.jimple.NullConstant;
import soot.jimple.Stmt;
public class ExtendedClassForNameTarget extends AnalysisTarget {
@Override
public boolean matches(AnalysisDirection direction, SootMethod enclosingMethod, InvokeExpr ie) {
return ie.getMethodRef().name().equals("forName") && ie.getMethodRef().declaringClass().getName().equals("java.lang.Class")
&& ie.getMethodRef().parameterTypes().size() == 3;
}
@Override
public KillGenInfo processForwardCallToReturn(Trackable taint, Stmt callSite, InvokeExpr ie, Value left) {
Taint classInstance = new Taint(callSite, taint, left, ie.getMethod().getReturnType());
return KillGenInfo.propagate(classInstance);
}
@Override
public KillGenInfo processBackwardCallToReturn(Trackable taint, Stmt callSite, InvokeExpr ie) {
Value classNameArg = ie.getArg(0);
Value classLoaderArg = ie.getArg(2);
if (classNameArg instanceof NullConstant || classLoaderArg instanceof NullConstant)
return KillGenInfo.kill();
SootMethod method = ie.getMethod();
Taint classNameParameter = new Taint(callSite, taint, classNameArg, method.getParameterType(0));
Taint classLoaderParameter = new Taint(callSite, taint, classLoaderArg, method.getParameterType(2));
return KillGenInfo.propagate(classNameParameter, classLoaderParameter);
}
@Override
public void enableIfDeferred() {
}
}
| 1,617 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
GenericCallerSensitive.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/targets/GenericCallerSensitive.java | package flow.twist.targets;
import static fj.data.Option.none;
import static fj.data.Option.some;
import static flow.twist.config.AnalysisDirection.BACKWARDS;
import static flow.twist.config.AnalysisDirection.FORWARDS;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import static flow.twist.ifds.Propagator.KillGenInfo.propagate;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import soot.MethodOrMethodContext;
import soot.PrimType;
import soot.Scene;
import soot.SootMethod;
import soot.Type;
import soot.Value;
import soot.VoidType;
import soot.jimple.Constant;
import soot.jimple.InstanceInvokeExpr;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
import soot.tagkit.AnnotationTag;
import soot.tagkit.Tag;
import soot.tagkit.VisibilityAnnotationTag;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import fj.data.Option;
import flow.twist.config.AnalysisConfiguration;
import flow.twist.config.AnalysisDirection;
import flow.twist.ifds.Propagator.KillGenInfo;
import flow.twist.path.Path;
import flow.twist.pathchecker.PathChecker;
import flow.twist.pathchecker.StoreAnyPath;
import flow.twist.pathchecker.SubPathRemover;
import flow.twist.pathchecker.TwoPathChecker;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import flow.twist.util.CacheMap;
public class GenericCallerSensitive extends AnalysisTarget {
private Set<SootMethod> sensitiveMethods = Sets.newHashSet();
private CacheMap<SootMethod, PathChecker> pathChecker = new CacheMap<SootMethod, PathChecker>() {
@Override
protected PathChecker createItem(SootMethod method) {
if (matches(FORWARDS, method) && matches(BACKWARDS, method)) {
return new TwoPathChecker(new SubPathRemover(new StoreAnyPath(GenericCallerSensitive.this)));
} else {
return new StoreAnyPath(GenericCallerSensitive.this);
}
}
};
public GenericCallerSensitive() {
for (Iterator<MethodOrMethodContext> iter = Scene.v().getReachableMethods().listener(); iter.hasNext();) {
SootMethod m = iter.next().method();
for (Tag tag : m.getTags()) {
if (tag instanceof VisibilityAnnotationTag) {
for (AnnotationTag annotation : ((VisibilityAnnotationTag) tag).getAnnotations()) {
if (annotation.getType().equals("Lsun/reflect/CallerSensitive;")) {
if (hasTaintableValueForDirection(FORWARDS, m) && hasTaintableValueForDirection(BACKWARDS, m))
sensitiveMethods.add(m);
}
}
}
}
}
}
@Override
public boolean matches(AnalysisDirection direction, SootMethod enclosingMethod, InvokeExpr ie) {
return matches(direction, ie.getMethod());
}
private boolean matches(AnalysisDirection direction, SootMethod method) {
if (!sensitiveMethods.contains(method))
return false;
return hasTaintableValueForDirection(direction, method);
}
protected boolean hasTaintableValueForDirection(AnalysisDirection direction, SootMethod method) {
if (direction == BACKWARDS) {
if (!method.isStatic())
return true;
for (Type parameterType : method.getParameterTypes()) {
if (!(parameterType instanceof PrimType)) {
return true;
}
}
return false;
} else {
return !(method.getReturnType() instanceof VoidType);
}
}
@Override
public KillGenInfo processForwardCallToReturn(Trackable taint, Stmt callSite, InvokeExpr ie, Value left) {
return propagate(new Taint(callSite, taint, left, ie.getMethod().getReturnType()));
}
@Override
public KillGenInfo processBackwardCallToReturn(Trackable taint, Stmt callSite, InvokeExpr ie) {
SootMethod method = ie.getMethod();
List<Taint> taints = Lists.newLinkedList();
if (ie instanceof InstanceInvokeExpr) {
Value receiver = ((InstanceInvokeExpr) ie).getBase();
taints.add(new Taint(callSite, taint, receiver, receiver.getType()));
}
for (int i = 0; i < method.getParameterCount(); i++) {
Type parameterType = method.getParameterType(i);
if (!(parameterType instanceof PrimType) && !(ie.getArg(i) instanceof Constant)) {
taints.add(new Taint(callSite, taint, ie.getArg(i), parameterType));
}
}
if (taints.isEmpty())
return kill();
else
return propagate(taints.toArray(new Taint[taints.size()]));
}
@Override
public void enableIfDeferred() {
}
@Override
public Option<PathChecker> getPathChecker(Path path) {
if (path.context.type != AnalysisConfiguration.Type.InnerToOuter)
return super.getPathChecker(path);
Stmt stmt = (Stmt) path.getFirst();
if (stmt.containsInvokeExpr()) {
InvokeExpr ie = stmt.getInvokeExpr();
SootMethod enclosingMethod = path.context.icfg.getMethodOf(stmt);
if (matches(path.context.direction, enclosingMethod, ie)) {
return some(pathChecker.getOrCreate(ie.getMethod()));
}
}
return none();
}
public Set<SootMethod> getSensitiveMethods() {
return sensitiveMethods;
}
}
| 4,870 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
SimpleClassForNameTarget.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/targets/SimpleClassForNameTarget.java | package flow.twist.targets;
import flow.twist.config.AnalysisDirection;
import flow.twist.ifds.Propagator.KillGenInfo;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import soot.SootMethod;
import soot.Value;
import soot.jimple.Constant;
import soot.jimple.InvokeExpr;
import soot.jimple.NullConstant;
import soot.jimple.Stmt;
public class SimpleClassForNameTarget extends AnalysisTarget {
/*
* (non-Javadoc)
*
* @see targets.AnalysisTarget#matches(soot.jimple.InvokeExpr)
*/
@Override
public boolean matches(AnalysisDirection direction, SootMethod enclosingMethod, InvokeExpr ie) {
boolean matches = ie.getMethodRef().name().equals("forName") && ie.getMethodRef().declaringClass().getName().equals("java.lang.Class")
&& ie.getMethodRef().parameterTypes().size() == 1;
if (matches && !(ie.getArg(0) instanceof Constant)) {
return true;
}
return false;
}
/*
* (non-Javadoc)
*
* @see
* targets.AnalysisTarget#processForwardCallToReturn(permissionAnalysis.
* trackables.Trackable, soot.jimple.Stmt, soot.jimple.InvokeExpr,
* soot.Value)
*/
@Override
public KillGenInfo processForwardCallToReturn(Trackable taint, Stmt callSite, InvokeExpr ie, Value left) {
Taint classInstance = new Taint(callSite, taint, left, ie.getMethod().getReturnType());
return KillGenInfo.propagate(classInstance);
}
/*
* (non-Javadoc)
*
* @see
* targets.AnalysisTarget#processBackwardCallToReturn(permissionAnalysis
* .trackables.Trackable, soot.jimple.Stmt, soot.jimple.InvokeExpr)
*/
@Override
public KillGenInfo processBackwardCallToReturn(Trackable taint, Stmt callSite, InvokeExpr ie) {
Value classNameArg = ie.getArg(0);
if (classNameArg instanceof NullConstant)
return KillGenInfo.kill();
Taint classNameParameter = new Taint(callSite, taint, classNameArg, ie.getMethod().getParameterType(0));
return KillGenInfo.propagate(classNameParameter);
}
@Override
public void enableIfDeferred() {
}
}
| 1,991 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
FlowEdge.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/ifds/FlowEdge.java | package flow.twist.ifds;
import soot.SootMethod;
import soot.Unit;
import soot.jimple.Stmt;
public abstract class FlowEdge {
public abstract <T> T accept(Visitor<T> visitor);
public static interface Visitor<T> {
T visit(NormalEdge normalEdge);
T visit(CallEdge callEdge);
T visit(ReturnEdge returnEdge);
T visit(Call2ReturnEdge call2ReturnEdge);
}
public static class NormalEdge extends FlowEdge {
public final Unit curr;
public final Unit succ;
public NormalEdge(Unit curr, Unit succ) {
this.curr = curr;
this.succ = succ;
}
@Override
public <T> T accept(Visitor<T> visitor) {
return visitor.visit(this);
}
@Override
public String toString() {
return "[normal] " + curr.toString();
}
}
public static class CallEdge extends FlowEdge {
public final Unit callStmt;
public final SootMethod destinationMethod;
public CallEdge(Unit callStmt, SootMethod destinationMethod) {
this.callStmt = callStmt;
this.destinationMethod = destinationMethod;
}
@Override
public <T> T accept(Visitor<T> visitor) {
return visitor.visit(this);
}
@Override
public String toString() {
return "[call] " + callStmt + " - " + destinationMethod;
}
}
public static class ReturnEdge extends FlowEdge {
public final Unit callSite;
public final SootMethod calleeMethod;
public final Unit exitStmt;
public final Unit returnSite;
public ReturnEdge(Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
this.callSite = callSite;
this.calleeMethod = calleeMethod;
this.exitStmt = exitStmt;
this.returnSite = returnSite;
}
@Override
public <T> T accept(Visitor<T> visitor) {
return visitor.visit(this);
}
@Override
public String toString() {
return "[return] " + returnSite + " (" + callSite + ")";
}
}
public static class Call2ReturnEdge extends FlowEdge {
public final Stmt callSite;
public final Unit returnSite;
public Call2ReturnEdge(Stmt callSite, Unit returnSite) {
this.callSite = callSite;
this.returnSite = returnSite;
}
@Override
public <T> T accept(Visitor<T> visitor) {
return visitor.visit(this);
}
@Override
public String toString() {
return "[call2ret] " + callSite;
}
}
}
| 2,256 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PropagatorProvider.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/ifds/PropagatorProvider.java | package flow.twist.ifds;
import flow.twist.config.AnalysisContext;
public interface PropagatorProvider {
Propagator[][] provide(AnalysisContext context);
}
| 161 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
Propagator.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/ifds/Propagator.java | package flow.twist.ifds;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import flow.twist.trackable.Trackable;
import soot.SootMethod;
import soot.Unit;
import soot.jimple.Stmt;
public interface Propagator {
boolean canHandle(Trackable trackable);
KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ);
KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod);
KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite);
KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite);
public static class KillGenInfo {
protected final Collection<? extends Trackable> gen;
public final boolean kill;
private static final KillGenInfo ID = new KillGenInfo(false, Collections.<Trackable> emptySet());
public KillGenInfo(boolean kill, Collection<? extends Trackable> gen) {
this.kill = kill;
this.gen = gen;
}
public Collection<? extends Trackable> gen() {
return gen;
}
public static KillGenInfo kill() {
return new KillGenInfo(true, Collections.<Trackable> emptySet());
}
public static KillGenInfo gen(Trackable... gen) {
if (gen.length == 0)
throw new IllegalArgumentException();
return new KillGenInfo(false, Arrays.asList(gen));
}
public static KillGenInfo propagate(Trackable... gen) {
if (gen.length == 0)
throw new IllegalArgumentException();
return new KillGenInfo(true, Arrays.asList(gen));
}
public static KillGenInfo identity() {
return ID;
}
}
}
| 1,619 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
TabulationProblem.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/ifds/TabulationProblem.java | package flow.twist.ifds;
import heros.DefaultSeeds;
import heros.FlowFunctions;
import java.util.Map;
import java.util.Set;
import soot.SootMethod;
import soot.Unit;
import soot.jimple.toolkits.ide.DefaultJimpleIFDSTabulationProblem;
import soot.jimple.toolkits.ide.icfg.BackwardsInterproceduralCFG;
import soot.jimple.toolkits.ide.icfg.BiDiInterproceduralCFG;
import soot.jimple.toolkits.ide.icfg.JimpleBasedInterproceduralCFG;
import flow.twist.config.AnalysisConfiguration;
import flow.twist.config.AnalysisContext;
import flow.twist.config.AnalysisDirection;
import flow.twist.targets.AnalysisTarget;
import flow.twist.trackable.Trackable;
import flow.twist.trackable.Zero;
public class TabulationProblem extends DefaultJimpleIFDSTabulationProblem<Trackable, BiDiInterproceduralCFG<Unit, SootMethod>> {
private AnalysisContext context;
private FlowFunctionFactory flowFunctionFactory;
public TabulationProblem(AnalysisConfiguration config) {
super(makeICFG(config.direction));
this.context = new AnalysisContext(config, interproceduralCFG());
flowFunctionFactory = new FlowFunctionFactory(this.context);
}
private static BiDiInterproceduralCFG<Unit, SootMethod> makeICFG(AnalysisDirection direction) {
JimpleBasedInterproceduralCFG fwdIcfg = new JimpleBasedInterproceduralCFG();
if (direction == AnalysisDirection.FORWARDS)
return fwdIcfg;
else
return new BackwardsInterproceduralCFG(fwdIcfg);
}
@Override
public Map<Unit, Set<Trackable>> initialSeeds() {
return DefaultSeeds.make(context.seedFactory.initialSeeds(context), zeroValue());
}
public void startReturningDeferredTargets() {
for (AnalysisTarget target : context.targets) {
target.enableIfDeferred();
}
}
@Override
protected FlowFunctions<Unit, Trackable, SootMethod> createFlowFunctionsFactory() {
return flowFunctionFactory;
}
@Override
protected Trackable createZeroValue() {
return Zero.ZERO;
}
@Override
public boolean autoAddZero() {
return false;
}
@Override
public boolean followReturnsPastSeeds() {
// unbalanced analysis problem
return true;
}
@Override
public boolean computeValues() {
return false;
}
public AnalysisContext getContext() {
return context;
}
}
| 2,219 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
FlowFunctionFactory.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/ifds/FlowFunctionFactory.java | package flow.twist.ifds;
import flow.twist.config.AnalysisContext;
import flow.twist.ifds.FlowEdge.Call2ReturnEdge;
import flow.twist.ifds.FlowEdge.CallEdge;
import flow.twist.ifds.FlowEdge.NormalEdge;
import flow.twist.ifds.FlowEdge.ReturnEdge;
import flow.twist.ifds.FlowEdge.Visitor;
import flow.twist.ifds.Propagator.KillGenInfo;
import flow.twist.trackable.Trackable;
import heros.FlowFunction;
import heros.FlowFunctions;
import java.util.Arrays;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import soot.SootMethod;
import soot.Unit;
import soot.jimple.Stmt;
import com.google.common.base.Predicate;
import com.google.common.collect.Iterables;
import com.google.common.collect.Sets;
public class FlowFunctionFactory implements FlowFunctions<Unit, Trackable, SootMethod> {
public static AtomicInteger propCounter = new AtomicInteger(0);
private Propagator[][] propagators;
private AnalysisContext context;
public FlowFunctionFactory(AnalysisContext context) {
this.context = context;
propagators = context.propagatorProvider.provide(context);
}
private Iterable<Propagator> matchingPropagators(final Trackable taint, Propagator[] phase) {
return Iterables.filter(Arrays.asList(phase), new Predicate<Propagator>() {
@Override
public boolean apply(Propagator propagator) {
return propagator.canHandle(taint);
}
});
}
private FlowFunction<Trackable> propagate(final FlowEdge edge) {
propCounter.incrementAndGet();
return new FlowFunction<Trackable>() {
@Override
public Set<Trackable> computeTargets(final Trackable source) {
final Set<Trackable> propagatedTaints = Sets.newHashSet();
boolean killed = false;
for (Propagator[] phase : propagators) {
for (Propagator propagator : matchingPropagators(source, phase)) {
PropagatorVisitor visitor = new PropagatorVisitor(propagator, source);
KillGenInfo killGen = edge.accept(visitor);
propagatedTaints.addAll(killGen.gen());
killed |= killGen.kill;
if (killGen.kill) {
context.debugger.kill(context, source, propagator, edge);
}
}
if (killed)
break;
}
if (!killed) {
// identity propagations
// propagatedTaints.add(source);
propagatedTaints.add(edge.accept(new Visitor<Trackable>() {
@Override
public Trackable visit(Call2ReturnEdge call2ReturnEdge) {
// TODO: unclear if necessary to create an alias
return source.createAlias(call2ReturnEdge.callSite);
// return source;
}
@Override
public Trackable visit(ReturnEdge returnEdge) {
// identity doesn't make any sense
throw new IllegalStateException();
}
@Override
public Trackable visit(CallEdge callEdge) {
// identity doesn't make any sense
throw new IllegalStateException();
}
@Override
public Trackable visit(NormalEdge normalEdge) {
// TODO: Here a real difference occurs. Not sure,
// why.
return source.createAlias(normalEdge.curr);
// return source;
}
}));
}
if (!propagatedTaints.isEmpty())
context.debugger.propagate(context, source, propagatedTaints, edge);
return propagatedTaints;
}
};
}
@Override
public FlowFunction<Trackable> getNormalFlowFunction(final Unit curr, final Unit succ) {
return propagate(new NormalEdge(curr, succ));
}
@Override
public FlowFunction<Trackable> getCallFlowFunction(final Unit callStmt, final SootMethod destinationMethod) {
return propagate(new FlowEdge.CallEdge(callStmt, destinationMethod));
}
@Override
public FlowFunction<Trackable> getReturnFlowFunction(final Unit callSite, final SootMethod calleeMethod,
final Unit exitStmt, final Unit returnSite) {
return propagate(new FlowEdge.ReturnEdge(callSite, calleeMethod, exitStmt, returnSite));
}
@Override
public FlowFunction<Trackable> getCallToReturnFlowFunction(final Unit callSite, final Unit returnSite) {
return propagate(new FlowEdge.Call2ReturnEdge((Stmt) callSite, returnSite));
}
private static class PropagatorVisitor implements FlowEdge.Visitor<KillGenInfo> {
private Propagator propagator;
private Trackable source;
public PropagatorVisitor(Propagator propagator, Trackable source) {
this.propagator = propagator;
this.source = source;
}
@Override
public KillGenInfo visit(NormalEdge normalEdge) {
return propagator.propagateNormalFlow(source, normalEdge.curr, normalEdge.succ);
}
@Override
public KillGenInfo visit(CallEdge callEdge) {
return propagator.propagateCallFlow(source, callEdge.callStmt, callEdge.destinationMethod);
}
@Override
public KillGenInfo visit(ReturnEdge returnEdge) {
return propagator.propagateReturnFlow(source, returnEdge.callSite, returnEdge.calleeMethod,
returnEdge.exitStmt, returnEdge.returnSite);
}
@Override
public KillGenInfo visit(Call2ReturnEdge call2ReturnEdge) {
return propagator.propagateCallToReturnFlow(source, call2ReturnEdge.callSite);
}
}
}
| 5,045 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PushOnStack.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/trackable/PushOnStack.java | package flow.twist.trackable;
import soot.Unit;
public interface PushOnStack {
public Unit getCallSite();
public int getParameterIndex();
}
| 146 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
Trackable.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/trackable/Trackable.java | package flow.twist.trackable;
import heros.solver.LinkedNode;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import soot.Unit;
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
public abstract class Trackable implements LinkedNode<Trackable> {
public final Trackable predecessor;
public final Unit sourceUnit;
private final List<Trackable> neighbors;
private final Set<Object> payload;
protected Trackable() {
this.predecessor = null;
this.sourceUnit = null;
payload = Sets.newHashSet();
neighbors = Lists.newLinkedList();
}
public Trackable(Unit sourceUnit, Trackable predecessor) {
this.predecessor = predecessor;
this.sourceUnit = sourceUnit;
payload = Sets.newHashSet();
neighbors = Lists.newLinkedList();
payload.addAll(predecessor.payload);
}
public void addPayload(Object payload) {
this.payload.add(payload);
}
public void addNeighbor(Trackable trackable) {
// trackable.neighbors.addAll(getSelfAndNeighbors());
neighbors.add(trackable);
}
public Collection<Trackable> getSelfAndNeighbors() {
LinkedList<Trackable> result = Lists.newLinkedList(neighbors);
result.add(this);
return result;
}
public boolean hasSelfOrNeighborAnPredecessor() {
for (Trackable t : getSelfAndNeighbors())
if (t.predecessor != null)
return true;
return false;
}
public abstract Trackable cloneWithoutNeighborsAndPayload();
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((payload == null) ? 0 : payload.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Trackable))
return false;
Trackable other = (Trackable) obj;
if (payload == null) {
if (other.payload != null)
return false;
} else if (!payload.equals(other.payload))
return false;
return true;
}
public String payloadString() {
if (payload.size() == 0)
return "";
return "(" + Joiner.on(",").join(payload) + ")";
}
public abstract Trackable createAlias(Unit sourceUnits);
public Collection<Object> getPayload() {
return payload;
}
}
| 2,291 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ReturnValueTaint.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/trackable/ReturnValueTaint.java | package flow.twist.trackable;
import soot.Type;
import soot.Unit;
public class ReturnValueTaint extends Trackable implements PopFromStack {
public final Type type;
public ReturnValueTaint(Unit sourceUnit, Trackable predecessor, Type type) {
super(sourceUnit, predecessor);
this.type = type;
}
@Override
public String toString() {
return "ReturnValue" + payloadString();
}
@Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + ((type == null) ? 0 : type.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!super.equals(obj))
return false;
if (!(obj instanceof ReturnValueTaint))
return false;
ReturnValueTaint other = (ReturnValueTaint) obj;
if (type == null) {
if (other.type != null)
return false;
} else if (!type.equals(other.type))
return false;
return true;
}
@Override
public Trackable createAlias(Unit sourceUnit) {
throw new IllegalStateException("Never propagate ReturnValueTaint, thus don't create any alias.");
}
@Override
public ReturnValueTaint cloneWithoutNeighborsAndPayload() {
return new ReturnValueTaint(sourceUnit, predecessor, type);
}
@Override
public Unit getCallSite() {
return sourceUnit;
}
}
| 1,319 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ParameterTaint.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/trackable/ParameterTaint.java | package flow.twist.trackable;
import soot.Type;
import soot.Unit;
import soot.Value;
public class ParameterTaint extends Taint implements PopFromStack {
public ParameterTaint(Unit sourceUnit, Trackable predecessor, Value value, Type type) {
super(sourceUnit, predecessor, value, type);
}
@Override
public String toString() {
return "[ParameterTaint" + payloadString() + ": " + value + "]";
}
@Override
public Unit getCallSite() {
return sourceUnit;
}
}
| 472 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
Taint.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/trackable/Taint.java | package flow.twist.trackable;
import soot.Type;
import soot.Unit;
import soot.Value;
import soot.jimple.Constant;
public class Taint extends Trackable {
public final Value value;
public final Type type;
public Taint(Unit sourceUnit, Trackable predecessor, Value value, Type type) {
super(sourceUnit, predecessor);
if (value instanceof Constant) {
throw new IllegalArgumentException("Constant value has been tainted.");
}
this.value = value;
this.type = type;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!super.equals(obj))
return false;
if (!(obj instanceof Taint))
return false;
Taint other = (Taint) obj;
if (type == null) {
if (other.type != null)
return false;
} else if (!type.equals(other.type))
return false;
if (value == null) {
if (other.value != null)
return false;
} else if (!value.equals(other.value))
return false;
return true;
}
@Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + ((type == null) ? 0 : type.hashCode());
result = prime * result + ((value == null) ? 0 : value.hashCode());
return result;
}
@Override
public String toString() {
return "[Taint" + payloadString() + ": " + value + " Type: " + type + "]";
// return "[Taint: " + value + "; " + System.identityHashCode(this) +
// "; " + System.identityHashCode(value) + "; " + hashCode() + "]";
}
public Taint createAlias(Value value, Unit sourceUnit) {
return new Taint(sourceUnit, this, value, type);
}
@Override
public Trackable createAlias(Unit sourceUnit) {
return new Taint(sourceUnit, this, value, type);
}
@Override
public Taint cloneWithoutNeighborsAndPayload() {
return new Taint(sourceUnit, predecessor, value, type);
}
}
| 1,824 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
Dummy.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/trackable/Dummy.java | package flow.twist.trackable;
import soot.Unit;
public class Dummy extends Trackable {
public static Dummy DUMMY = new Dummy();
private Dummy() {
}
@Override
public Trackable createAlias(Unit sourceUnits) {
throw new IllegalStateException();
}
@Override
public String toString() {
return "";
}
@Override
public Dummy cloneWithoutNeighborsAndPayload() {
return DUMMY;
}
}
| 397 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ReturnEdgeTaint.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/trackable/ReturnEdgeTaint.java | package flow.twist.trackable;
import soot.Type;
import soot.Unit;
import soot.Value;
public class ReturnEdgeTaint extends Taint implements PushOnStack {
public final Unit callSite;
public final int paramIndex;
public ReturnEdgeTaint(Unit callSite, Unit exitStmt, Trackable predecessor, Value value, int paramIndex, Type type) {
super(exitStmt, predecessor, value, type);
this.callSite = callSite;
this.paramIndex = paramIndex;
}
@Override
public String toString() {
return "[ReturnEdgeTaint" + payloadString() + ": " + value + "]";
}
@Override
public Unit getCallSite() {
return callSite;
}
@Override
public int getParameterIndex() {
return paramIndex;
}
@Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + ((callSite == null) ? 0 : callSite.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!super.equals(obj))
return false;
if (getClass() != obj.getClass())
return false;
ReturnEdgeTaint other = (ReturnEdgeTaint) obj;
if (callSite == null) {
if (other.callSite != null)
return false;
} else if (!callSite.equals(other.callSite))
return false;
return true;
}
}
| 1,266 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PopFromStack.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/trackable/PopFromStack.java | package flow.twist.trackable;
import soot.Unit;
public interface PopFromStack {
public Unit getCallSite();
}
| 113 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
Zero.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/trackable/Zero.java | package flow.twist.trackable;
import soot.Unit;
public class Zero extends Trackable {
private Zero() {
super();
}
public static final Trackable ZERO = new Zero();
@Override
public String toString() {
return "ZERO";
}
@Override
public Trackable createAlias(Unit sourceUnits) {
throw new IllegalStateException("Never propagate ZERO, thus don't create any alias.");
}
@Override
public Trackable cloneWithoutNeighborsAndPayload() {
return ZERO;
}
@Override
public int hashCode() {
return 23543865;
}
@Override
public boolean equals(Object obj) {
return this == obj;
}
}
| 605 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
CalledMethod.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/pathchecker/CalledMethod.java | package flow.twist.pathchecker;
import java.util.List;
import soot.SootClass;
import soot.SootMethod;
import soot.SootMethodRef;
import soot.Unit;
import soot.jimple.Stmt;
@SuppressWarnings("rawtypes")
public class CalledMethod {
private SootClass declaringClass;
private String methodName;
private List parameterTypes;
private int paramIndex;
public CalledMethod(Unit callSite, int paramIndex) {
SootMethodRef method = ((Stmt) callSite).getInvokeExpr().getMethodRef();
methodName = method.name();
parameterTypes = method.parameterTypes();
declaringClass = getDeclaringClass(method.declaringClass());
this.paramIndex = paramIndex;
}
private SootClass getDeclaringClass(SootClass declaringClass) {
for (SootClass i : declaringClass.getInterfaces()) {
SootClass candidate = getDeclaringClass(i);
if (candidate != null)
return candidate;
if (hasMethod(i))
return i;
}
if (declaringClass.hasSuperclass()) {
SootClass candidate = getDeclaringClass(declaringClass.getSuperclass());
if (candidate != null)
return candidate;
if (hasMethod(declaringClass))
return declaringClass;
}
return null;
}
private boolean hasMethod(SootClass declaringClass) {
for (SootMethod m : declaringClass.getMethods()) {
if (m.getName().equals(methodName) && m.getParameterTypes().equals(parameterTypes)) {
return true;
}
}
return false;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((declaringClass == null) ? 0 : declaringClass.hashCode());
result = prime * result + ((methodName == null) ? 0 : methodName.hashCode());
result = prime * result + paramIndex;
result = prime * result + ((parameterTypes == null) ? 0 : parameterTypes.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
CalledMethod other = (CalledMethod) obj;
if (declaringClass == null) {
if (other.declaringClass != null)
return false;
} else if (!declaringClass.equals(other.declaringClass))
return false;
if (methodName == null) {
if (other.methodName != null)
return false;
} else if (!methodName.equals(other.methodName))
return false;
if (paramIndex != other.paramIndex)
return false;
if (parameterTypes == null) {
if (other.parameterTypes != null)
return false;
} else if (!parameterTypes.equals(other.parameterTypes))
return false;
return true;
}
} | 2,561 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
FilterSingleDirectionReports.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/pathchecker/FilterSingleDirectionReports.java | package flow.twist.pathchecker;
import java.util.List;
import soot.SootMethod;
import com.google.common.collect.Lists;
import flow.twist.config.AnalysisDirection;
import flow.twist.reporter.Report;
import flow.twist.transformer.ResultTransformer;
import flow.twist.util.CacheMap;
public class FilterSingleDirectionReports extends ResultTransformer<Iterable<Report>, Iterable<Report>> {
public FilterSingleDirectionReports(ResultTransformer<Iterable<Report>, ?> successor) {
super(successor);
}
protected Iterable<Report> transformAnalysisResults(Iterable<Report> from) {
CacheMap<SootMethod, ReportsPerSourceMethod> cache = new CacheMap<SootMethod, ReportsPerSourceMethod>() {
@Override
protected ReportsPerSourceMethod createItem(SootMethod key) {
return new ReportsPerSourceMethod(key);
}
};
for (Report r : from) {
SootMethod method = r.context.icfg.getMethodOf(r.targetUnit);
cache.getOrCreate(method).reports.add(r);
}
List<Report> result = Lists.newLinkedList();
for (ReportsPerSourceMethod rpsm : cache.values()) {
if (rpsm.hasReportsForBothDirections())
result.addAll(rpsm.reports);
}
return result;
}
public static class ReportsPerSourceMethod {
public final SootMethod method;
public final List<Report> reports;
public ReportsPerSourceMethod(SootMethod method) {
this.method = method;
reports = Lists.newLinkedList();
}
public boolean hasReportsForBothDirections() {
int forward = 0;
for (Report r : reports) {
if (r.context.direction == AnalysisDirection.FORWARDS)
forward++;
}
return forward > 0 && forward < reports.size();
}
}
}
| 1,644 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
StoreAnyPath.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/pathchecker/StoreAnyPath.java | package flow.twist.pathchecker;
import java.util.Set;
import com.google.common.collect.Sets;
import flow.twist.path.Path;
import flow.twist.targets.AnalysisTarget;
public class StoreAnyPath implements PathChecker {
private Set<Path> paths = Sets.newHashSet();
private AnalysisTarget analysisTarget;
public StoreAnyPath(AnalysisTarget analysisTarget) {
this.analysisTarget = analysisTarget;
}
@Override
public void addOrDismiss(Path path) {
paths.add(path);
}
@Override
public Set<Path> getValidPaths() {
return paths;
}
@Override
public AnalysisTarget getTarget() {
return analysisTarget;
}
}
| 623 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
TwoPathChecker.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/pathchecker/TwoPathChecker.java | package flow.twist.pathchecker;
import java.util.LinkedList;
import java.util.Set;
import soot.SootMethod;
import soot.Unit;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import flow.twist.config.AnalysisDirection;
import flow.twist.path.Path;
import flow.twist.targets.AnalysisTarget;
public class TwoPathChecker implements PathChecker {
private PathChecker decoratee;
public TwoPathChecker(PathChecker decoratee) {
this.decoratee = decoratee;
}
@Override
public void addOrDismiss(Path path) {
decoratee.addOrDismiss(path);
}
@Override
public Set<Path> getValidPaths() {
Set<Path> result = Sets.newHashSet();
HashMultimap<SimilarPathIndication, Path> similarPaths = HashMultimap.create();
for (Path path : decoratee.getValidPaths()) {
similarPaths.put(new SimilarPathIndication(path), path);
}
for (SimilarPathIndication key : similarPaths.keySet()) {
Set<Path> paths = similarPaths.get(key);
Set<Path> forwards = Sets.newHashSet();
Set<Path> backwards = Sets.newHashSet();
for (Path path : paths) {
if (path.context.direction == AnalysisDirection.BACKWARDS)
backwards.add(path);
else
forwards.add(path);
}
for (Path backwardPath : backwards) {
for (Path forwardPath : forwards) {
result.add(backwardPath.reverse().append(forwardPath));
}
}
// if (result.isEmpty()) {
// for (Path path : paths) {
// System.out.println("Dismissing: " + path);
// }
// }
}
return result;
}
private static class SimilarPathIndication {
private final Unit sink;
private final SootMethod source;
private final LinkedList<Object> callStack;
public SimilarPathIndication(Path path) {
sink = path.getFirst();
source = path.context.icfg.getMethodOf(path.getFirst());
callStack = Lists.newLinkedList(path.getCallStack());
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((callStack == null) ? 0 : callStack.hashCode());
result = prime * result + ((sink == null) ? 0 : sink.hashCode());
result = prime * result + ((source == null) ? 0 : source.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
SimilarPathIndication other = (SimilarPathIndication) obj;
if (callStack == null) {
if (other.callStack != null)
return false;
} else if (!callStack.equals(other.callStack))
return false;
if (sink == null) {
if (other.sink != null)
return false;
} else if (!sink.equals(other.sink))
return false;
if (source == null) {
if (other.source != null)
return false;
} else if (!source.equals(other.source))
return false;
return true;
}
}
@Override
public AnalysisTarget getTarget() {
return decoratee.getTarget();
}
}
| 3,003 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
EmptyCallStackChecker.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/pathchecker/EmptyCallStackChecker.java | package flow.twist.pathchecker;
import java.util.Set;
import flow.twist.path.Path;
import flow.twist.targets.AnalysisTarget;
public class EmptyCallStackChecker implements PathChecker {
private PathChecker decoratee;
public EmptyCallStackChecker(PathChecker decoratee) {
this.decoratee = decoratee;
}
@Override
public void addOrDismiss(Path path) {
if (path.getCallStack().isEmpty())
decoratee.addOrDismiss(path);
}
@Override
public Set<Path> getValidPaths() {
return decoratee.getValidPaths();
}
@Override
public AnalysisTarget getTarget() {
return decoratee.getTarget();
}
}
| 608 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
SubPathRemover.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/pathchecker/SubPathRemover.java | package flow.twist.pathchecker;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import flow.twist.path.Path;
import flow.twist.targets.AnalysisTarget;
public class SubPathRemover implements PathChecker {
private PathChecker decoratee;
public SubPathRemover(PathChecker decoratee) {
this.decoratee = decoratee;
}
@Override
public void addOrDismiss(Path path) {
decoratee.addOrDismiss(path);
}
@Override
public Set<Path> getValidPaths() {
Set<Path> paths = new HashSet<Path>(decoratee.getValidPaths());
Iterator<Path> iterator = paths.iterator();
outer: while (iterator.hasNext()) {
Path p = iterator.next();
for (Path other : paths) {
if (p == other)
continue;
if (p.context == other.context && p.isSubPath(other)) {
iterator.remove();
continue outer;
}
}
}
return paths;
}
@Override
public AnalysisTarget getTarget() {
return decoratee.getTarget();
}
}
| 956 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PathChecker.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/pathchecker/PathChecker.java | package flow.twist.pathchecker;
import java.util.Set;
import flow.twist.path.Path;
import flow.twist.targets.AnalysisTarget;
public interface PathChecker {
void addOrDismiss(Path path);
Set<Path> getValidPaths();
AnalysisTarget getTarget();
}
| 252 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
Path.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/path/Path.java | package flow.twist.path;
import java.util.Iterator;
import java.util.List;
import soot.SootMethod;
import soot.Unit;
import com.google.common.base.Joiner;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import flow.twist.config.AnalysisConfiguration;
import flow.twist.config.AnalysisContext;
import flow.twist.config.AnalysisDirection;
import flow.twist.util.AnalysisUtil;
public class Path implements Iterable<PathElement> {
private Iterable<PathElement> elements;
public final AnalysisContext context;
private final fj.data.List<Object> callStack;
private Unit sink;
public Path(AnalysisContext context, Iterable<PathElement> elements, fj.data.List<Object> callStack, Unit sink) {
this.context = context;
this.elements = elements;
this.callStack = callStack;
this.sink = sink;
}
public Unit getFirst() {
return Iterables.getFirst(elements, null).from;
}
public Unit getLast() {
return Iterables.getLast(elements).to;
}
@Override
public String toString() {
return Joiner.on("\n").join(elements);
}
public String toContextAwareString() {
StringBuffer buffer = new StringBuffer();
SootMethod currentMethod = null;
PathElement lastElement = null;
for (PathElement e : elements) {
lastElement = e;
SootMethod fromMethod = this.context.icfg.getMethodOf(e.from);
if (currentMethod == null || !currentMethod.equals(fromMethod)) {
currentMethod = fromMethod;
buffer.append("[");
buffer.append(currentMethod);
buffer.append("]");
buffer.append("\n");
}
buffer.append(AnalysisUtil.getLine(e.from));
buffer.append("\t");
buffer.append(e.from);
buffer.append("\n");
// buffer.append(e.toString());
//
// SootMethod toMethod = this.context.icfg.getMethodOf(e.to);
// if (currentMethod == null || !currentMethod.equals(toMethod)) {
// currentMethod = toMethod;
// buffer.append("\n");
// buffer.append("[");
// buffer.append(currentMethod);
// buffer.append("]");
// }
//
// buffer.append("\n");
}
if (lastElement != null) {
buffer.append(AnalysisUtil.getLine(lastElement.to));
buffer.append("\t");
buffer.append(lastElement.to);
buffer.append("\n");
}
return buffer.toString();
}
public Path reverse() {
List<PathElement> newElements = Lists.newLinkedList();
for (PathElement element : this.elements) {
newElements.add(0, element.reverse());
}
return new Path(reverse(context), newElements, callStack, sink);
}
private static AnalysisDirection reverse(AnalysisDirection direction) {
return direction == AnalysisDirection.FORWARDS ? AnalysisDirection.BACKWARDS : AnalysisDirection.FORWARDS;
}
private static AnalysisContext reverse(AnalysisContext context) {
return new AnalysisContext(new AnalysisConfiguration(context.targets, reverse(context.direction), context.type, context.reporter,
context.seedFactory, context.debugger, context.propagatorProvider), context.icfg);
}
public Path append(Path successor) {
List<PathElement> elements = Lists.newLinkedList(this.elements);
Iterables.addAll(elements, successor.elements);
return new Path(context, elements, callStack, sink);
}
@Override
public Iterator<PathElement> iterator() {
return elements.iterator();
}
public fj.data.List<Object> getCallStack() {
return callStack;
}
public boolean isSubPath(Path other) {
Iterator<PathElement> otherIt = other.iterator();
PathElement current = otherIt.next();
for (PathElement element : elements) {
if (element.equals(current)) {
if (otherIt.hasNext())
current = otherIt.next();
else
return true;
} else
return false;
}
return false;
}
public Unit getSink() {
return sink;
}
}
| 3,745 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PathElement.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/path/PathElement.java | package flow.twist.path;
import soot.Unit;
import flow.twist.trackable.Trackable;
public class PathElement implements Comparable<PathElement> {
public final Unit from;
public final Trackable trackable;
public final Unit to;
public PathElement(Unit from, Trackable trackable, Unit to) {
this.from = from;
this.trackable = trackable;
this.to = to;
}
@Override
public String toString() {
return String.format("%s (%d) -----%s-----> %s (%d)", from, from.hashCode(), trackable, to, to.hashCode());
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((to == null) ? 0 : to.hashCode());
result = prime * result + ((from == null) ? 0 : from.hashCode());
result = prime * result + ((trackable == null) ? 0 : System.identityHashCode(trackable));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
PathElement other = (PathElement) obj;
if (to == null) {
if (other.to != null)
return false;
} else if (!to.equals(other.to))
return false;
if (from == null) {
if (other.from != null)
return false;
} else if (!from.equals(other.from))
return false;
if (trackable != other.trackable)
return false;
return true;
}
public PathElement reverse() {
return new PathElement(to, trackable, from);
}
@Override
public int compareTo(PathElement o) {
return Integer.compare(hashCode(), o.hashCode());
}
}
| 1,554 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
AnalysisUtil.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/util/AnalysisUtil.java | package flow.twist.util;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Properties;
import java.util.Set;
import soot.ArrayType;
import soot.Local;
import soot.Modifier;
import soot.PrimType;
import soot.RefType;
import soot.SootClass;
import soot.SootMethod;
import soot.Type;
import soot.Unit;
import soot.Value;
import soot.jimple.ArrayRef;
import soot.jimple.AssignStmt;
import soot.jimple.CastExpr;
import soot.jimple.FieldRef;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
import soot.tagkit.LineNumberTag;
import soot.tagkit.SourceLnPosTag;
import com.google.common.collect.Sets;
import flow.twist.config.AnalysisContext;
import flow.twist.config.AnalysisDirection;
import flow.twist.targets.AnalysisTarget;
public class AnalysisUtil {
/**
* Returns <code>true</code> if both references may point to the same memory
* location. The current implementation is conservative, as it does not take
* any points-to information into account.
*/
public static boolean maybeSameLocation(Value abstrRef, Value programRef) {
// arrays are handled through their "base" pointer
assert !(abstrRef instanceof ArrayRef);
assert !(programRef instanceof ArrayRef);
if (abstrRef == programRef)
return true;
// handle primtive types
Type abstrRefType = abstrRef.getType();
Type programRefType = programRef.getType();
if (programRefType instanceof PrimType) {
// we don't track primitive types, just Strings, ClassLoaders, etc.
// ...
return false;
}
if (abstrRefType instanceof PrimType) {
// we don't track primitive types, just Strings, ClassLoaders, etc.
// ...
throw new InternalError("abstraction ref type is " + abstrRefType);
}
if (abstrRef instanceof Local && programRef instanceof Local) {
// two locals only point to the same memory locations if they are
// the same
return abstrRef == programRef;
} else if (abstrRef instanceof FieldRef && programRef instanceof FieldRef) {
FieldRef fieldRef = (FieldRef) abstrRef;
FieldRef fieldRef2 = (FieldRef) programRef;
// references point to the same location if class and field name are
// identical;
// note that we ignore the receiver object of InstanceFieldRefs
return fieldRef.getField().getDeclaringClass().equals(fieldRef2.getField().getDeclaringClass())
&& fieldRef.getFieldRef().name().equals(fieldRef2.getFieldRef().name());
} else {
return false;
}
}
public static String methodCanBeOverwrittenByApplication(SootMethod m) {
int methodModifiers = m.getModifiers();
int classModifiers = m.getDeclaringClass().getModifiers();
if (Modifier.isPublic(classModifiers) && !Modifier.isFinal(classModifiers)) {
if (Modifier.isPublic(methodModifiers) && !Modifier.isStatic(methodModifiers) && !Modifier.isFinal(methodModifiers)) {
return "Method and declaring class are public and non-final, method is non-static.";
} else if (Modifier.isProtected(methodModifiers) && !Modifier.isStatic(methodModifiers) && !Modifier.isFinal(methodModifiers)) {
return "Method is protected and non-final and non-static, declaring class is public and non-final.";
}
}
return null;
}
private static String[] restrictedPackages;
public static void initRestrictedPackages(String pathToJREHome) {
Properties secProps = new Properties();
try {
try {
secProps.load(new InputStreamReader(new FileInputStream(pathToJREHome + File.separator + "lib" + File.separator + "security"
+ File.separator + "java.security")));
} catch (Exception e) {
secProps.load(new InputStreamReader(new FileInputStream(pathToJREHome + File.separator + "jre" + File.separator + "lib"
+ File.separator + "security" + File.separator + "java.security")));
}
restrictedPackages = secProps.getProperty("package.access").split(",");
String defn = secProps.getProperty("package.definition");
if (defn != null) {
String[] defnPackages = defn.split(",");
if (!Arrays.equals(restrictedPackages, defnPackages)) {
System.err.println("package.access differs from package.definition!");
}
}
System.out.println("The following packages are access restricted:");
for (int i = 0; i < restrictedPackages.length; i++) {
restrictedPackages[i] = restrictedPackages[i].trim();
System.out.println(restrictedPackages[i]);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static boolean isAccessRestricted(SootClass sc) {
for (String pkg : restrictedPackages) {
String name = sc.getName();
if (name.startsWith(pkg)) {
return true;
}
}
return false;
}
public static int getLine(Unit unit) {
SourceLnPosTag tag = (SourceLnPosTag) unit.getTag("SourceLnPosTag");
if (tag != null)
return tag.startLn();
LineNumberTag lnTag = (LineNumberTag) unit.getTag("LineNumberTag");
if (lnTag != null)
return lnTag.getLineNumber();
return -1;
}
public static boolean isTarget(AnalysisContext context, Unit unit) {
return isTarget(context.direction, context.icfg.getMethodOf(unit), unit, context.targets);
}
public static boolean isTarget(AnalysisDirection direction, SootMethod enclosingMethod, Unit unit, Iterable<AnalysisTarget> targets) {
if (!(unit instanceof AssignStmt))
return false;
Stmt s = (Stmt) unit;
if (!s.containsInvokeExpr())
return false;
InvokeExpr ie = s.getInvokeExpr();
for (AnalysisTarget target : targets) {
if (target.matches(direction, enclosingMethod, ie))
return true;
}
return false;
}
public static boolean methodMayBeCallableFromApplication(SootMethod m) {
int methodModifiers = m.getModifiers();
int classModifiers = m.getDeclaringClass().getModifiers();
if (Modifier.isPublic(classModifiers) && !isAccessRestricted(m.getDeclaringClass())) {
if (Modifier.isPublic(methodModifiers)) {
return true;
} else if (Modifier.isProtected(methodModifiers) && !Modifier.isFinal(classModifiers)) {
return true;
}
}
return false;
}
/**
* extracts array base values from array refs and values from cast
* expressions
*/
public static Value getBackwardsBase(Value val) {
if (val instanceof ArrayRef) {
ArrayRef arrayRef = (ArrayRef) val;
return arrayRef.getBase();
}
if (val instanceof CastExpr) {
CastExpr castExpr = (CastExpr) val;
return castExpr.getOp();
}
return val;
}
public static Value getForwardsBase(Value val) {
if (val instanceof ArrayRef) {
ArrayRef arrayRef = (ArrayRef) val;
return arrayRef.getBase();
}
return val;
}
/**
* Returns true if an instance of type taintType is assignable to a
* declaration of type declaredType.
*/
public static boolean isAssignable(Type taintType, Type declaredType) {
if (taintType instanceof ArrayType)
taintType = ((ArrayType) taintType).getArrayElementType();
if (declaredType instanceof ArrayType)
declaredType = ((ArrayType) declaredType).getArrayElementType();
if (taintType.equals(declaredType))
return true;
if (!(taintType instanceof RefType))
return false;
if (!(declaredType instanceof RefType)) {
return false;
}
return isAssignable(((RefType) taintType).getSootClass(), ((RefType) declaredType).getSootClass());
}
public static boolean isAssignable(SootClass taintType, SootClass declaredType) {
if (taintType.equals(declaredType))
return true;
if (taintType.hasSuperclass() && isAssignable(taintType.getSuperclass(), declaredType)) {
return true;
}
for (SootClass interf : taintType.getInterfaces()) {
if (isAssignable(interf, declaredType))
return true;
}
return false;
}
public static Set<SootMethod> getInitialDeclaration(SootMethod method) {
return getInitialDeclaration(method, method.getDeclaringClass());
}
// TODO: Consider implementing a cached version
private static Set<SootMethod> getInitialDeclaration(SootMethod method, SootClass candidate) {
Set<SootMethod> result = Sets.newHashSet();
if (candidate.hasSuperclass()) {
result.addAll(getInitialDeclaration(method, candidate.getSuperclass()));
}
for (SootClass intface : candidate.getInterfaces()) {
result.addAll(getInitialDeclaration(method, intface));
}
if (result.isEmpty()) {
for (SootMethod candidateMethod : candidate.getMethods()) {
if (compatible(candidateMethod, method)) {
result.add(candidateMethod);
break;
}
}
}
return result;
}
/**
* Returns true, if subClassMethod could be overriding superClassMethod.
* Check only considers the method name and the parameters.
*/
public static boolean compatible(SootMethod superClassMethod, SootMethod subClassMethod) {
if (!superClassMethod.getName().equals(subClassMethod.getName()))
return false;
if (superClassMethod.getParameterCount() != subClassMethod.getParameterCount())
return false;
boolean paramsMatch = true;
for (int i = 0; i < superClassMethod.getParameterCount(); i++) {
Type superType = superClassMethod.getParameterType(i);
Type subType = superClassMethod.getParameterType(i);
if (!isAssignable(superType, subType)) {
paramsMatch = false;
break;
}
}
return paramsMatch;
}
}
| 9,204 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
CacheMap.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/util/CacheMap.java | package flow.twist.util;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public abstract class CacheMap<K, V> implements Map<K, V> {
private HashMap<K, V> map;
public CacheMap() {
map = new HashMap<K, V>();
}
@Override
public int size() {
return map.size();
}
@Override
public boolean isEmpty() {
return map.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return map.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return map.containsValue(value);
}
protected abstract V createItem(K key);
public V getOrCreate(K key) {
if (!map.containsKey(key)) {
V value = createItem((K) key);
map.put((K) key, value);
return value;
}
return map.get(key);
}
@Override
public V get(Object key) {
return map.get(key);
}
@Override
public V put(K key, V value) {
return map.put(key, value);
}
@Override
public V remove(Object key) {
return map.remove(key);
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
map.putAll(m);
}
@Override
public void clear() {
map.clear();
}
@Override
public Set<K> keySet() {
return map.keySet();
}
@Override
public Collection<V> values() {
return map.values();
}
@Override
public Set<java.util.Map.Entry<K, V>> entrySet() {
return map.entrySet();
}
}
| 1,377 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
MultipleAnalysisPlotter.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/util/MultipleAnalysisPlotter.java | package flow.twist.util;
import java.util.HashMap;
import java.util.Set;
import att.grappa.Edge;
import att.grappa.Node;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import flow.twist.path.Path;
import flow.twist.trackable.Trackable;
public class MultipleAnalysisPlotter extends PathPlotter {
private HashMap<EdgeKey, Edge> edges = Maps.newHashMap();
public MultipleAnalysisPlotter() {
super(Sets.<Path> newHashSet());
}
public void plotAnalysisResults(Set<Path> paths, String color) {
this.currentColor = color;
for (Path path : paths) {
createPath(path);
toggleColor();
}
}
@Override
protected Edge createEdge(Node fromNode, Node toNode, Trackable trackable, double weight) {
EdgeKey key = new EdgeKey(fromNode, toNode, trackable);
if (edges.containsKey(key)) {
Edge edge = edges.get(key);
int count = Integer.parseInt((String) edge.getAttributeValue("count"));
edge.setAttribute("count", String.valueOf(count + 1));
edge.setAttribute("label", trackable.toString() + " (" + (count + 1) + "x)");
edge.setAttribute("color", edge.getAttribute("color").getStringValue() + ":" + currentColor());
edge.setAttribute("fontcolor", "black");
return edge;
} else {
Edge edge = super.createEdge(fromNode, toNode, trackable, weight);
edge.setAttribute("count", String.valueOf(1));
edges.put(key, edge);
return edge;
}
}
private static class EdgeKey {
private Node fromNode;
private Node toNode;
private Trackable trackable;
private EdgeKey(Node fromNode, Node toNode, Trackable trackable) {
this.fromNode = fromNode;
this.toNode = toNode;
this.trackable = trackable.cloneWithoutNeighborsAndPayload();
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((fromNode == null) ? 0 : System.identityHashCode(fromNode));
result = prime * result + ((toNode == null) ? 0 : System.identityHashCode(toNode));
result = prime * result + ((trackable == null) ? 0 : trackable.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
EdgeKey other = (EdgeKey) obj;
if (fromNode != other.fromNode)
return false;
if (toNode != other.toNode)
return false;
if (!trackable.equals(other.trackable))
return false;
return true;
}
}
}
| 2,486 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ImmutableLinkedHashSet.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/util/ImmutableLinkedHashSet.java | package flow.twist.util;
import java.util.Iterator;
import fj.F;
import fj.data.List;
public class ImmutableLinkedHashSet<T> extends ImmutableHashSet<T> implements Iterable<T> {
public static <T> ImmutableLinkedHashSet<T> empty() {
ImmutableLinkedHashSet<T> result = new ImmutableLinkedHashSet<T>();
result.initEmpty();
return result;
}
private List<T> linkedItems;
protected ImmutableLinkedHashSet() {
}
@Override
protected ImmutableLinkedHashSet<T> create() {
return new ImmutableLinkedHashSet<T>();
}
@Override
protected void initEmpty() {
super.initEmpty();
linkedItems = List.nil();
}
@Override
public ImmutableLinkedHashSet<T> add(T item) {
ImmutableLinkedHashSet<T> result = (ImmutableLinkedHashSet<T>) super.add(item);
result.linkedItems = linkedItems.cons(item);
return result;
}
@Override
public Iterator<T> iterator() {
return linkedItems.iterator();
}
public T head() {
return linkedItems.head();
}
@Override
public ImmutableHashSet<T> remove(final T item) {
ImmutableLinkedHashSet<T> result = (ImmutableLinkedHashSet<T>) super.remove(item);
result.linkedItems = linkedItems.filter(new F<T, Boolean>() {
@Override
public Boolean f(T other) {
return isEquals(other, item);
}
});
return result;
}
public ImmutableLinkedHashSet<T> removeHead() {
ImmutableLinkedHashSet<T> result = (ImmutableLinkedHashSet<T>) super.remove(linkedItems.head());
result.linkedItems = linkedItems.tail();
return result;
}
public fj.data.List<T> asList() {
return linkedItems;
}
public int size() {
return linkedItems.length();
}
}
| 1,615 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
Pair.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/util/Pair.java | package flow.twist.util;
public class Pair<A, B> {
public final A first;
public final B second;
public Pair(A first, B second) {
super();
this.first = first;
this.second = second;
}
public static <A, B> Pair<A, B> pair(A a, B b) {
return new Pair<A, B>(a, b);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((first == null) ? 0 : first.hashCode());
result = prime * result + ((second == null) ? 0 : second.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Pair))
return false;
Pair other = (Pair) obj;
if (first == null) {
if (other.first != null)
return false;
} else if (!first.equals(other.first))
return false;
if (second == null) {
if (other.second != null)
return false;
} else if (!second.equals(other.second))
return false;
return true;
}
}
| 994 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
DotHelper.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/util/DotHelper.java | package flow.twist.util;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import att.grappa.Graph;
public class DotHelper {
public static void writeFilesForGraph(String filename, Graph graph) {
try {
ByteArrayOutputStream byteOutStream = new ByteArrayOutputStream();
graph.printGraph(byteOutStream);
String output = byteOutStream.toString().replaceAll("#", "\"");
// System.out.println(output);
File file = new File(filename + ".dot").getAbsoluteFile();
if (!file.getParentFile().exists())
file.getParentFile().mkdirs();
FileWriter fileWriter = new FileWriter(file);
fileWriter.write(output);
fileWriter.close();
String dot = System.getProperty("dot.executable", "C:\\Program Files (x86)\\Graphviz\\bin\\dot.exe");
if (!new File(dot).exists()) {
dot = "/usr/local/bin/dot";
}
if (!new File(dot).exists()) {
dot = "/usr/bin/dot";
}
if (new File(dot).exists()) {
Process pngProcess = Runtime.getRuntime().exec(new String[] { dot, "-Tpng", file.getAbsolutePath(), "-o", filename + ".png" });
Process pdfProcess = Runtime.getRuntime().exec(new String[] { dot, "-Tpdf", file.getAbsolutePath(), "-o", filename + ".pdf" });
pngProcess.waitFor();
pdfProcess.waitFor();
}
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
| 1,436 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ImmutableHashSet.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/util/ImmutableHashSet.java | package flow.twist.util;
import fj.F;
import fj.Ord;
import fj.Ordering;
import fj.data.List;
import fj.data.Option;
import fj.data.TreeMap;
public class ImmutableHashSet<T> {
public static <T> ImmutableHashSet<T> empty() {
ImmutableHashSet<T> result = new ImmutableHashSet<T>();
result.initEmpty();
return result;
}
private TreeMap<T, List<T>> backingMap;
protected ImmutableHashSet() {
}
protected ImmutableHashSet<T> create() {
return new ImmutableHashSet<>();
}
protected void initEmpty() {
Ord<T> ord = Ord.ord(new F<T, F<T, Ordering>>() {
@Override
public F<T, Ordering> f(final T first) {
return new F<T, Ordering>() {
@Override
public Ordering f(T second) {
return Ord.intOrd.compare(getHashCode(first), getHashCode(second));
}
};
}
});
backingMap = TreeMap.empty(ord);
}
protected boolean isEquals(T t, T item) {
return t.equals(item);
}
protected int getHashCode(T item) {
return item.hashCode();
}
public ImmutableHashSet<T> add(final T item) {
ImmutableHashSet<T> result = create();
Option<List<T>> existingBucket = backingMap.get(item);
List<T> newBucket;
if (existingBucket.isSome()) {
newBucket = existingBucket.some().filter(new F<T, Boolean>() {
@Override
public Boolean f(T existingItem) {
return !isEquals(existingItem, item);
}
}).cons(item);
} else {
newBucket = List.single(item);
}
result.backingMap = backingMap.set(item, newBucket);
return result;
}
public boolean contains(final T item) {
Option<List<T>> bucket = backingMap.get(item);
if (bucket.isSome()) {
return bucket.some().exists(new F<T, Boolean>() {
@Override
public Boolean f(T existingItem) {
return isEquals(existingItem, item);
}
});
}
return false;
}
public ImmutableHashSet<T> remove(final T item) {
ImmutableHashSet<T> result = create();
Option<List<T>> existingBucket = backingMap.get(item);
List<T> newBucket;
if (existingBucket.isSome()) {
newBucket = existingBucket.some().filter(new F<T, Boolean>() {
@Override
public Boolean f(T existingItem) {
return !isEquals(existingItem, item);
}
});
if (newBucket.isEmpty()) {
result.backingMap = backingMap.delete(item);
} else {
result.backingMap = backingMap.set(item, newBucket);
}
} else {
newBucket = List.single(item);
result.backingMap = backingMap.set(item, newBucket);
}
return result;
}
public boolean isEmpty() {
return backingMap.isEmpty();
}
}
| 2,521 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PathPlotter.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/util/PathPlotter.java | package flow.twist.util;
import java.util.Set;
import flow.twist.config.AnalysisContext;
import flow.twist.path.Path;
import flow.twist.path.PathElement;
import flow.twist.trackable.ReturnEdgeTaint;
import flow.twist.trackable.Trackable;
import soot.SootMethod;
import soot.Unit;
import att.grappa.Edge;
import att.grappa.Graph;
import att.grappa.Node;
import att.grappa.Subgraph;
public class PathPlotter {
private Graph graph;
private CacheMap<SootMethod, Subgraph> methodSubgraphs = new CacheMap<SootMethod, Subgraph>() {
@Override
protected Subgraph createItem(SootMethod key) {
Subgraph subgraph = new Subgraph(graph, "cluster_" + methodSubgraphs.size());
subgraph.setAttribute("label", "\"" + key.toString() + "\"");
subgraph.setAttribute("style", "filled");
subgraph.setAttribute("color", "lightgrey");
subgraph.setAttribute("fillcolor", "lightgrey");
return subgraph;
}
};
private CacheMap<Unit, Node> nodes = new CacheMap<Unit, Node>() {
@Override
protected Node createItem(Unit key) {
SootMethod enclosingMethod = context.icfg.getMethodOf(key);
Subgraph subgraph = methodSubgraphs.getOrCreate(enclosingMethod);
Node node = new Node(subgraph);
node.setAttribute("shape", "rectangle");
node.setAttribute("label", key.toString());
if (AnalysisUtil.isTarget(context.direction, enclosingMethod, key, context.targets)) {
node.setAttribute("style", "filled");
node.setAttribute("fillcolor", "green");
}
subgraph.addNode(node);
return node;
}
};
protected AnalysisContext context;
private int colorIndex = 0;
private String[] colors = new String[] { "red", "blue", "green", "yellow", "cyan", "orange" };
protected String currentColor = colors[0];
public PathPlotter(Set<Path> paths) {
graph = new Graph("debug graph");
graph.setAttribute("compound", "true");
for (Path path : paths) {
createPath(path);
toggleColor();
}
}
protected void toggleColor() {
colorIndex = (colorIndex + 1) % colors.length;
currentColor = colors[colorIndex];
}
protected void createPath(Path path) {
context = path.context;
for (PathElement element : path) {
Node fromNode = nodes.getOrCreate(element.from);
Node toNode = nodes.getOrCreate(element.to);
if (element.trackable instanceof ReturnEdgeTaint) {
ReturnEdgeTaint retTaint = (ReturnEdgeTaint) element.trackable;
Node callSiteNode = nodes.getOrCreate(retTaint.callSite);
Edge edge = createEdge(fromNode, callSiteNode, element.trackable, 1);
createEdge(callSiteNode, toNode, element.trackable, calculateEdgeWeight(retTaint.callSite, element.to));
} else {
createEdge(fromNode, toNode, element.trackable, calculateEdgeWeight(element.from, element.to));
}
}
nodes.getOrCreate(path.getFirst()).getSubgraph().setAttribute("color", "green");
}
private double calculateEdgeWeight(Unit from, Unit to) {
if (context.icfg.getMethodOf(from).equals(context.icfg.getMethodOf(to))) {
return 100;
} else
return 5;
}
protected String currentColor() {
return currentColor;
}
protected Edge createEdge(Node fromNode, Node toNode, Trackable trackable, double weight) {
Edge edge = new Edge(graph, fromNode, toNode);
edge.setAttribute("label", trackable.toString());
edge.setAttribute("color", currentColor());
edge.setAttribute("fontcolor", currentColor());
edge.setAttribute("weight", weight);
graph.addEdge(edge);
return edge;
}
public void writeFile(String filename) {
DotHelper.writeFilesForGraph(filename, graph);
}
}
| 3,533 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ImmutableIdentityHashSet.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/util/ImmutableIdentityHashSet.java | package flow.twist.util;
public class ImmutableIdentityHashSet<T> extends ImmutableHashSet<T> {
public static <T> ImmutableIdentityHashSet<T> empty() {
ImmutableIdentityHashSet<T> result = new ImmutableIdentityHashSet<T>();
result.initEmpty();
return result;
}
@Override
protected ImmutableIdentityHashSet<T> create() {
return new ImmutableIdentityHashSet<T>();
}
protected ImmutableIdentityHashSet() {
super();
}
protected boolean isEquals(T t, T item) {
return t == item;
}
protected int getHashCode(T item) {
return System.identityHashCode(item);
}
@Override
public ImmutableIdentityHashSet<T> add(T item) {
return (ImmutableIdentityHashSet<T>) super.add(item);
}
@Override
public ImmutableIdentityHashSet<T> remove(T item) {
return (ImmutableIdentityHashSet<T>) super.remove(item);
}
}
| 833 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ClassForNameBiDi.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/mains/ClassForNameBiDi.java | package flow.twist.mains;
import java.util.Set;
import flow.twist.AbstractMainAnalysis;
import flow.twist.SolverFactory;
import flow.twist.config.AnalysisConfigurationBuilder;
import flow.twist.path.Path;
import flow.twist.pathchecker.FilterSingleDirectionReports;
import flow.twist.reporter.ResultForwardingReporter;
import flow.twist.transformer.StoreDataTransformer;
import flow.twist.transformer.path.MergeEqualSelectorStrategy;
import flow.twist.transformer.path.PathBuilderResultTransformer;
public class ClassForNameBiDi {
public static void main(final String[] args) {
new AbstractMainAnalysis(args) {
@Override
protected Set<Path> _executeAnalysis() {
StoreDataTransformer<Set<Path>> dataStorage = new StoreDataTransformer<Set<Path>>();
SolverFactory.runBiDirectionSolver(AnalysisConfigurationBuilder.i2oSimpleClassForNameDefaults().reporter(
new ResultForwardingReporter(new FilterSingleDirectionReports(new PathBuilderResultTransformer(dataStorage,
new MergeEqualSelectorStrategy())))));
return dataStorage.getData();
}
}.execute();
}
}
| 1,093 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ClassForNameForwardsFromStringParams.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/mains/ClassForNameForwardsFromStringParams.java | package flow.twist.mains;
import java.util.Set;
import flow.twist.AbstractMainAnalysis;
import flow.twist.SolverFactory;
import flow.twist.config.AnalysisConfigurationBuilder;
import flow.twist.path.Path;
import flow.twist.reporter.ResultForwardingReporter;
import flow.twist.transformer.StoreDataTransformer;
import flow.twist.transformer.path.MergeEqualSelectorStrategy;
import flow.twist.transformer.path.PathBuilderResultTransformer;
public class ClassForNameForwardsFromStringParams {
public static void main(final String[] args) {
new AbstractMainAnalysis(args) {
@Override
protected Set<Path> _executeAnalysis() {
StoreDataTransformer<Set<Path>> dataStorage = new StoreDataTransformer<Set<Path>>();
SolverFactory.runOneDirectionSolver(AnalysisConfigurationBuilder.forwardsFromStringParametersDefaults(false).reporter(
new ResultForwardingReporter(new PathBuilderResultTransformer(dataStorage, new MergeEqualSelectorStrategy()))));
return dataStorage.getData();
}
}.execute();
}
}
| 1,024 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
GenericCallerSensitiveBiDi.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/mains/GenericCallerSensitiveBiDi.java | package flow.twist.mains;
import java.util.Set;
import flow.twist.AbstractMainAnalysis;
import flow.twist.SolverFactory;
import flow.twist.config.AnalysisConfigurationBuilder;
import flow.twist.path.Path;
import flow.twist.pathchecker.FilterSingleDirectionReports;
import flow.twist.reporter.ResultForwardingReporter;
import flow.twist.transformer.StoreDataTransformer;
import flow.twist.transformer.path.MergeEqualSelectorStrategy;
import flow.twist.transformer.path.PathBuilderResultTransformer;
public class GenericCallerSensitiveBiDi {
public static void main(final String[] args) {
new AbstractMainAnalysis(args) {
@Override
protected Set<Path> _executeAnalysis() {
StoreDataTransformer<Set<Path>> dataStorage = new StoreDataTransformer<Set<Path>>();
SolverFactory.runBiDirectionSolver(AnalysisConfigurationBuilder.i2oGenericCallerSensitiveDefaults().reporter(
new ResultForwardingReporter(new FilterSingleDirectionReports(new PathBuilderResultTransformer(dataStorage,
new MergeEqualSelectorStrategy())))));
return dataStorage.getData();
}
}.execute();
}
}
| 1,107 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
GenericCallerSensitiveSimple.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/mains/GenericCallerSensitiveSimple.java | package flow.twist.mains;
import java.util.Set;
import flow.twist.AbstractMainAnalysis;
import flow.twist.SolverFactory;
import flow.twist.config.AnalysisConfigurationBuilder;
import flow.twist.path.Path;
import flow.twist.pathchecker.FilterSingleDirectionReports;
import flow.twist.reporter.ResultForwardingReporter;
import flow.twist.transformer.StoreDataTransformer;
import flow.twist.transformer.path.MergeEqualSelectorStrategy;
import flow.twist.transformer.path.PathBuilderResultTransformer;
public class GenericCallerSensitiveSimple {
public static void main(final String[] args) {
new AbstractMainAnalysis(args) {
@Override
protected Set<Path> _executeAnalysis() {
StoreDataTransformer<Set<Path>> dataStorage = new StoreDataTransformer<Set<Path>>();
SolverFactory.runInnerToOuterSolver(AnalysisConfigurationBuilder.i2oGenericCallerSensitiveDefaults().reporter(
new ResultForwardingReporter(new FilterSingleDirectionReports(new PathBuilderResultTransformer(dataStorage,
new MergeEqualSelectorStrategy())))));
return dataStorage.getData();
}
}.execute();
}
}
| 1,110 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ClassForNameSimple.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/mains/ClassForNameSimple.java | package flow.twist.mains;
import java.util.Set;
import flow.twist.AbstractMainAnalysis;
import flow.twist.SolverFactory;
import flow.twist.config.AnalysisConfigurationBuilder;
import flow.twist.path.Path;
import flow.twist.pathchecker.FilterSingleDirectionReports;
import flow.twist.reporter.ResultForwardingReporter;
import flow.twist.transformer.StoreDataTransformer;
import flow.twist.transformer.path.MergeEqualSelectorStrategy;
import flow.twist.transformer.path.PathBuilderResultTransformer;
public class ClassForNameSimple {
public static void main(final String[] args) {
new AbstractMainAnalysis(args) {
@Override
protected Set<Path> _executeAnalysis() {
StoreDataTransformer<Set<Path>> dataStorage = new StoreDataTransformer<Set<Path>>();
SolverFactory.runInnerToOuterSolver(AnalysisConfigurationBuilder.i2oSimpleClassForNameDefaults().reporter(
new ResultForwardingReporter(new FilterSingleDirectionReports(new PathBuilderResultTransformer(dataStorage,
new MergeEqualSelectorStrategy())))));
return dataStorage.getData();
}
}.execute();
}
}
| 1,096 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ClassForNameForwardsFromAllParams.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/mains/ClassForNameForwardsFromAllParams.java | package flow.twist.mains;
import java.util.Set;
import flow.twist.AbstractMainAnalysis;
import flow.twist.SolverFactory;
import flow.twist.config.AnalysisConfigurationBuilder;
import flow.twist.path.Path;
import flow.twist.reporter.ResultForwardingReporter;
import flow.twist.transformer.StoreDataTransformer;
import flow.twist.transformer.path.MergeEqualSelectorStrategy;
import flow.twist.transformer.path.PathBuilderResultTransformer;
public class ClassForNameForwardsFromAllParams {
public static void main(final String[] args) {
new AbstractMainAnalysis(args) {
@Override
protected Set<Path> _executeAnalysis() {
StoreDataTransformer<Set<Path>> dataStorage = new StoreDataTransformer<Set<Path>>();
SolverFactory.runOneDirectionSolver(AnalysisConfigurationBuilder.forwardsFromAllParametersDefaults(false).reporter(
new ResultForwardingReporter(new PathBuilderResultTransformer(dataStorage, new MergeEqualSelectorStrategy()))));
return dataStorage.getData();
}
}.execute();
}
}
| 1,018 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
GenericCallerSensitiveForwardsFromAllParams.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/mains/GenericCallerSensitiveForwardsFromAllParams.java | package flow.twist.mains;
import java.util.Set;
import flow.twist.AbstractMainAnalysis;
import flow.twist.SolverFactory;
import flow.twist.config.AnalysisConfigurationBuilder;
import flow.twist.path.Path;
import flow.twist.reporter.ResultForwardingReporter;
import flow.twist.transformer.StoreDataTransformer;
import flow.twist.transformer.path.MergeEqualSelectorStrategy;
import flow.twist.transformer.path.PathBuilderResultTransformer;
public class GenericCallerSensitiveForwardsFromAllParams {
public static void main(final String[] args) {
new AbstractMainAnalysis(args) {
@Override
protected Set<Path> _executeAnalysis() {
StoreDataTransformer<Set<Path>> dataStorage = new StoreDataTransformer<Set<Path>>();
SolverFactory.runOneDirectionSolver(AnalysisConfigurationBuilder.forwardsFromAllParametersDefaults(true).reporter(
new ResultForwardingReporter(new PathBuilderResultTransformer(dataStorage, new MergeEqualSelectorStrategy()))));
return dataStorage.getData();
}
}.execute();
}
}
| 1,027 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
JavaUtilKiller.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/JavaUtilKiller.java | package flow.twist.propagator;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import soot.SootClass;
import soot.SootMethod;
import soot.Unit;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
import flow.twist.config.AnalysisContext;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import flow.twist.util.AnalysisUtil;
public class JavaUtilKiller implements Propagator {
private AnalysisContext context;
public JavaUtilKiller(AnalysisContext context) {
this.context = context;
}
@Override
public boolean canHandle(Trackable trackable) {
return trackable instanceof Taint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
InvokeExpr ie = ((Stmt) callStmt).getInvokeExpr();
if (isJavaUtilMethod(ie.getMethod()))
return kill();
else
return identity();
}
private boolean isJavaUtilMethod(SootMethod method) {
if (method == null)
return false;
for (SootMethod initMethodDecl : AnalysisUtil.getInitialDeclaration(method)) {
SootClass clazz = initMethodDecl.getDeclaringClass();
if (clazz.getPackageName().equals("java.util") || clazz.getPackageName().startsWith("java.util.concurrent")) {
return true;
}
}
return false;
}
@Override
public KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
if (returnSite != null && isJavaUtilMethod(context.icfg.getMethodOf(returnSite)))
return kill();
else
return identity();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
return identity();
}
}
| 1,911 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PrimitiveTaintKiller.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/PrimitiveTaintKiller.java | package flow.twist.propagator;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import flow.twist.ifds.Propagator;
import flow.twist.ifds.Propagator.KillGenInfo;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import soot.ArrayType;
import soot.PrimType;
import soot.SootMethod;
import soot.Type;
import soot.Unit;
import soot.Value;
import soot.jimple.ArrayRef;
import soot.jimple.Stmt;
public class PrimitiveTaintKiller implements Propagator {
@Override
public boolean canHandle(Trackable trackable) {
return trackable instanceof Taint;
}
private boolean isPrimitive(Value value) {
while (value.getType() instanceof ArrayRef) {
value = ((ArrayRef) value.getType()).getBase();
}
if (value instanceof PrimType) {
return true;
}
Type type = value.getType();
while (type instanceof ArrayType) {
type = ((ArrayType) type).getArrayElementType();
}
if (type instanceof PrimType)
return true;
return false;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
if (isPrimitive(((Taint) trackable).value))
return kill();
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
if (isPrimitive(((Taint) trackable).value))
return kill();
return identity();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
if (isPrimitive(((Taint) trackable).value))
return kill();
return identity();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
if (isPrimitive(((Taint) trackable).value))
return kill();
return identity();
}
}
| 1,858 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
SpecificMethodKiller.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/SpecificMethodKiller.java | package flow.twist.propagator;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import soot.SootMethod;
import soot.Unit;
import soot.jimple.Stmt;
import flow.twist.config.AnalysisContext;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
public class SpecificMethodKiller implements Propagator {
private AnalysisContext context;
public SpecificMethodKiller(AnalysisContext context) {
this.context = context;
}
@Override
public boolean canHandle(Trackable trackable) {
return trackable instanceof Taint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
if (destinationMethod.toString().contains("sun.org.mozilla.javascript.internal.Interpreter"))
return kill();
return identity();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
if (returnSite != null && context.icfg.getMethodOf(returnSite).toString().contains("sun.org.mozilla.javascript.internal.Interpreter"))
return kill();
return identity();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
return identity();
}
}
| 1,481 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PropagateOverTarget.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/backwards/PropagateOverTarget.java | package flow.twist.propagator.backwards;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import static flow.twist.util.AnalysisUtil.isTarget;
import java.util.Set;
import soot.PrimType;
import soot.SootMethod;
import soot.Type;
import soot.Unit;
import soot.Value;
import soot.jimple.AssignStmt;
import soot.jimple.Constant;
import soot.jimple.InstanceInvokeExpr;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
import com.google.common.collect.Sets;
import flow.twist.config.AnalysisContext;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
public class PropagateOverTarget implements Propagator {
private AnalysisContext context;
public PropagateOverTarget(AnalysisContext context) {
this.context = context;
}
@Override
public boolean canHandle(Trackable trackable) {
return trackable instanceof Taint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
if (isTarget(context, callStmt)) {
return kill();
}
return identity();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
return identity();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
if (isTarget(context, callSite)) {
Taint taint = (Taint) trackable;
boolean returnValueTainted = false;
boolean receiverTainted = false;
if (callSite instanceof AssignStmt) {
AssignStmt assignStmt = (AssignStmt) callSite;
if (taint.value.equals(assignStmt.getLeftOp())) {
returnValueTainted = true;
}
}
if (callSite.getInvokeExpr() instanceof InstanceInvokeExpr) {
InstanceInvokeExpr iie = (InstanceInvokeExpr) callSite.getInvokeExpr();
Value receiver = iie.getBase();
if (taint.value.equals(receiver))
receiverTainted = true;
}
if (returnValueTainted || receiverTainted) {
InvokeExpr ie = callSite.getInvokeExpr();
Set<Taint> taints = Sets.newHashSet();
if (!receiverTainted && ie instanceof InstanceInvokeExpr) {
Value receiver = ((InstanceInvokeExpr) ie).getBase();
taints.add(new Taint(callSite, taint, receiver, receiver.getType()));
}
for (int i = 0; i < ie.getMethod().getParameterCount(); i++) {
Type parameterType = ie.getMethod().getParameterType(i);
if (!(parameterType instanceof PrimType) && !(ie.getArg(i) instanceof Constant)) {
taints.add(new Taint(callSite, taint, ie.getArg(i), parameterType));
}
}
return new KillGenInfo(returnValueTainted && !receiverTainted, taints);
}
}
return identity();
}
}
| 2,905 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PermissionCheckPropagator.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/backwards/PermissionCheckPropagator.java | package flow.twist.propagator.backwards;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import soot.SootMethod;
import soot.SootMethodRef;
import soot.Unit;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
public class PermissionCheckPropagator implements Propagator {
@Override
public boolean canHandle(Trackable trackable) {
return trackable instanceof Taint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
return identity();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
return identity();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
Taint taint = (Taint) trackable;
InvokeExpr ie = ((Stmt) callSite).getInvokeExpr();
SootMethodRef ref = ie.getMethodRef();
if (ref.declaringClass().getName().equals("sun.reflect.misc.ReflectUtil")
|| ref.declaringClass().getName().equals("java.lang.SecurityManager") && ref.name().equals("checkPackageAccess")
&& ie.getArg(0).equals(taint.value))
return kill();
return identity();
}
}
| 1,501 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
SinkHandler.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/backwards/SinkHandler.java | package flow.twist.propagator.backwards;
import flow.twist.config.AnalysisContext;
import flow.twist.config.AnalysisDirection;
import flow.twist.ifds.Propagator;
import flow.twist.targets.AnalysisTarget;
import flow.twist.trackable.Trackable;
import flow.twist.trackable.Zero;
import soot.SootMethod;
import soot.Unit;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
public class SinkHandler implements Propagator {
private AnalysisContext context;
public SinkHandler(AnalysisContext context) {
this.context = context;
}
@Override
public boolean canHandle(Trackable taint) {
return taint == Zero.ZERO;
}
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
throw new IllegalStateException();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
return KillGenInfo.kill();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable taint, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
throw new IllegalStateException();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable taint, Stmt callSite) {
final InvokeExpr ie = callSite.getInvokeExpr();
SootMethod enclosingMethod = context.icfg.getMethodOf(callSite);
for (AnalysisTarget t : context.targets) {
if (t.matches(AnalysisDirection.BACKWARDS, enclosingMethod, ie))
return t.processBackwardCallToReturn(taint, callSite, ie);
}
throw new IllegalStateException();
}
}
| 1,520 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
StringBuilderPropagator.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/backwards/StringBuilderPropagator.java | package flow.twist.propagator.backwards;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import static flow.twist.ifds.Propagator.KillGenInfo.propagate;
import java.util.Set;
import soot.RefType;
import soot.SootMethod;
import soot.Value;
import soot.jimple.Constant;
import soot.jimple.DefinitionStmt;
import soot.jimple.InstanceInvokeExpr;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
import com.google.common.collect.Sets;
import flow.twist.trackable.Taint;
//TODO handle StringBuilder.insert etc.
public class StringBuilderPropagator extends MethodFilteringPropagator {
public StringBuilderPropagator() {
super("<java.lang.StringBuffer: java.lang.String toString()>", "<java.lang.StringBuffer: java.lang.StringBuffer append(java.lang.Object)>",
"<java.lang.StringBuffer: java.lang.StringBuffer append(java.lang.CharSequence)>",
"<java.lang.StringBuffer: java.lang.StringBuffer append(java.lang.String)>",
"<java.lang.StringBuffer: void <init>(java.lang.String)>", "<java.lang.StringBuffer: void <init>(java.lang.CharSequence)>",
"<java.lang.StringBuffer: void <init>()>", "<java.lang.StringBuilder: java.lang.String toString()>",
"<java.lang.StringBuilder: java.lang.StringBuilder append(java.lang.Object)>",
"<java.lang.StringBuilder: java.lang.StringBuilder append(java.lang.CharSequence)>",
"<java.lang.StringBuilder: java.lang.StringBuilder append(java.lang.String)>",
"<java.lang.StringBuilder: void <init>(java.lang.String)>", "<java.lang.StringBuilder: void <init>(java.lang.CharSequence)>",
"<java.lang.StringBuilder: void <init>()>");
}
@Override
protected KillGenInfo handleMethodCall(Taint taint, Stmt callSite, InvokeExpr ie) {
if (isStringBuilderToString(ie)) {
if (callSite instanceof DefinitionStmt) {
DefinitionStmt definitionStmt = (DefinitionStmt) callSite;
final Value toStringReturnValue = definitionStmt.getLeftOp();
if (taint.value.equals(toStringReturnValue)) {
InstanceInvokeExpr iie = (InstanceInvokeExpr) ie;
Value stringBuilderObject = iie.getBase();
return propagate(new Taint(callSite, taint, stringBuilderObject, stringBuilderObject.getType()));
}
}
} else if (isStringBuilderAppend(ie)) {
// append returns a reference to the StringBuilder object, therefore
// parameters have to be tainted if the left side of an assignment
// is tainted, or if the instance append is called upon is tainted.
InstanceInvokeExpr iie = (InstanceInvokeExpr) ie;
Value stringBuilderObjectCallReceiver = iie.getBase();
boolean kill = false;
Set<Taint> genTaints = Sets.newHashSet();
if (callSite instanceof DefinitionStmt) {
DefinitionStmt definitionStmt = (DefinitionStmt) callSite;
final Value stringBuilderObjectLeftSide = definitionStmt.getLeftOp();
if (taint.value.equals(stringBuilderObjectLeftSide)) {
genTaints.add(taint.createAlias(stringBuilderObjectCallReceiver, callSite));
kill = true;
}
}
if (taint.value.equals(stringBuilderObjectCallReceiver) || !genTaints.isEmpty()) {
Value stringArg = ie.getArg(0);
if (!(stringArg instanceof Constant)) {
genTaints.add(new Taint(callSite, taint, stringArg, stringArg.getType()));
}
}
return new KillGenInfo(kill, genTaints);
} else if (isStringBuilderConstructorCall(ie)) {
InstanceInvokeExpr iie = (InstanceInvokeExpr) ie;
Value stringBuilderObject = iie.getBase();
if (taint.value.equals(stringBuilderObject)) {
if (ie.getArgCount() == 1 && ie.getArg(0).getType().equals(RefType.v("java.lang.String"))) {
Value arg = ie.getArg(0);
if (!(arg instanceof Constant))
return propagate(new Taint(callSite, taint, arg, arg.getType()));
}
return kill();
}
}
return identity();
}
public static boolean isStringBuilderToString(InvokeExpr ie) {
return ie.getMethodRef().name().equals("toString")
&& ie.getArgCount() == 0
&& (ie.getMethodRef().declaringClass().getName().equals("java.lang.StringBuilder") || ie.getMethodRef().declaringClass().getName()
.equals("java.lang.StringBuffer"));
}
public static boolean isStringBuilderAppend(InvokeExpr ie) {
return ie.getMethodRef().name().equals("append")
&& ie.getArgCount() == 1
&& (ie.getMethodRef().declaringClass().getName().equals("java.lang.StringBuilder") || ie.getMethodRef().declaringClass().getName()
.equals("java.lang.StringBuffer"));
}
public static boolean isStringBuilderConstructorCall(InvokeExpr ie) {
return ie.getMethodRef().name().equals(SootMethod.constructorName)
&& (ie.getMethodRef().declaringClass().getName().equals("java.lang.StringBuilder") || ie.getMethodRef().declaringClass().getName()
.equals("java.lang.StringBuffer"));
}
}
| 4,819 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ShortcutPropagator.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/backwards/ShortcutPropagator.java | package flow.twist.propagator.backwards;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import static flow.twist.ifds.Propagator.KillGenInfo.propagate;
import soot.Value;
import soot.jimple.AssignStmt;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
import flow.twist.trackable.Taint;
import flow.twist.util.AnalysisUtil;
public class ShortcutPropagator extends MethodFilteringPropagator {
private static final String VALUE_OF = "<java.lang.String: java.lang.String valueOf(java.lang.Object)>";
public ShortcutPropagator() {
super(VALUE_OF);
}
@Override
protected KillGenInfo handleMethodCall(Taint taint, Stmt callSite, InvokeExpr ie) {
if (ie.getMethodRef().getSignature().equals(VALUE_OF)) {
if (callSite instanceof AssignStmt) {
AssignStmt definitionStmt = (AssignStmt) callSite;
final Value returnValue = definitionStmt.getLeftOp();
if (taint.value.equals(returnValue)) {
Value objectArg = ie.getArg(0);
if (AnalysisUtil.isAssignable(taint.type, objectArg.getType()))
return propagate(new Taint(callSite, taint, objectArg, objectArg.getType()));
else
return kill();
}
}
}
return identity();
}
}
| 1,251 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
DefaultTaintPropagator.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/backwards/DefaultTaintPropagator.java | package flow.twist.propagator.backwards;
import static flow.twist.ifds.Propagator.KillGenInfo.gen;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import static flow.twist.ifds.Propagator.KillGenInfo.propagate;
import soot.Local;
import soot.SootMethod;
import soot.Type;
import soot.Unit;
import soot.Value;
import soot.jimple.AssignStmt;
import soot.jimple.Constant;
import soot.jimple.DefinitionStmt;
import soot.jimple.Jimple;
import soot.jimple.ReturnStmt;
import soot.jimple.Stmt;
import flow.twist.config.AnalysisContext;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.ReturnEdgeTaint;
import flow.twist.trackable.ReturnValueTaint;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import flow.twist.util.AnalysisUtil;
public class DefaultTaintPropagator implements Propagator {
private AnalysisContext context;
public DefaultTaintPropagator(AnalysisContext context) {
this.context = context;
}
@Override
public boolean canHandle(Trackable taint) {
return taint instanceof Taint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
if (!(curr instanceof DefinitionStmt))
return identity();
Taint taint = (Taint) trackable;
DefinitionStmt defStmt = (DefinitionStmt) curr;
// extract "base" locals of array refs
Value leftBase = AnalysisUtil.getBackwardsBase(defStmt.getLeftOp());
Value rightBase = AnalysisUtil.getBackwardsBase(defStmt.getRightOp());
if (!AnalysisUtil.maybeSameLocation(taint.value, leftBase))
return identity();
if (leftBase.equals(rightBase)) // x = x; or x[i] = x[j]; -> do nothing
return identity();
if (defStmt.getLeftOp() instanceof Local) { // Local
if (defStmt.getRightOp() instanceof Constant || !AnalysisUtil.isAssignable(taint.type, rightBase.getType()))
return kill();
return propagate(taint.createAlias(rightBase, curr));
} else { // Field
if (defStmt.getRightOp() instanceof Constant || !AnalysisUtil.isAssignable(taint.type, rightBase.getType()))
return identity();
// if the stmt defines a local then we know that this value we
// definitely overwritten;
// if it does not define a local (but, say, a FieldRef) then the
// value *may* have been
// overwritten; hence we need to track the source, too
return gen(taint.createAlias(rightBase, curr));
}
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
Taint taint = (Taint) trackable;
if (callStmt instanceof AssignStmt) {
AssignStmt assignStmt = (AssignStmt) callStmt;
if (taint.value.equals(assignStmt.getLeftOp())) {
if (AnalysisUtil.isAssignable(taint.type, destinationMethod.getReturnType())) {
for (Unit u : context.icfg.getStartPointsOf(destinationMethod)) {
if (u instanceof ReturnStmt) {
ReturnStmt returnStmt = (ReturnStmt) u;
Value retValue = returnStmt.getOp();
if (retValue instanceof Constant)
continue;
// There is at least one non constant return stmt
return propagate(new ReturnValueTaint(callStmt, trackable, taint.type));
}
}
}
}
}
return kill();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable taint, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
if (callSite == null)
return kill();
Taint t = (Taint) taint;
Stmt s = (Stmt) callSite;
final int paramCount = calleeMethod.getParameterCount();
final Value[] actualParams = new Value[paramCount];
for (int i = 0; i < paramCount; i++) {
actualParams[i] = s.getInvokeExpr().getArg(i);
}
for (int i = 0; i < paramCount; i++) {
Type parameterType = calleeMethod.getParameterType(i);
Value parameterRef = Jimple.v().newParameterRef(parameterType, i);
if (parameterRef.equivTo(t.value)) {
Value actualParam = actualParams[i];
// don't track constants
if (actualParam instanceof Local && AnalysisUtil.isAssignable(t.type, actualParam.getType())) {
return propagate(new ReturnEdgeTaint(callSite, exitStmt, taint, actualParam, i, t.type));
}
}
}
return kill();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
if (!(callSite instanceof DefinitionStmt))
return identity();
Taint taint = (Taint) trackable;
DefinitionStmt defStmt = (DefinitionStmt) callSite;
if (!defStmt.getLeftOp().equals(taint.value))
return identity();
if (defStmt.getLeftOp() instanceof Local) {
return kill();
} else {
// if the stmt defines a local then we know that this value we
// definitely overwritten;
// if it does not define a local (but, say, a FieldRef) then the
// value *may* have been
// overwritten; hence we need to track the source, too
return identity();
}
}
}
| 4,908 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
MethodFilteringPropagator.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/backwards/MethodFilteringPropagator.java | package flow.twist.propagator.backwards;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import java.util.Set;
import soot.SootMethod;
import soot.SootMethodRef;
import soot.Unit;
import soot.jimple.AssignStmt;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
import com.google.common.collect.Sets;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
public abstract class MethodFilteringPropagator implements Propagator {
protected final Set<String> methodSigs;
public MethodFilteringPropagator(String... methodSigs) {
this.methodSigs = Sets.newHashSet(methodSigs);
}
@Override
public boolean canHandle(Trackable trackable) {
return trackable instanceof Taint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable taint, Unit curr, Unit succ) {
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable taint, Unit callSite, SootMethod destinationMethod) {
if (callSite instanceof AssignStmt) {
final Stmt s = (Stmt) callSite;
final InvokeExpr ie = s.getInvokeExpr();
final SootMethodRef m = ie.getMethodRef();
if (methodSigs.contains(m.getSignature())) {
return kill();
}
}
return identity();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable taint, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
return identity();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
Taint taint = (Taint) trackable;
final Stmt s = (Stmt) callSite;
final InvokeExpr ie = s.getInvokeExpr();
final SootMethodRef m = ie.getMethodRef();
if (methodSigs.contains(m.getSignature())) {
return handleMethodCall(taint, callSite, ie);
}
return identity();
}
protected abstract KillGenInfo handleMethodCall(Taint taint, Stmt callSite, InvokeExpr ie);
}
| 1,960 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ReturnValuePropagator.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/backwards/ReturnValuePropagator.java | package flow.twist.propagator.backwards;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import static flow.twist.ifds.Propagator.KillGenInfo.propagate;
import soot.SootMethod;
import soot.Unit;
import soot.Value;
import soot.jimple.ArrayRef;
import soot.jimple.CastExpr;
import soot.jimple.Constant;
import soot.jimple.ReturnStmt;
import soot.jimple.Stmt;
import soot.jimple.ThrowStmt;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.ReturnValueTaint;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import flow.twist.util.AnalysisUtil;
public class ReturnValuePropagator implements Propagator {
@Override
public boolean canHandle(Trackable trackable) {
return trackable instanceof ReturnValueTaint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
if (curr instanceof ReturnStmt) {
Value retValue = getBase(((ReturnStmt) curr).getOp());
if (retValue instanceof Constant) {
return kill();
} else {
ReturnValueTaint retValTaint = (ReturnValueTaint) trackable;
if (AnalysisUtil.isAssignable(retValTaint.type, retValue.getType()))
return propagate(new Taint(curr, trackable, retValue, retValTaint.type));
else
return kill();
}
} else if (curr instanceof ThrowStmt)
return kill();
throw new IllegalStateException();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
throw new IllegalStateException();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
throw new IllegalStateException();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
throw new IllegalStateException();
}
/**
* extracts array base values from array refs and values from cast
* expressions
*/
private Value getBase(Value val) {
if (val instanceof ArrayRef) {
ArrayRef arrayRef = (ArrayRef) val;
return arrayRef.getBase();
}
if (val instanceof CastExpr) {
CastExpr castExpr = (CastExpr) val;
return castExpr.getOp();
}
return val;
}
}
| 2,215 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
NonStringKiller.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/backwards/NonStringKiller.java | package flow.twist.propagator.backwards;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import soot.ArrayType;
import soot.PrimType;
import soot.SootMethod;
import soot.Type;
import soot.Unit;
import soot.Value;
import soot.jimple.ArrayRef;
import soot.jimple.Stmt;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
public class NonStringKiller implements Propagator {
@Override
public boolean canHandle(Trackable trackable) {
return trackable instanceof Taint;
}
public static boolean isWrongType(Value value) {
while (value.getType() instanceof ArrayRef) {
value = ((ArrayRef) value.getType()).getBase();
}
if (value instanceof PrimType) {
return true;
}
Type type = value.getType();
while (type instanceof ArrayType) {
type = ((ArrayType) type).getArrayElementType();
}
if (type instanceof PrimType)
return true;
if (!type.toString().contains("String") && !type.toString().contains("Object") && !type.toString().contains("Serializable")
&& !type.toString().contains("Comparable") && !type.toString().contains("CharSequence"))
return true;
return false;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
if (isWrongType(((Taint) trackable).value))
return kill();
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
if (isWrongType(((Taint) trackable).value))
return kill();
return identity();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
if (isWrongType(((Taint) trackable).value))
return kill();
return identity();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
if (isWrongType(((Taint) trackable).value))
return kill();
return identity();
}
}
| 2,058 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ArgumentSourceHandler.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/backwards/ArgumentSourceHandler.java | package flow.twist.propagator.backwards;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import soot.Local;
import soot.SootMethod;
import soot.Unit;
import soot.Value;
import soot.jimple.IdentityStmt;
import soot.jimple.ParameterRef;
import soot.jimple.Stmt;
import flow.twist.TransitiveSinkCaller;
import flow.twist.config.AnalysisContext;
import flow.twist.ifds.Propagator;
import flow.twist.reporter.Report;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import flow.twist.util.AnalysisUtil;
public class ArgumentSourceHandler implements Propagator {
private final AnalysisContext context;
private TransitiveSinkCaller transitiveSinkCaller;
public ArgumentSourceHandler(AnalysisContext context, TransitiveSinkCaller transitiveSinkCaller) {
this.context = context;
this.transitiveSinkCaller = transitiveSinkCaller;
}
@Override
public boolean canHandle(Trackable taint) {
return taint instanceof Taint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable taint, Unit curr, Unit succ) {
if (!(curr instanceof IdentityStmt))
return identity();
IdentityStmt idStmt = (IdentityStmt) curr;
Value left = AnalysisUtil.getBackwardsBase(idStmt.getLeftOp());
Taint t = (Taint) taint;
if (!AnalysisUtil.maybeSameLocation(t.value, left))
return identity();
if (idStmt.getRightOp() instanceof ParameterRef) {
if (t.value instanceof Local) {
SootMethod m = context.icfg.getMethodOf(idStmt);
if (AnalysisUtil.methodMayBeCallableFromApplication(m) && transitiveSinkCaller.isTransitiveCallerOfAnySink(m)) {
context.reporter.reportTrackable(new Report(context, taint, curr));
}
}
}
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable taint, Unit callStmt, SootMethod destinationMethod) {
return identity();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable taint, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
return identity();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable taint, Stmt callSite) {
return identity();
}
}
| 2,131 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PropagateOverTarget.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/forwards/PropagateOverTarget.java | package flow.twist.propagator.forwards;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import static flow.twist.util.AnalysisUtil.isTarget;
import java.util.Set;
import soot.SootMethod;
import soot.Unit;
import soot.Value;
import soot.jimple.AssignStmt;
import soot.jimple.InstanceInvokeExpr;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
import com.google.common.collect.Sets;
import flow.twist.config.AnalysisConfiguration.Type;
import flow.twist.config.AnalysisContext;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
public class PropagateOverTarget implements Propagator {
private AnalysisContext context;
public PropagateOverTarget(AnalysisContext context) {
this.context = context;
}
@Override
public boolean canHandle(Trackable trackable) {
return trackable instanceof Taint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
if (isTarget(context, callStmt)) {
return kill();
}
return identity();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt,
Unit returnSite) {
return identity();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
if (isTarget(context, callSite)) {
Taint taint = (Taint) trackable;
InvokeExpr ie = callSite.getInvokeExpr();
boolean argsTainted = false;
boolean receiverIsTainted = false;
if (ie instanceof InstanceInvokeExpr) {
Value receiver = ((InstanceInvokeExpr) ie).getBase();
if (receiver.equals(taint.value)) {
receiverIsTainted = true;
}
}
for (Value arg : ie.getArgs()) {
if (arg.equivTo(taint.value)) {
argsTainted = true;
break;
}
}
if (argsTainted || receiverIsTainted) {
Set<Taint> newTaints = Sets.newHashSet();
if (callSite instanceof AssignStmt) {
Value left = ((AssignStmt) callSite).getLeftOp();
Taint returnValueTaint = new Taint(callSite, taint, left, left.getType());
if (context.type != Type.InnerToOuter)
returnValueTaint.addPayload("passedSink");
newTaints.add(returnValueTaint);
}
if (!receiverIsTainted && ie instanceof InstanceInvokeExpr) {
Value receiver = ((InstanceInvokeExpr) ie).getBase();
newTaints.add(new Taint(callSite, taint, receiver, receiver.getType()));
}
return new KillGenInfo(false, newTaints);
}
}
return identity();
}
}
| 2,729 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PayloadSourceRecognizer.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/forwards/PayloadSourceRecognizer.java | package flow.twist.propagator.forwards;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import java.util.Collections;
import java.util.HashSet;
import soot.SootMethod;
import soot.Unit;
import soot.Value;
import soot.jimple.ReturnStmt;
import soot.jimple.Stmt;
import com.google.common.collect.Sets;
import flow.twist.config.AnalysisContext;
import flow.twist.ifds.Propagator;
import flow.twist.reporter.Report;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import flow.twist.util.AnalysisUtil;
public class PayloadSourceRecognizer implements Propagator {
private final AnalysisContext context;
private HashSet<SootMethod> seedMethods;
public PayloadSourceRecognizer(AnalysisContext context) {
this.context = context;
this.seedMethods = Sets.newHashSet();
for (Unit seed : context.seedFactory.initialSeeds(context)) {
seedMethods.add(context.icfg.getMethodOf(seed));
}
}
@Override
public boolean canHandle(Trackable trackable) {
return trackable instanceof Taint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
return identity();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
boolean isSeedMethod = seedMethods.contains(context.icfg.getMethodOf(exitStmt));
if (!(exitStmt instanceof ReturnStmt))
return new KillGenInfo(isSeedMethod, Collections.<Trackable> emptyList());
Taint taint = (Taint) trackable;
ReturnStmt returnStmt = (ReturnStmt) exitStmt;
Value retVal = AnalysisUtil.getForwardsBase(returnStmt.getOp());
if (isSeedMethod && AnalysisUtil.maybeSameLocation(taint.value, retVal)) {
SootMethod m = context.icfg.getMethodOf(returnStmt);
if (AnalysisUtil.methodMayBeCallableFromApplication(m)) {
if (!trackable.getPayload().isEmpty()) {
context.reporter.reportTrackable(new Report(context, taint, exitStmt));
}
}
}
return new KillGenInfo(isSeedMethod, Collections.<Trackable> emptyList());
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
return identity();
}
}
| 2,337 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
PermissionCheckPropagator.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/forwards/PermissionCheckPropagator.java | package flow.twist.propagator.forwards;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import soot.SootMethod;
import soot.SootMethodRef;
import soot.Unit;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
public class PermissionCheckPropagator implements Propagator {
@Override
public boolean canHandle(Trackable trackable) {
return trackable instanceof Taint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
return identity();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
return identity();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
Taint taint = (Taint) trackable;
InvokeExpr ie = ((Stmt) callSite).getInvokeExpr();
SootMethodRef ref = ie.getMethodRef();
if (ref.declaringClass().getName().equals("sun.reflect.misc.ReflectUtil")
|| ref.declaringClass().getName().equals("java.lang.SecurityManager") && ref.name().equals("checkPackageAccess")
&& ie.getArg(0).equals(taint.value))
return kill();
return identity();
}
}
| 1,500 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
I2OSourceRecognizer.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/forwards/I2OSourceRecognizer.java | package flow.twist.propagator.forwards;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import soot.SootMethod;
import soot.Unit;
import soot.Value;
import soot.jimple.ReturnStmt;
import soot.jimple.Stmt;
import flow.twist.TransitiveSinkCaller;
import flow.twist.config.AnalysisContext;
import flow.twist.ifds.Propagator;
import flow.twist.reporter.Report;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import flow.twist.util.AnalysisUtil;
public class I2OSourceRecognizer implements Propagator {
private final AnalysisContext context;
private TransitiveSinkCaller transitiveSinkCaller;
public I2OSourceRecognizer(AnalysisContext context, TransitiveSinkCaller transitiveSinkCaller) {
this.context = context;
this.transitiveSinkCaller = transitiveSinkCaller;
}
@Override
public boolean canHandle(Trackable trackable) {
return trackable instanceof Taint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
return identity();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
if (!(exitStmt instanceof ReturnStmt))
return identity();
Taint taint = (Taint) trackable;
ReturnStmt returnStmt = (ReturnStmt) exitStmt;
Value retVal = AnalysisUtil.getForwardsBase(returnStmt.getOp());
if (AnalysisUtil.maybeSameLocation(taint.value, retVal)) {
SootMethod m = context.icfg.getMethodOf(returnStmt);
if (AnalysisUtil.methodMayBeCallableFromApplication(m) && transitiveSinkCaller.isTransitiveCallerOfAnySink(m)) {
context.reporter.reportTrackable(new Report(context, taint, exitStmt));
}
}
return identity();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
return identity();
}
}
| 2,007 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ZeroAtParameterHandler.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/forwards/ZeroAtParameterHandler.java | package flow.twist.propagator.forwards;
import flow.twist.config.AnalysisContext;
import flow.twist.config.AnalysisConfiguration.Type;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import flow.twist.trackable.Zero;
import soot.SootMethod;
import soot.Unit;
import soot.jimple.IdentityStmt;
import soot.jimple.Stmt;
public class ZeroAtParameterHandler implements Propagator {
private AnalysisContext context;
public ZeroAtParameterHandler(AnalysisContext context) {
this.context = context;
}
@Override
public boolean canHandle(Trackable taint) {
return taint == Zero.ZERO;
}
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
if (curr instanceof IdentityStmt) {
IdentityStmt idStmt = (IdentityStmt) curr;
if (idStmt.getRightOp().toString().contains("@parameter")) {
if (context.type == Type.ForwardsFromAllParameters || idStmt.getRightOp().getType().toString().equals("java.lang.String"))
return KillGenInfo.propagate(new Taint(curr, trackable, idStmt.getLeftOp(), idStmt.getLeftOp().getType()));
}
}
return KillGenInfo.kill();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
return KillGenInfo.kill();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable taint, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
throw new IllegalStateException();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable taint, Stmt callSite) {
throw new IllegalArgumentException();
}
}
| 1,638 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
StringBuilderPropagator.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/forwards/StringBuilderPropagator.java | package flow.twist.propagator.forwards;
import static flow.twist.ifds.Propagator.KillGenInfo.gen;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import java.util.Set;
import soot.SootMethod;
import soot.Value;
import soot.jimple.AssignStmt;
import soot.jimple.DefinitionStmt;
import soot.jimple.InstanceInvokeExpr;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
import com.google.common.collect.Sets;
import flow.twist.propagator.backwards.MethodFilteringPropagator;
import flow.twist.trackable.Taint;
import flow.twist.util.AnalysisUtil;
//TODO handle StringBuilder.insert etc.
public class StringBuilderPropagator extends MethodFilteringPropagator {
public StringBuilderPropagator() {
super("<java.lang.StringBuffer: java.lang.String toString()>", "<java.lang.StringBuffer: java.lang.StringBuffer append(java.lang.Object)>",
"<java.lang.StringBuffer: java.lang.StringBuffer append(java.lang.CharSequence)>",
"<java.lang.StringBuffer: java.lang.StringBuffer append(java.lang.String)>",
"<java.lang.StringBuffer: void <init>(java.lang.String)>", "<java.lang.StringBuffer: void <init>(java.lang.CharSequence)>",
"<java.lang.StringBuffer: void <init>()>", "<java.lang.StringBuilder: java.lang.String toString()>",
"<java.lang.StringBuilder: java.lang.StringBuilder append(java.lang.Object)>",
"<java.lang.StringBuilder: java.lang.StringBuilder append(java.lang.CharSequence)>",
"<java.lang.StringBuilder: java.lang.StringBuilder append(java.lang.String)>",
"<java.lang.StringBuilder: void <init>(java.lang.String)>", "<java.lang.StringBuilder: void <init>(java.lang.CharSequence)>",
"<java.lang.StringBuilder: void <init>()>");
}
@Override
protected KillGenInfo handleMethodCall(Taint taint, Stmt callSite, InvokeExpr ie) {
if (isStringBuilderToString(ie)) {
if (callSite instanceof AssignStmt) {
AssignStmt definitionStmt = (AssignStmt) callSite;
InstanceInvokeExpr iie = (InstanceInvokeExpr) ie;
Value stringBuilderObjectCallReceiver = iie.getBase();
if (AnalysisUtil.maybeSameLocation(taint.value, stringBuilderObjectCallReceiver)) {
final Value toStringReturnValue = definitionStmt.getLeftOp();
return gen(new Taint(callSite, taint, toStringReturnValue, toStringReturnValue.getType()));
}
}
} else if (isStringBuilderAppend(ie)) {
InstanceInvokeExpr iie = (InstanceInvokeExpr) ie;
Value stringBuilderObjectCallReceiver = iie.getBase();
Value argValue = ie.getArg(0);
boolean genReturn = false;
boolean callReceiverTainted;
if (AnalysisUtil.maybeSameLocation(taint.value, stringBuilderObjectCallReceiver)) {
genReturn = true;
callReceiverTainted = true;
} else {
callReceiverTainted = false;
}
if (AnalysisUtil.maybeSameLocation(taint.value, argValue)) {
genReturn = true;
}
Set<Taint> genTaints = Sets.newHashSet();
if (genReturn && callSite instanceof DefinitionStmt) {
final Value returnValue = ((DefinitionStmt) callSite).getLeftOp();
if (!AnalysisUtil.maybeSameLocation(taint.value, returnValue))
genTaints.add(new Taint(callSite, taint, returnValue, returnValue.getType()));
if (stringBuilderObjectCallReceiver.equals(returnValue))
callReceiverTainted = true;
}
if (!callReceiverTainted) {
genTaints.add(new Taint(callSite, taint, stringBuilderObjectCallReceiver, stringBuilderObjectCallReceiver.getType()));
}
return new KillGenInfo(false, genTaints);
} else if (isStringBuilderConstructorCall(ie)) {
InstanceInvokeExpr iie = (InstanceInvokeExpr) ie;
Value stringBuilderObject = iie.getBase();
if (ie.getArgCount() == 1) {
Value argValue = ie.getArg(0);
if (AnalysisUtil.maybeSameLocation(taint.value, argValue)) {
return gen(new Taint(callSite, taint, stringBuilderObject, stringBuilderObject.getType()));
}
}
}
return identity();
}
public static boolean isStringBuilderToString(InvokeExpr ie) {
return ie.getMethodRef().name().equals("toString")
&& ie.getArgCount() == 0
&& (ie.getMethodRef().declaringClass().getName().equals("java.lang.StringBuilder") || ie.getMethodRef().declaringClass().getName()
.equals("java.lang.StringBuffer"));
}
public static boolean isStringBuilderAppend(InvokeExpr ie) {
return ie.getMethodRef().name().equals("append")
&& ie.getArgCount() == 1
&& (ie.getMethodRef().declaringClass().getName().equals("java.lang.StringBuilder") || ie.getMethodRef().declaringClass().getName()
.equals("java.lang.StringBuffer"));
}
public static boolean isStringBuilderConstructorCall(InvokeExpr ie) {
return ie.getMethodRef().name().equals(SootMethod.constructorName)
&& (ie.getMethodRef().declaringClass().getName().equals("java.lang.StringBuilder") || ie.getMethodRef().declaringClass().getName()
.equals("java.lang.StringBuffer"));
}
}
| 4,861 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
ShortcutPropagator.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/forwards/ShortcutPropagator.java | package flow.twist.propagator.forwards;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.propagate;
import soot.Value;
import soot.jimple.AssignStmt;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
import flow.twist.propagator.backwards.MethodFilteringPropagator;
import flow.twist.trackable.Taint;
import flow.twist.util.AnalysisUtil;
public class ShortcutPropagator extends MethodFilteringPropagator {
private static final String VALUE_OF = "<java.lang.String: java.lang.String valueOf(java.lang.Object)>";
public ShortcutPropagator() {
super(VALUE_OF);
}
@Override
protected KillGenInfo handleMethodCall(Taint taint, Stmt callSite, InvokeExpr ie) {
if (ie.getMethodRef().getSignature().equals(VALUE_OF)) {
if (callSite instanceof AssignStmt) {
AssignStmt definitionStmt = (AssignStmt) callSite;
Value argValue = definitionStmt.getInvokeExpr().getArg(0);
if (AnalysisUtil.maybeSameLocation(taint.value, argValue)) {
final Value returnValue = definitionStmt.getLeftOp();
return propagate(new Taint(callSite, taint, returnValue, returnValue.getType()));
}
}
}
return identity();
}
}
| 1,209 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
DefaultTaintPropagator.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/forwards/DefaultTaintPropagator.java | package flow.twist.propagator.forwards;
import static flow.twist.ifds.Propagator.KillGenInfo.gen;
import static flow.twist.ifds.Propagator.KillGenInfo.identity;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import static flow.twist.ifds.Propagator.KillGenInfo.propagate;
import java.util.ArrayList;
import java.util.Iterator;
import soot.Local;
import soot.SootMethod;
import soot.Unit;
import soot.Value;
import soot.jimple.AssignStmt;
import soot.jimple.CastExpr;
import soot.jimple.DefinitionStmt;
import soot.jimple.IdentityStmt;
import soot.jimple.ParameterRef;
import soot.jimple.ReturnStmt;
import soot.jimple.Stmt;
import com.google.common.collect.Lists;
import flow.twist.config.AnalysisContext;
import flow.twist.ifds.Propagator;
import flow.twist.trackable.ParameterTaint;
import flow.twist.trackable.ReturnEdgeTaint;
import flow.twist.trackable.Taint;
import flow.twist.trackable.Trackable;
import flow.twist.util.AnalysisUtil;
public class DefaultTaintPropagator implements Propagator {
private AnalysisContext context;
public DefaultTaintPropagator(AnalysisContext context) {
this.context = context;
}
@Override
public boolean canHandle(Trackable taint) {
return taint instanceof Taint;
}
@Override
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
Taint taint = (Taint) trackable;
if (curr instanceof DefinitionStmt) {
DefinitionStmt defStmt = (DefinitionStmt) curr;
Value rightBase = AnalysisUtil.getForwardsBase(defStmt.getRightOp());
Value leftBase = AnalysisUtil.getForwardsBase(defStmt.getLeftOp());
if (leftBase.equals(rightBase)) // x = x; or x[i] = x[j]; -> do
// nothing
return identity();
// kill the LHS if it is assigned another value
Value left = defStmt.getLeftOp();
if (left instanceof Local && taint.value.equals(left)) {
return kill();
}
if (rightBase instanceof CastExpr) {
CastExpr castExpr = (CastExpr) rightBase;
if (AnalysisUtil.maybeSameLocation(taint.value, castExpr.getOp())) {
if (AnalysisUtil.isAssignable(taint.type, leftBase.getType())) {
return gen(taint.createAlias(leftBase, curr));
} else {
return identity();
}
}
}
// at assignments, propagate taint from right to left
if (taint.value.equivTo(rightBase) || AnalysisUtil.maybeSameLocation(taint.value, rightBase)) {
return gen(taint.createAlias(leftBase, curr));
}
}
return identity();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
if (!destinationMethod.hasActiveBody())
return kill();
Taint taint = (Taint) trackable;
Stmt s = (Stmt) callStmt;
ArrayList<Taint> propagations = Lists.newArrayList();
final int paramCount = destinationMethod.getParameterCount();
Value[] destinationValues = getParameterValues(destinationMethod);
for (int i = 0; i < paramCount; i++) {
if (s.getInvokeExpr().getArg(i).equivTo(taint.value)) {
propagations.add(new ParameterTaint(callStmt, taint, destinationValues[i], taint.type));
}
}
if (propagations.size() == 0)
return kill();
else
return propagate(propagations.toArray(new Trackable[propagations.size()]));
}
private Value[] getParameterValues(SootMethod destinationMethod) {
int paramsFound = 0;
Value[] result = new Value[destinationMethod.getParameterCount()];
for (Unit unit : destinationMethod.getActiveBody().getUnits()) {
if (!(unit instanceof IdentityStmt))
continue;
Value rightOp = ((IdentityStmt) unit).getRightOp();
if (!(rightOp instanceof ParameterRef))
continue;
ParameterRef paramRef = (ParameterRef) rightOp;
result[paramRef.getIndex()] = paramRef;
paramsFound++;
if (paramsFound == result.length)
break;
}
return result;
}
public Value getParameter(SootMethod destinationMethod, int i) {
Iterator<Unit> unitsIt = destinationMethod.getActiveBody().getUnits().iterator();
while (unitsIt.hasNext()) {
Unit s = unitsIt.next();
if (s instanceof IdentityStmt) {
Value rightOp = ((IdentityStmt) s).getRightOp();
if (rightOp instanceof ParameterRef && ((ParameterRef) rightOp).getIndex() == i) {
return rightOp;
}
}
}
throw new RuntimeException("couldn't find parameterref for index " + i + " in " + destinationMethod);
}
@Override
public KillGenInfo propagateReturnFlow(Trackable trackable, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
Taint taint = (Taint) trackable;
if (!(exitStmt instanceof ReturnStmt))
return kill();
if (!(callSite instanceof AssignStmt))
return kill();
ReturnStmt returnStmt = (ReturnStmt) exitStmt;
AssignStmt assignStmt = (AssignStmt) callSite;
if (!returnStmt.getOp().equivTo(taint.value))
return kill();
Value left = AnalysisUtil.getForwardsBase(assignStmt.getLeftOp());
// return propagate(taint.createAlias(left, callSite));
// return propagate(taint.createAlias(left, exitStmt));
return propagate(new ReturnEdgeTaint(callSite, exitStmt, taint, left, -1, taint.type));
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable trackable, Stmt callSite) {
Taint taint = (Taint) trackable;
if (callSite instanceof AssignStmt) {
AssignStmt assignStmt = (AssignStmt) callSite;
Value left = assignStmt.getLeftOp();
if (left instanceof Local && taint.value.equals(left)) {
return kill();
}
}
return identity();
}
}
| 5,479 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
I2OZeroHandler.java | /FileExtraction/Java_unseen/johanneslerch_FlowTwist/FlowTwist/src/flow/twist/propagator/forwards/I2OZeroHandler.java | package flow.twist.propagator.forwards;
import static flow.twist.ifds.Propagator.KillGenInfo.kill;
import flow.twist.config.AnalysisContext;
import flow.twist.config.AnalysisDirection;
import flow.twist.ifds.Propagator;
import flow.twist.targets.AnalysisTarget;
import flow.twist.trackable.Trackable;
import flow.twist.trackable.Zero;
import soot.SootMethod;
import soot.Unit;
import soot.Value;
import soot.jimple.ArrayRef;
import soot.jimple.AssignStmt;
import soot.jimple.InvokeExpr;
import soot.jimple.Stmt;
public class I2OZeroHandler implements Propagator {
private AnalysisContext context;
public I2OZeroHandler(AnalysisContext context) {
this.context = context;
}
@Override
public boolean canHandle(Trackable taint) {
return taint == Zero.ZERO;
}
public KillGenInfo propagateNormalFlow(Trackable trackable, Unit curr, Unit succ) {
throw new IllegalStateException();
}
@Override
public KillGenInfo propagateCallFlow(Trackable trackable, Unit callStmt, SootMethod destinationMethod) {
return KillGenInfo.kill();
}
@Override
public KillGenInfo propagateReturnFlow(Trackable taint, Unit callSite, SootMethod calleeMethod, Unit exitStmt, Unit returnSite) {
throw new IllegalStateException();
}
@Override
public KillGenInfo propagateCallToReturnFlow(Trackable taint, Stmt callSite) {
if (callSite instanceof AssignStmt) {
AssignStmt assignStmt = (AssignStmt) callSite;
final InvokeExpr ie = assignStmt.getInvokeExpr();
SootMethod enclosingMethod = context.icfg.getMethodOf(assignStmt);
for (AnalysisTarget t : context.targets)
if (t.matches(AnalysisDirection.FORWARDS, enclosingMethod, ie))
return t.processForwardCallToReturn(taint, callSite, ie, getBase(assignStmt.getLeftOp()));
}
return kill();
}
private Value getBase(Value val) {
if (val instanceof ArrayRef) {
ArrayRef arrayRef = (ArrayRef) val;
return arrayRef.getBase();
}
return val;
}
}
| 1,931 | Java | .java | johanneslerch/FlowTwist | 9 | 4 | 0 | 2014-03-14T10:26:08Z | 2015-02-13T09:54:39Z |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.