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()); }
/** * Get whole tree of interfaces on {@code Scene} for class/interface. * * @param sc * class or interface to get all its interfaces * @return all interfaces on {@code Scene} for class or interface */ public static List<SootClass> getAllInterfacesOf(SootClass sc) { Hierarchy hierarchy = Scene.v().getActiveHierarchy(); Stream<SootClass> superClassInterfaces = sc.isInterface() ? Stream.empty() : hierarchy.getSuperclassesOf(sc).stream().map(HierarchyUtils::getAllInterfacesOf).flatMap(Collection::stream); Stream<SootClass> directInterfaces = Stream.concat(sc.getInterfaces().stream(), sc.getInterfaces().stream().map(HierarchyUtils::getAllInterfacesOf).flatMap(Collection::stream)); return Stream.concat(superClassInterfaces, directInterfaces).collect(toList()); }
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; }
private static List<SootClass> getVisibleApplicationClasses(SootMethod visibleBy) { final List<SootClass> result = new ArrayList<>(); final Iterator<SootClass> applicationClassesIterator = Scene.v().getApplicationClasses().snapshotIterator(); while (applicationClassesIterator.hasNext()) { final SootClass applicationClass = applicationClassesIterator.next(); if (applicationClass.isConcrete() && !applicationClass.isInterface() && applicationClass.isPublic() && Scene.v().getActiveHierarchy().isVisible(applicationClass, visibleBy)) { result.add(applicationClass); } } return result; }
private List<SootClass> getParentsOfIncluding(SootClass applicationClass) { // result contains of interfaces that implements passed applicationClass final List<SootClass> result = HierarchyUtils.getAllInterfacesOf(applicationClass); // add implementing interfaces result.addAll(applicationClass.getInterfaces()); // add extending class if any if (!applicationClass.isInterface() && applicationClass.hasSuperclass()) { result.add(applicationClass.getSuperclass()); } // and superclasses (superinterfaces) of passed applicationClass result.addAll( applicationClass.isInterface() ? Scene.v().getActiveHierarchy().getSuperinterfacesOfIncluding(applicationClass) : Scene.v().getActiveHierarchy().getSuperclassesOfIncluding(applicationClass)); return result; }
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(); } }
static boolean specialInvokePerformsLookupIn(InvokeExpr ie, SootClass containerClass) { // If all of the conditions are true, a lookup is performed. SootMethod m = ie.getMethod(); if (m.getName().equals("<init>")) { return false; } if (m.isPrivate()) { return false; } Hierarchy h = Scene.v().getActiveHierarchy(); if (!h.isClassSuperclassOf(m.getDeclaringClass(), containerClass)) { return false; } // ACC_SUPER must always be set, eh? return true; } }
private boolean isSuitableClassToAddFieldConstant(SootClass sc, Constant constant) { if (sc.isInterface()) { return false; } if (constant instanceof ClassConstant) { ClassConstant classConstant = (ClassConstant) constant; RefType type = (RefType) classConstant.toSootType(); SootClass classFromConstant = type.getSootClass(); Hierarchy hierarchy = Scene.v().getActiveHierarchy(); return hierarchy.isVisible(sc, classFromConstant); } return true; }
/** * If exception e is caught at unit u in body b, return true; otherwise, return false. */ public static boolean isExceptionCaughtAt(SootClass e, Unit u, Body b) { /* * Look through the traps t of b, checking to see if: - caught exception is e; - and, unit lies between t.beginUnit and * t.endUnit */ Hierarchy h = Scene.v().getActiveHierarchy(); Chain<Unit> units = b.getUnits(); for (Trap t : b.getTraps()) { /* Ah ha, we might win. */ if (h.isClassSubclassOfIncluding(e, t.getException())) { Iterator<Unit> it = units.iterator(t.getBeginUnit(), units.getPredOf(t.getEndUnit())); while (it.hasNext()) { if (u.equals(it.next())) { return true; } } } } return false; }
joinStatements = new HashSet<Stmt>(); hierarchy = Scene.v().getActiveHierarchy();
Hierarchy typeHierarchy = Scene.v().getActiveHierarchy();
Hierarchy typeHierarchy = Scene.v().getActiveHierarchy();
Hierarchy typeHierarchy = Scene.v().getActiveHierarchy();
public boolean isExceptionPointer(Node v) { if (v.getType() instanceof RefType) { SootClass sc = ((RefType) v.getType()).getSootClass(); if (!sc.isInterface() && Scene.v().getActiveHierarchy().isClassSubclassOfIncluding(sc, Constants.exeception_type.getSootClass())) { return true; } } return false; }
if (rightClass.isInterface()) { if (!(leftClass.getName().equals(rightClass.getName()) || Scene.v().getActiveHierarchy().isInterfaceSubinterfaceOf(rightClass, leftClass))) { exception.add(new ValidationException(stmt, "Warning: Bad use of interface type" + errorSuffix + " in " + body.getMethod())); + errorSuffix + " in " + body.getMethod())); } else { if (!Scene.v().getActiveHierarchy().isClassSubclassOfIncluding(rightClass, leftClass)) { exception.add( new ValidationException(stmt, "Warning: Bad use of class type" + errorSuffix + " in " + body.getMethod()));
SootClass baseTypeClass = ((RefType) pType).getSootClass(); if (!baseTypeClass.isInterface()) { List<SootClass> baseClasses = Scene.v().getActiveHierarchy().getSuperclassesOfIncluding(baseTypeClass); if (!baseClasses.contains(RefType.v("java.lang.Exception").getSootClass())) { for (SootClass baseClass : baseClasses) {
Hierarchy h = Scene.v().getActiveHierarchy();
Hierarchy h = Scene.v().getActiveHierarchy(); boolean saved = false;
SootClass baseTypeClass = ((RefType) pType).getSootClass(); if (!baseTypeClass.isInterface()) { List<SootClass> baseClasses = Scene.v().getActiveHierarchy().getSuperclassesOfIncluding(baseTypeClass); if (!baseClasses.contains(RefType.v("java.lang.Exception").getSootClass())) { for (SootClass baseClass : baseClasses) {
if (baseLocal.getType() instanceof RefType) { SootClass baseClass = ((RefType) baseLocal.getType()).getSootClass(); if (Scene.v().getActiveHierarchy().isClassSubclassOfIncluding(baseClass, RefType.v("java.lang.Exception").getSootClass())) { return null;