Refine search
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(); }
private byte[] toByteArray(ClassNode cn) { ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); cn.accept(cw); return cw.toByteArray(); }
@Override public FieldVisitor visitField( int access, String name, String desc, String signature, Object value) { desc = config.remapParamType(desc); return super.visitField(access & ~Opcodes.ACC_FINAL, name, desc, signature, value); }
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); }
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 byte[] handleTileEntityClass(byte[] bytes) { final ClassReader reader = new ClassReader(bytes); final ClassNode node = new ClassNode(); reader.accept(node, 0); node.interfaces.add("logisticspipes/asm/te/ILPTEInformation"); node.visitField(Opcodes.ACC_PRIVATE, "informationObjectLogisticsPipes", "Llogisticspipes/asm/te/LPTileEntityObject;", null, null); for (MethodNode m : node.methods) { if (m.name.equals("validate") || m.name.equals("func_145829_t") || (m.name.equals("t") && m.desc.equals("()V"))) { mv = node.visitMethod(Opcodes.ACC_PUBLIC, "getObject", "()Llogisticspipes/asm/te/LPTileEntityObject;", null, null); mv.visitCode(); Label l0 = new Label(); mv = node.visitMethod(Opcodes.ACC_PUBLIC, "setObject", "(Llogisticspipes/asm/te/LPTileEntityObject;)V", null, null); mv.visitCode(); Label l0 = new Label(); mv.visitEnd(); ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS); node.accept(writer); return writer.toByteArray();
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(); } } }
@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); } }
@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); } } }
@Override public void transform() { ArrayList<String> classNames = new ArrayList<>(getClassPath().keySet()); for (int i = 0; i < classNames.size() % 20; i++) { DESCRIPTORS.add("L" + classNames.get(RandomUtils.getRandomIntNoOrigin(classNames.size())) + ";"); } for (int i = 0; i < this.radon.sessionInfo.getTrashClasses(); i++) { ClassNode classNode = generateClass(); ClassWriter cw = new ClassWriter(0); cw.newUTF8("RADON" + Main.VERSION); classNode.accept(cw); this.getResources().put(classNode.name + ".class", cw.toByteArray()); } LoggerUtils.stdOut(String.format("Generated %d trash classes.", this.radon.sessionInfo.getTrashClasses())); }
byte[] instrumentToBytes(MutableClass mutableClass) { instrument(mutableClass); ClassNode classNode = mutableClass.classNode; ClassWriter writer = new InstrumentingClassWriter(mutableClass.classNodeProvider, classNode); Remapper remapper = new Remapper() { @Override public String map(final String internalName) { return mutableClass.config.mappedTypeName(internalName); } }; ClassRemapper visitor = new ClassRemapper(writer, remapper); classNode.accept(visitor); return writer.toByteArray(); }
private ClassNode createClass(String className) { ClassNode classNode = new ClassNode(); classNode.visit(49, ACC_SUPER + ACC_PUBLIC, className, null, "java/lang/Object", null); MethodVisitor mv = classNode.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null); mv.visitCode(); mv.visitVarInsn(ALOAD, 0); mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false); mv.visitInsn(RETURN); mv.visitMaxs(1, 1); mv.visitEnd(); classNode.visitEnd(); return classNode; }
private void reset0() { cn = new ClassNode(ASM4); fn = null; mn = null; }
public void accept(ClassVisitor cv) throws RecognitionException{ sFile(); cn.accept(cv); } public ClassNode parse() throws RecognitionException {
@Override public MethodVisitor visitMethod( int access, String name, String desc, String signature, String[] exceptions) { MethodVisitor methodVisitor = super.visitMethod(access, name, config.remapParams(desc), signature, exceptions); return new JSRInlinerAdapter(methodVisitor, access, name, desc, signature, exceptions); } };
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; }
public static byte[] handleTravelingItemClass(byte[] bytes) { final ClassReader reader = new ClassReader(bytes); final ClassNode node = new ClassNode(); reader.accept(node, 0); FieldVisitor fv = node.visitField(Opcodes.ACC_PUBLIC, "lpRoutingInformation", "Ljava/lang/Object;", null, null); fv.visitEnd(); mv = node.visitMethod(Opcodes.ACC_PUBLIC, "getLPRoutingInfoAddition", "()Ljava/lang/Object;", null, null); mv.visitCode(); Label l0 = new Label(); mv = node.visitMethod(Opcodes.ACC_PUBLIC, "setLPRoutingInfoAddition", "(Ljava/lang/Object;)V", null, null); mv.visitCode(); Label l0 = new Label(); ClassWriter writer = new ClassWriter(0/*ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES*/); node.accept(writer); return writer.toByteArray();
@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 boolean isAlreadyInstrumented(ClassReader reader) { ClassNode classNode = new ClassNode(); int readFlags = ClassReader.SKIP_FRAMES | ClassReader.SKIP_CODE; reader.accept(classNode, readFlags); for(String interfaceName : ((List<String>)classNode.interfaces)) { if(InstrumentedClass.class.getName().equals(interfaceName.replace('/', '.'))) return true; } return false; }
/** * Given a map of ClassNodes and mappings, returns a map of class names to * class bytes. */ public static Map<String, byte[]> process(Map<String, ClassNode> nodes, Map<String, MappedClass> mappings) { Map<String, byte[]> out = new HashMap<String, byte[]>(); RemapperImpl mapper = new RemapperImpl(mappings); for (ClassNode cn : nodes.values()) { ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); ClassVisitor remapper = new ClassRemapper(cw, mapper); cn.accept(remapper); out.put(mappings.get(cn.name).getNewName(), cw.toByteArray()); } return out; }