/** * Returns a (possibly not yet resolved) SootClass to be used in references to a class. If/when the class is resolved, it * will be resolved into this SootClass. */ public SootClass makeClassRef(String className) { if (Scene.v().containsClass(className)) { return Scene.v().getSootClass(className); } SootClass newClass; newClass = new SootClass(className); newClass.setResolvingLevel(SootClass.DANGLING); Scene.v().addClass(newClass); return newClass; }
public JimpleBasedInterproceduralCFG(boolean enableExceptions, boolean includeReflectiveCalls) { super(enableExceptions); this.includeReflectiveCalls = includeReflectiveCalls; cg = Scene.v().getCallGraph(); initializeUnitToOwner(); }
private Set<SootClass> getChildrenOfIncluding(Collection<SootClass> classes) { return Stream .concat(classes.stream().filter(c -> !c.getName().equals("java.lang.Object")) .map(c -> c.isInterface() ? Scene.v().getActiveHierarchy().getImplementersOf(c) : Scene.v().getActiveHierarchy().getSubclassesOf(c)) .flatMap(Collection::stream), classes.stream()) .collect(toSet()); }
public SootField grabField(String fieldSignature) { String cname = signatureToClass(fieldSignature); String fname = signatureToSubsignature(fieldSignature); if (!containsClass(cname)) { return null; } SootClass c = getSootClass(cname); return c.getFieldUnsafe(fname); }
/** * Retrieves the active side-effect analysis */ public SideEffectAnalysis getSideEffectAnalysis() { if (!hasSideEffectAnalysis()) { setSideEffectAnalysis(new SideEffectAnalysis(getPointsToAnalysis(), getCallGraph())); } return activeSideEffectAnalysis; }
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); exception = Scene.v().getSootClass((String) in.readObject()); }
private Set<SootMethod> inferSource(String source, int lineNumber) { String className = source.substring(0, source.lastIndexOf(".")); String methodName = source.substring(source.lastIndexOf(".") + 1); if (!Scene.v().containsClass(className)) { Scene.v().addBasicClass(className, SootClass.BODIES); Scene.v().loadBasicClasses(); if (!Scene.v().containsClass(className)) { throw new RuntimeException("Trace file refers to unknown class: " + className); SootClass sootClass = Scene.v().getSootClass(className); Set<SootMethod> methodsWithRightName = new LinkedHashSet<SootMethod>(); for (SootMethod m : sootClass.getMethods()) {
@Override protected void internalTransform(String phaseName, Map<String, String> options) { for (SootClass sc : Scene.v().getClasses()) { transformClass(sc); } }
Scene.v().addBasicClass(className, SootClass.SIGNATURES); } else Options.v().set_src_prec(Options.src_prec_class); Scene.v().loadNecessaryClasses(); for (Iterator<SootClass> scIt = Scene.v().getApplicationClasses().snapshotIterator(); scIt.hasNext();) { SootClass sc = scIt.next(); Scene.v().forceResolve(sc.getName(), SootClass.SIGNATURES); if (sc.isConcrete()) checkAndAdd(realClasses, sc.getName()); if (className.endsWith(".*")) { String prefix = className.substring(0, className.length() - 1); for (Iterator<SootClass> scIt = Scene.v().getClasses().snapshotIterator(); scIt.hasNext();) { SootClass sc = scIt.next(); if (sc.getName().startsWith(prefix)) { Scene.v().forceResolve(sc.getName(), SootClass.SIGNATURES); if (sc.isConcrete()) checkAndAdd(realClasses, sc.getName()); SootClass sc = Scene.v().getSootClass(className); if (!sc.isConcrete()) { SootClass sc = Scene.v().getSootClass(analysisTask.className); for (SootMethod sm : sc.getMethods()) { if (checkAndAdd(analysisTask, sm)) {
protected void internalApply() { CGOptions options = new CGOptions(PhaseOptions.v().getPhaseOptions(this)); if (!Scene.v().hasCustomEntryPoints()) { if (!options.implicit_entry()) { Scene.v().setEntryPoints(EntryPoints.v().application()); } if (options.all_reachable()) { List<SootMethod> entryPoints = new ArrayList<SootMethod>(); entryPoints.addAll(EntryPoints.v().all()); entryPoints.addAll(EntryPoints.v().methodsOfApplicationClasses()); Scene.v().setEntryPoints(entryPoints); } } super.internalApply(); ClinitElimTransformer trimmer = new ClinitElimTransformer(); if (options.trim_clinit()) { for (SootClass cl : Scene.v().getClasses(SootClass.BODIES)) { for (SootMethod m : cl.getMethods()) { if (m.isConcrete() && m.hasActiveBody()) { trimmer.transform(m.getActiveBody()); } } } } } }
Iterator<SootClass> it = Scene.v().getApplicationClasses().snapshotIterator(); while (it.hasNext()) { List<SootMethod> initMethodsToRewrite = new ArrayList<>(); Scene.v().releaseActiveHierarchy(); mediatingClass.setSuperclass(originalSuperclass); Scene.v().addClass(mediatingClass); mediatingClass.setApplicationClass(); mediatingClass.setInScene(true); newMethod = Scene.v().makeSootMethod(newMethodName, paramTypes, returnType, modifiers, exceptions); mediatingClass.addMethod(newMethod); newMethod = Scene.v().makeSootMethod(originalSuperclassMethod.getName(), paramTypes, returnType, modifiers, exceptions); mediatingClass.addMethod(newMethod); if (!mediatingClass.declaresMethod(constructorName, smr.parameterTypes())) { List<Type> paramTypes = smr.parameterTypes(); newSuperInit = Scene.v().makeSootMethod(constructorName, paramTypes, smr.returnType()); mediatingClass.addMethod(newSuperInit); Scene.v().releaseActiveHierarchy(); Scene.v().getActiveHierarchy(); Scene.v().setFastHierarchy(new FastHierarchy());
public static void main(String[] args) { // assumes 2 args: Class + Method Scene.v().loadClassAndSupport(args[0]); SootClass sc = Scene.v().getSootClass(args[0]); SootMethod sm = sc.getMethod(args[1]); Body b = sm.retrieveActiveBody(); CompleteBlockGraph cfg = new CompleteBlockGraph(b); System.out.println(cfg); BlockGraphConverter.addStartStopNodesTo(cfg); System.out.println(cfg); BlockGraphConverter.reverse(cfg); System.out.println(cfg); }
Options.v().set_allow_phantom_refs(true); SootClass sootClass = Scene.v().forceResolve(className, SootClass.SIGNATURES); Scene.v().loadNecessaryClasses(); for (SootMethod method : sootClass.getMethods()) { for (Map.Entry<String, String> entry : map.getValue().entrySet()) {
public void applyTransformation() { ArrayType objAr = ArrayType.v(Scene.v().getSootClass("java.lang.Object").getType(), 1); RefType objArRepl = getArrayReplacementType(objAr); List<SootClass> classes = new LinkedList<SootClass>(Scene.v().getClasses()); List<JimpleBody> bodies = new LinkedList<JimpleBody>(); List<SootMethod> entryPoints = new LinkedList<SootMethod>(Scene.v().getEntryPoints()); for (SootClass sc : classes) { if (sc.resolvingLevel() >= SootClass.SIGNATURES) { Scene.v().setEntryPoints(entryPoints);
@Override protected void initializeAnalysis(A commandLineArguments) { addSceneTransformer(); Options.v().set_no_bodies_for_excluded(true); Options.v().set_allow_phantom_refs(true); Options.v().set_output_format(Options.output_format_none); Options.v().set_whole_program(true); Options.v().set_soot_classpath( commandLineArguments.getInput() + File.pathSeparator + commandLineArguments.getClasspath()); Options.v().setPhaseOption("cg.spark", "on"); // do not merge variables (causes problems with PointsToSets) Options.v().setPhaseOption("jb.ulp", "off"); // Options.v().setPhaseOption("jb.ne", "off"); Options.v().setPhaseOption("jb.uce", "remove-unreachable-traps:true"); Options.v().setPhaseOption("cg", "trim-clinit:false"); Options.v().set_prepend_classpath(true); Options.v().set_src_prec(Options.src_prec_java); for (String analysisClass : AnalysisParameters.v().getAnalysisClasses()) { SootClass sootClass = Scene.v().loadClassAndSupport(analysisClass); Scene.v().forceResolve(analysisClass, SootClass.BODIES); sootClass.setApplicationClass(); } Scene.v().loadNecessaryClasses(); Scene.v().setMainClassFromOptions(); Scene.v().setEntryPoints(EntryPoints.v().application()); }
private void constantForName(String cls, SootMethod src, Stmt srcUnit) { if (cls.length() > 0 && cls.charAt(0) == '[') { if (cls.length() > 1 && cls.charAt(1) == 'L' && cls.charAt(cls.length() - 1) == ';') { cls = cls.substring(2, cls.length() - 1); constantForName(cls, src, srcUnit); } } else { if (!Scene.v().containsClass(cls)) { if (options.verbose()) { logger.warn("Class " + cls + " is" + " a dynamic class, and you did not specify" + " it as such; graph will be incomplete!"); } } else { SootClass sootcls = Scene.v().getSootClass(cls); if (!sootcls.isPhantomClass()) { if (!sootcls.isApplicationClass()) { sootcls.setLibraryClass(); } for (SootMethod clinit : EntryPoints.v().clinitsOf(sootcls)) { addEdge(src, srcUnit, clinit, Kind.CLINIT); } } } } }
Scene.v().addBasicClass(s, SootClass.BODIES); Scene.v().addBasicClass("java.lang.System", SootClass.SIGNATURES); Scene.v().addBasicClass("java.lang.Thread", SootClass.SIGNATURES); Scene.v().addBasicClass("java.lang.ThreadGroup", SootClass.SIGNATURES); Scene.v().addBasicClass("java.lang.ClassLoader", SootClass.SIGNATURES); Scene.v().addBasicClass("java.security.PrivilegedActionException", SootClass.SIGNATURES); Scene.v().addBasicClass("java.lang.ref.Finalizer", SootClass.SIGNATURES); Scene.v().loadBasicClasses(); Scene.v().loadNecessaryClasses(); for (SootClass sc : Scene.v().getClasses()) { if (sc.resolvingLevel() < SootClass.SIGNATURES) { sc.setResolvingLevel(SootClass.SIGNATURES);
@Override protected void internalTransform(String phaseName, Map<String, String> options) { PurityOptions opts = new PurityOptions(options); logger.debug("[AM] Analysing purity"); CallGraph cg = Scene.v().getCallGraph(); // launch the analysis new PurityInterproceduralAnalysis(cg, Scene.v().getEntryPoints().iterator(), opts); } }
RTI = new ReflectionTraceInfo(logFilePath); Scene.v().getSootClass(SootSig.class.getName()).setApplicationClass(); Scene.v().getSootClass(UnexpectedReflectiveCall.class.getName()).setApplicationClass(); Scene.v().getSootClass(IUnexpectedReflectiveCallHandler.class.getName()).setApplicationClass(); Scene.v().getSootClass(DefaultHandler.class.getName()).setApplicationClass(); Scene.v().getSootClass(OpaquePredicate.class.getName()).setApplicationClass(); Scene.v().getSootClass(ReflectiveCalls.class.getName()).setApplicationClass(); Scene.v().addClass(reflectiveCallsClass); reflectiveCallsClass.setApplicationClass(); UNINTERPRETED_METHOD = Scene.v().makeMethodRef(Scene.v().getSootClass("soot.rtlib.tamiflex.OpaquePredicate"), "getFalse", Collections.<Type>emptyList(), BooleanType.v(), true);
public MonitorConverter(Singletons.Global g) { SootClass davaMonitor = new SootClass("soot.dava.toolkits.base.DavaMonitor.DavaMonitor", Modifier.PUBLIC); davaMonitor.setSuperclass(Scene.v().loadClassAndSupport("java.lang.Object")); LinkedList objectSingleton = new LinkedList(); objectSingleton.add(RefType.v("java.lang.Object")); v = Scene.v().makeSootMethod("v", new LinkedList(), RefType.v("soot.dava.toolkits.base.DavaMonitor.DavaMonitor"), Modifier.PUBLIC | Modifier.STATIC); enter = Scene.v().makeSootMethod("enter", objectSingleton, VoidType.v(), Modifier.PUBLIC | Modifier.SYNCHRONIZED); exit = Scene.v().makeSootMethod("exit", objectSingleton, VoidType.v(), Modifier.PUBLIC | Modifier.SYNCHRONIZED); davaMonitor.addMethod(v); davaMonitor.addMethod(enter); davaMonitor.addMethod(exit); Scene.v().addClass(davaMonitor); }