private void reset0() { cn = new ClassNode(ASM4); fn = null; mn = null; }
private ClassNode readClassNode(byte[] data) { ClassReader cr = new ClassReader(data); ClassNode cn = new ClassNode(); cr.accept(cn, ClassReader.EXPAND_FRAMES | ClassReader.SKIP_FRAMES); return cn; }
private ClassNode createClassNode(String internalClassName) throws ClassNotFoundException { byte[] byteCode = getClassBytes(internalClassName); ClassReader classReader = new ClassReader(byteCode); ClassNode classNode = new ClassNode(); classReader.accept(classNode, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES); return classNode; }
private ClassNode loadClassNode(String name) { String classFileName = name.replace('.', '/') + ".class"; ZipEntry entry = jarFile.getEntry(classFileName); if (entry == null) { return null; } try (InputStream inputStream = jarFile.getInputStream(entry)) { ClassReader classReader = new ClassReader(inputStream); ClassNode classNode = new ClassNode(); classReader.accept(classNode, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES); return classNode; } catch (IOException e) { throw new RuntimeException("failed to analyze " + classFileName + " in " + path, e); } }
private void disassemble1(Path file, Path output) throws IOException { ClassReader r = new ClassReader(Files.readAllBytes(file)); Path jFile = output.resolve(r.getClassName().replace('.', '/') + ".j"); createParentDirectories(jFile); try (BufferedWriter out = Files.newBufferedWriter(jFile, Charset.forName(encoding))) { PrintWriter pw = new PrintWriter(out); ClassNode node = new ClassNode(); r.accept(node, (debugInfo ? 0 : ClassReader.SKIP_DEBUG) | ClassReader.EXPAND_FRAMES | ClassReader.SKIP_FRAMES); new JasminDumper(pw).dump(node); pw.flush(); } } }
protected ClassNode getClassNode(byte[] classdata) { ClassNode cn = new ClassNode(); ClassReader cr = new ClassReader(classdata); cr.accept(cn, 0); return cn; }
@Override public void visitFile(Path file, String relative) throws IOException { if (file.getFileName().toString().endsWith(".class")) { ClassReader cr = new ClassReader(Files.readAllBytes(file)); ClassNode cn = new ClassNode(); cr.accept(new CheckClassAdapter(cn, false), ClassReader.SKIP_DEBUG | ClassReader.EXPAND_FRAMES | ClassReader.SKIP_FRAMES); for (MethodNode method : cn.methods) { BasicVerifier verifier = new BasicVerifier(); Analyzer<BasicValue> a = new Analyzer<>(verifier); try { a.analyze(cn.name, method); } catch (Exception ex) { System.err.println("Error verify method " + cr.getClassName() + "." + method.name + " " + method.desc); if (detail) { ex.printStackTrace(System.err); printAnalyzerResult(method, a, new PrintWriter(new OutputStreamWriter(System.err, StandardCharsets.UTF_8))); } } } } } });
public byte[] transformCode(byte[] b1, String className) throws IOException { ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); ClassReader cr = new ClassReader(b1); ClassNode classNode = new ClassNode(); Map<String, Boolean> methodInstructionTypeMap = new HashMap<>(); cr.accept(classNode, 0); final List<MethodNode> methods = classNode.methods; for (MethodNode m : methods) { InsnList inList = m.instructions; boolean isMethodInvoke = false; for (int i = 0; i < inList.size(); i++) { if (inList.get(i).getType() == AbstractInsnNode.METHOD_INSN) { isMethodInvoke = true; } } methodInstructionTypeMap.put(m.name + m.desc, isMethodInvoke); } InsertMethodBodyAdapter insertMethodBodyAdapter = new InsertMethodBodyAdapter(cw, className, methodInstructionTypeMap); cr.accept(insertMethodBodyAdapter, ClassReader.EXPAND_FRAMES); return cw.toByteArray(); }
@Override public ClassHolder map(String name) { ClassNode clsNode = new ClassNode(); String resourceName = name.replace('.', '/') + ".class"; if (!resourceReader.hasResource(resourceName)) { return null; } try (InputStream input = resourceReader.openResource(resourceName)) { ClassReader reader = new ClassReader(input); reader.accept(clsNode, 0); } catch (IOException e) { throw new RuntimeException(e); } return parser.parseClass(clsNode); } }
@SuppressWarnings("unchecked") private MethodNode getMethod(byte[] classbytes, String methodName) { ClassReader super_cr = new ClassReader(classbytes); ClassNode cn = new ClassNode(); super_cr.accept(cn, 0); List<MethodNode> methods = cn.methods; if (methods != null) { for (MethodNode mn : methods) { if (mn.name.equals(methodName)) { return mn; } } } return null; }
@SuppressWarnings("unchecked") private FieldNode getField(byte[] classbytes, String fieldName) { ClassReader super_cr = new ClassReader(classbytes); ClassNode cn = new ClassNode(); super_cr.accept(cn, 0); List<FieldNode> fields = cn.fields; if (fields != null) { for (FieldNode fn : fields) { if (fn.name.equals(fieldName)) { return fn; } } } return null; }
public static int getPausableStatus(String className, String methodName, String desc, Detector detector) { try { ClassCache classCache = classCacheMap.get(className); if (classCache == null) { ClassReader cr = new ClassReader(className); ClassNode cn = new ClassNode(); cr.accept(cn, /*flags*/ 0); classCache = cache(className, cn); } int status = classCache.getPausableStatus(methodName, desc); if (status == Detector.METHOD_NOT_FOUND_OR_PAUSABLE) { // check super classes for (String superName: classCache.superClasses) { status = detector.getPausableStatus(superName, methodName, desc); if (status != Detector.METHOD_NOT_FOUND_OR_PAUSABLE) break; } } return status; } catch (IOException ioe) { System.err.println("***Error reading " + className + ": " + ioe.getMessage()); return Detector.METHOD_NOT_FOUND_OR_PAUSABLE; } } private static ClassCache cache(String className, ClassNode cn) {
protected Class createClass(byte[] code, ClassNode classNode) { ClassReader cr = new ClassReader(code); GenericsTester classVisitor = new GenericsTester(new org.objectweb.asm.tree.ClassNode()); cr.accept(classVisitor, ClassWriter.COMPUTE_MAXS); return super.createClass(code,classNode); } }
public String submitClassFile(byte[] data) { ClassNode node = new ClassNode(); org.objectweb.asm.ClassReader reader = new org.objectweb.asm.ClassReader(data); reader.accept(node, 0); submitClass(new Parser(new ReferenceCache()).parseClass(node)); return node.name; }
public static String toStd(ClassNode expected) throws IOException { expected.access &= ~Opcodes.ACC_SUPER; ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); expected.accept(LdcOptimizeAdapter.wrap(cw)); ClassReader cr = new ClassReader(cw.toByteArray()); ClassNode n = new ClassNode(Opcodes.ASM4); cr.accept(n, ClassReader.EXPAND_FRAMES | ClassReader.SKIP_FRAMES); StringWriter stringWriter = new StringWriter(); new JasminDumper(new PrintWriter(stringWriter, true)).dump(n); return stringWriter.toString(); }
@Override public ClassNode analyze(IAnalysisCache analysisCache, ClassDescriptor descriptor) throws CheckedAnalysisException { ClassReader classReader = analysisCache.getClassAnalysis(ClassReader.class, descriptor); ICodeBaseEntry entry = analysisCache.getClassPath().lookupResource(descriptor.toResourceName()); // One of the less-than-ideal features of ASM is that // invalid classfile format is indicated by a // random runtime exception rather than something // indicative of the real problem. try { ClassNode cn = new ClassNode(); classReader.accept(cn, 0); return cn; } catch (RuntimeException e) { throw new InvalidClassFileFormatException(descriptor, entry, e); } }
private void test0(InvocationWeaver iw, String prefix) throws IOException, RecognitionException { ClassNode before = Jasmins .parse(prefix + "-before.j", getClass().getResourceAsStream("/weave/" + prefix + "-before.j")); ClassNode expectedAfter = Jasmins .parse(prefix + "-after.j", getClass().getResourceAsStream("/weave/" + prefix + "-after.j")); ClassNode expectedGen = Jasmins .parse(prefix + "-gen.j", getClass().getResourceAsStream("/weave/" + prefix + "-gen.j")); ClassNode after = new ClassNode(); before.accept(iw.wrapper(after)); assertEqual(expectedAfter, after); ClassNode gen = new ClassNode(); iw.buildInvocationClz(LdcOptimizeAdapter.wrap(gen)); assertEqual(expectedGen, gen); }
@SuppressWarnings("unchecked") protected void checkLocalVariables(byte[] bytes, String methodNameAndDescriptor, String... expected) { ClassNode cn = new ClassNode(); ClassReader cr = new ClassReader(bytes); cr.accept(cn, 0); boolean checked = false; List<MethodNode> methods = cn.methods; for (MethodNode mn : methods) { if (methodNameAndDescriptor.equals(mn.name + mn.desc)) { List<LocalVariableNode> localVariables = mn.localVariables; Assert.assertEquals(expected.length, localVariables.size()); for (int i = 0; i < expected.length; i++) { StringTokenizer tokenizer = new StringTokenizer(expected[i], ":"); String expectedName = tokenizer.nextToken(); String expectedDesc = tokenizer.nextToken(); LocalVariableNode localVariable = localVariables.get(i); Assert.assertEquals(i, localVariable.index); Assert.assertEquals(expectedName, localVariable.name); Assert.assertEquals(expectedDesc, localVariable.desc); } checked = true; } } if (!checked) { for (MethodNode mn : methods) { System.out.println(mn.name + mn.desc); } Assert.fail("Unable to find method " + methodNameAndDescriptor); } }
@SuppressWarnings("unchecked") protected void checkAnnotations(byte[] bytes, String methodNameAndDescriptor, String... expected) { ClassNode cn = new ClassNode(); ClassReader cr = new ClassReader(bytes); cr.accept(cn, 0);
@SuppressWarnings("rawtypes") public static void verify(final ClassReader cr, PrintWriter out) throws AnalyzerException, IllegalArgumentException, IllegalAccessException { ClassNode cn = new ClassNode(); cr.accept(new CheckClassAdapter(cn, false), ClassReader.SKIP_DEBUG); List methods = cn.methods; for (int i = 0; i < methods.size(); ++i) { MethodNode method = (MethodNode) methods.get(i); List tryCatchBlocks = method.tryCatchBlocks; for (int j = 0; j < tryCatchBlocks.size(); j++) { TryCatchBlockNode tcn = (TryCatchBlockNode) tryCatchBlocks.get(j); if (tcn.start.equals(tcn.end)) { throw new DexException("try/catch block %d in %s has same start(%s) and end(%s)", j, method.name, tcn.start.getLabel(), tcn.end.getLabel()); } } BasicVerifier verifier = new BasicVerifier(); Analyzer a = new Analyzer(verifier); try { a.analyze(cn.name, method); } catch (Exception e) { out.println(cr.getClassName() + "." + method.name + method.desc); printAnalyzerResult(method, a, out); e.printStackTrace(out); out.flush(); throw new DexException("method " + method.name + " " + method.desc, e); } } }