private static Collection<AncestryTreeNode> buildAncestryTree(RefType root) { if (root.getSootClass().isPhantom()) { return Collections.emptyList(); } LinkedList<AncestryTreeNode> leafs = new LinkedList<AncestryTreeNode>(); leafs.add(new AncestryTreeNode(null, root)); LinkedList<AncestryTreeNode> r = new LinkedList<AncestryTreeNode>(); final RefType objectType = RefType.v("java.lang.Object"); while (!leafs.isEmpty()) { AncestryTreeNode node = leafs.remove(); if (TypeResolver.typesEqual(node.type, objectType)) { r.add(node); } else { SootClass sc = node.type.getSootClass(); for (SootClass i : sc.getInterfaces()) { leafs.add(new AncestryTreeNode(node, (i).getType())); } // The superclass of all interfaces is Object // -- try to discard phantom interfaces. if ((!sc.isInterface() || sc.getInterfaceCount() == 0) && !sc.isPhantom()) { leafs.add(new AncestryTreeNode(node, sc.getSuperclass().getType())); } } } return r; }
public static void retrieveAllNames() { if (namesHaveBeenRetrieved) { return; } // iterate through application classes, rename fields with junk for (SootClass c : soot.Scene.v().getApplicationClasses()) { nameList.add(c.getName()); for (SootMethod m : c.getMethods()) { nameList.add(m.getName()); } for (SootField m : c.getFields()) { nameList.add(m.getName()); } } namesHaveBeenRetrieved = true; }
private void loadNecessaryClass(String name) { SootClass c; c = loadClassAndSupport(name); c.setApplicationClass(); }
/** * WARNING: interfaces are subclasses of the java.lang.Object class! Returns the superclass of this class. (see * hasSuperclass()) */ public SootClass getSuperclass() { checkLevel(HIERARCHY); if (superClass == null && !isPhantom()) { throw new RuntimeException("no superclass for " + getName()); } else { return superClass; } }
private boolean isCallClassSubClass(SootClass call, SootClass check) { if (!call.hasSuperclass()) { return false; } if (call.getSuperclass().equals(check)) { return true; } return false; }
public static List<SootField> getAllFields(SootClass sc) { // Get list of reachable methods declared in this class // Also get list of fields declared in this class List<SootField> allFields = new ArrayList<SootField>(); for (SootField field : sc.getFields()) { allFields.add(field); } // Add reachable methods and fields declared in superclasses SootClass superclass = sc; if (superclass.hasSuperclass()) { superclass = superclass.getSuperclass(); } while (superclass.hasSuperclass()) // we don't want to process Object { for (SootField scField : superclass.getFields()) { allFields.add(scField); } superclass = superclass.getSuperclass(); } return allFields; }
String enclosingClassname = enclosingClass.getName(); String enclosingClassnamePrefix = null; if (enclosingClassname == null || enclosingClassname.equals("")) { SootClass tclass = new SootClass(className); tclass.setModifiers(Modifier.PUBLIC | Modifier.FINAL); tclass.setSuperclass(Scene.v().getObjectType().getSootClass()); tclass.addInterface(functionalInterfaceToImplement); tclass.addInterface(RefType.v("java.io.Serializable").getSootClass()); tclass.addInterface(((RefType) AsmUtil.toBaseType(markerInterfaces.get(i).getValue())).getSootClass()); SootField f = new SootField("cap" + i, capTypes.get(i), 0); capFields.add(f); tclass.addField(f); if (implMethod.getMethodRef().declaringClass().getName().equals(enclosingClassname)) { SootMethod method = implMethod.getMethodRef().declaringClass().getMethod(implMethod.getMethodRef().getSubSignature()); int modifiers = method.getModifiers() & ~Modifier.PRIVATE; modifiers = modifiers | Modifier.PUBLIC; SootMethod tboot = new SootMethod("bootstrap$", capTypes, functionalInterfaceToImplement.getType(), Modifier.PUBLIC | Modifier.STATIC); tclass.addMethod(tboot); tboot.setSource(ms); tclass.addMethod(tctor);
Map<String, SootMethod> methodsToAdd = new HashMap<>(); SootClass sc = it.next(); SootClass originalSuperclass = sc.getSuperclass(); out.println("Processing " + sc.getName() + " with super " + originalSuperclass.getName()); Iterator<SootMethod> methodIterator = sc.methodIterator(); while (methodIterator.hasNext()) { SootMethod method = methodIterator.next(); final String fullName = ClassRenamer.v().getOrAddNewName(ClassRenamer.getPackageName(sc.getName()), null); SootClass mediatingClass = new SootClass(fullName, sc.getModifiers() & (~Modifier.FINAL)); Main.IntermediateAppClasses.add(mediatingClass); mediatingClass.setSuperclass(originalSuperclass); mediatingClass.setApplicationClass(); mediatingClass.setInScene(true); ThisRef thisRef = new ThisRef(mediatingClass.getType()); mediatingClass.addMethod(newMethod); mediatingClass.addMethod(newMethod); sc.setSuperclass(mediatingClass); SpecialInvokeExpr sie = (SpecialInvokeExpr) v; SootMethodRef smr = sie.getMethodRef();
/** * @ast method * @aspect EmitJimple * @declaredat /Users/eric/Documents/workspaces/clara-soot/JastAddExtensions/JimpleBackend/EmitJimple.jrag:186 */ public void jimplify1phase2() { SootClass sc = getSootClassDecl(); sc.setResolvingLevel(SootClass.DANGLING); sc.setModifiers(sootTypeModifiers()); sc.setApplicationClass(); SourceFileTag st = new soot.tagkit.SourceFileTag(sourceNameWithoutPath()); st.setAbsolutePath(compilationUnit().pathName()); sc.addTag(st); sc.setSuperclass(typeObject().getSootClassDecl()); for(Iterator iter = superinterfacesIterator(); iter.hasNext(); ) { TypeDecl typeDecl = (TypeDecl)iter.next(); if(typeDecl != typeObject() && !sc.implementsInterface(typeDecl.getSootClassDecl().getName())) sc.addInterface(typeDecl.getSootClassDecl()); } if(isNestedType()) sc.setOuterClass(enclosingType().getSootClassDecl()); sc.setResolvingLevel(SootClass.HIERARCHY); super.jimplify1phase2(); sc.setResolvingLevel(SootClass.SIGNATURES); } /**
private void addAsClassDefItem(SootClass c) { if (c.hasTag("SourceFileTag")) { SourceFileTag sft = (SourceFileTag) c.getTag("SourceFileTag"); sourceFile = sft.getSourceFile(); String classType = SootToDexUtils.getDexTypeDescriptor(c.getType()); int accessFlags = c.getModifiers(); String superClass = c.hasSuperclass() ? SootToDexUtils.getDexTypeDescriptor(c.getSuperclass().getType()) : null; if (!c.getInterfaces().isEmpty()) { interfaces = new ArrayList<String>(); for (SootClass ifc : c.getInterfaces()) { interfaces.add(SootToDexUtils.getDexTypeDescriptor(ifc.getType())); if (!c.getFields().isEmpty()) { fields = new ArrayList<Field>(); for (SootField f : c.getFields()) {
/** * Returns a list of <strong>direct</strong> superclasses of passed class in reverse order, starting with its parent. * * @param sootClass * the <strong>class</strong> of which superclasses will be taken. Must not be {@code null} or interface * @return list of superclasses * @throws IllegalArgumentException * when passed class is an interface * @throws NullPointerException * when passed argument is {@code null} */ public List<SootClass> getSuperclassesOf(SootClass sootClass) { sootClass.checkLevel(SootClass.HIERARCHY); if (sootClass.isInterface()) { throw new IllegalArgumentException(sootClass.getName() + " is an interface, but class is expected"); } checkState(); final List<SootClass> superclasses = new ArrayList<>(); SootClass current = sootClass; while (current.hasSuperclass()) { superclasses.add(current.getSuperclass()); current = current.getSuperclass(); } return Collections.unmodifiableList(superclasses); }
private Set<SootClass> getParentsOfIncluding(Collection<SootClass> classes) { final Set<SootClass> parents = new HashSet<>(classes); for (SootClass clazz : classes) { // add implementing interfaces parents.addAll(clazz.getInterfaces()); // add extending class if any if (!clazz.isInterface() && clazz.hasSuperclass()) { parents.add(clazz.getSuperclass()); } // and superclasses (superinterfaces) of passed applicationClass parents.addAll(clazz.isInterface() ? Scene.v().getActiveHierarchy().getSuperinterfacesOfIncluding(clazz) : Scene.v().getActiveHierarchy().getSuperclassesOfIncluding(clazz)); } return parents; }
SootClass sc = worklist[i].pop(); if (resolveEverything()) { // Whole program mode boolean onlySignatures = sc.isPhantom() || (Options.v().no_bodies_for_excluded() && Scene.v().isExcluded(sc) && !Scene.v().getBasicClasses().contains(sc.getName())); if (onlySignatures) { bringToSignatures(sc); sc.setPhantomClass(); for (SootMethod m : sc.getMethods()) { m.setPhantom(true); for (SootField f : sc.getFields()) { f.setPhantom(true);
if (s.isPhantom()) { continue; s.setApplicationClass(); if (Options.v().classes().contains(s.getName())) { s.setApplicationClass(); continue; if (s.isApplicationClass() && isExcluded(s)) { s.setLibraryClass(); s.setApplicationClass(); if (s.isApplicationClass()) { loadClassAndSupport(s.getName());
throw new RuntimeException("Oops, forgot to load " + type); if (sClass.isPhantomClass()) { throw new RuntimeException("Jimplification requires " + sClass + ", but it is a phantom ref."); SootClass superclass = sClass.getSuperclassUnsafe(); if (superclass != null && !sClass.getName().equals("java.lang.Object")) { TypeNode parent = hierarchy.typeNode(RefType.v(sClass.getSuperclass().getName())); plist.add(parent); parentClass = parent; for (Iterator<SootClass> i = sClass.getInterfaces().iterator(); i.hasNext();) { TypeNode parent = hierarchy.typeNode(RefType.v((i.next()).getName())); plist.add(parent);
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()); }
while (selectedClass != null) { if (trace != null) { trace.append("Looking in ").append(selectedClass).append(" which has methods ").append(selectedClass.getMethods()) .append("\n"); final SootMethod method = selectedClass.getMethodUnsafe(name, parameterTypes, returnType); if (method != null) { checkStatic(method); if (Scene.v().allowsPhantomRefs() && selectedClass.isPhantom()) { SootMethod phantomMethod = Scene.v().makeSootMethod(name, parameterTypes, returnType, isStatic() ? Modifier.STATIC : 0); phantomMethod.setPhantom(true); phantomMethod = selectedClass.getOrAddMethod(phantomMethod); checkStatic(phantomMethod); return phantomMethod; selectedClass = selectedClass.getSuperclassUnsafe(); final Queue<SootClass> queue = new ArrayDeque<>(selectedClass.getInterfaces()); while (!queue.isEmpty()) { final SootClass iface = queue.poll(); if (trace != null) { trace.append("Looking in ").append(iface).append(" which has methods ").append(iface.getMethods()).append("\n"); final SootMethod method = iface.getMethodUnsafe(name, parameterTypes, returnType); if (method != null) { checkStatic(method);
int classModifiers = sc.getModifiers(); int modifier = getModifiers(classModifiers, sc); String className = slashify(sc.getName()); if (sc.hasTag("SignatureTag")) { signature = ((SignatureTag) sc.getTag("SignatureTag")).getSignature(); SootClass csuperClass = sc.getSuperclassUnsafe(); if (csuperClass != null) { superClass = slashify(csuperClass.getName()); String[] interfaces = new String[sc.getInterfaceCount()]; Iterator<SootClass> implementedInterfaces = sc.getInterfaces().iterator(); int i = 0; while (implementedInterfaces.hasNext()) { SootClass interf = implementedInterfaces.next(); interfaces[i] = slashify(interf.getName()); ++i;
private Optional<SootMethod> findAccessibleInSuperClassesBySubSig(SootClass base, String subSig) { Hierarchy hierarchy = Scene.v().getActiveHierarchy(); for (SootClass superClass : hierarchy.getSuperclassesOfIncluding(base.getSuperclass())) { if (superClass.isLibraryClass() && superClass.declaresMethod(subSig)) { SootMethod method = superClass.getMethod(subSig); if (hierarchy.isVisible(base, method)) { return Optional.of(method); } } } return Optional.empty(); } }
private soot.SootClass getSpecialInterfaceAnonClass(soot.SootClass addToClass) { // check to see if there is already a special anon class for this // interface if ((InitialResolver.v().specialAnonMap() != null) && (InitialResolver.v().specialAnonMap().containsKey(addToClass))) { return InitialResolver.v().specialAnonMap().get(addToClass); } else { String specialClassName = addToClass.getName() + "$" + InitialResolver.v().getNextAnonNum(); // add class to scene and other maps and lists as needed soot.SootClass specialClass = new soot.SootClass(specialClassName); soot.Scene.v().addClass(specialClass); specialClass.setApplicationClass(); specialClass.addTag(new soot.tagkit.SyntheticTag()); specialClass.setSuperclass(soot.Scene.v().getSootClass("java.lang.Object")); Util.addInnerClassTag(addToClass, specialClass.getName(), addToClass.getName(), null, soot.Modifier.STATIC); Util.addInnerClassTag(specialClass, specialClass.getName(), addToClass.getName(), null, soot.Modifier.STATIC); InitialResolver.v().addNameToAST(specialClassName); references.add(RefType.v(specialClassName)); if (InitialResolver.v().specialAnonMap() == null) { InitialResolver.v().setSpecialAnonMap(new HashMap<SootClass, SootClass>()); } InitialResolver.v().specialAnonMap().put(addToClass, specialClass); return specialClass; } }