List of usage examples for org.objectweb.asm.tree ClassNode accept
public void accept(final ClassVisitor classVisitor)
From source file:com.retroduction.carma.transformer.asm.ror.ROR_Transition.java
License:Open Source License
@Override protected void checkNode(ClassNode classNode, MethodNode methodNode, List<Mutant> result, CRTEntry jcovInfo, AbstractInsnNode node) {/* w ww .j a va 2 s. co m*/ if (node instanceof JumpInsnNode) { JumpInsnNode jumpNode = (JumpInsnNode) node; if (jumpNode.getOpcode() == this.sourceInstruction) { jumpNode.setOpcode(this.targetInstruction); ClassWriter writer = new ClassWriter(0); classNode.accept(writer); SourceCodeMapping sourceMapping = new SourceCodeMapping(); sourceMapping.setLineStart(jcovInfo.getStartLine()); sourceMapping.setLineEnd(jcovInfo.getEndLine()); sourceMapping.setColumnStart(jcovInfo.getStartColumn()); sourceMapping.setColumnEnd(jcovInfo.getEndColumn()); Mutant mutant = new Mutant(); mutant.setByteCode(writer.toByteArray()); mutant.setSourceMapping(sourceMapping); mutant.setSurvived(true); mutant.setTransition(this); result.add(mutant); jumpNode.setOpcode(this.sourceInstruction); } } }
From source file:com.samczsun.helios.transformers.Transformer.java
License:Apache License
protected byte[] fixBytes(byte[] in) { ClassReader reader = new ClassReader(in); ClassNode node = new ClassNode(); reader.accept(node, ClassReader.EXPAND_FRAMES); ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS); node.accept(writer); return writer.toByteArray(); }
From source file:com.speed.ob.api.ClassStore.java
License:Open Source License
public void dump(File in, File out, Config config) throws IOException { if (in.isDirectory()) { for (ClassNode node : nodes()) { String[] parts = node.name.split("\\."); String dirName = node.name.substring(0, node.name.lastIndexOf(".")); dirName = dirName.replace(".", "/"); File dir = new File(out, dirName); if (!dir.exists()) { if (!dir.mkdirs()) throw new IOException("Could not make output dir: " + dir.getAbsolutePath()); }/*from w ww .j a v a 2 s . c o m*/ ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS); node.accept(writer); byte[] data = writer.toByteArray(); FileOutputStream fOut = new FileOutputStream( new File(dir, node.name.substring(node.name.lastIndexOf(".") + 1))); fOut.write(data); fOut.flush(); fOut.close(); } } else if (in.getName().endsWith(".jar")) { File output = new File(out, in.getName()); JarFile jf = new JarFile(in); HashMap<JarEntry, Object> existingData = new HashMap<>(); if (output.exists()) { try { JarInputStream jarIn = new JarInputStream(new FileInputStream(output)); JarEntry entry; while ((entry = jarIn.getNextJarEntry()) != null) { if (!entry.isDirectory()) { byte[] data = IOUtils.toByteArray(jarIn); existingData.put(entry, data); jarIn.closeEntry(); } } jarIn.close(); } catch (IOException e) { Logger.getLogger(this.getClass().getName()).log(Level.SEVERE, "Could not read existing output file, overwriting", e); } } FileOutputStream fout = new FileOutputStream(output); Manifest manifest = null; if (jf.getManifest() != null) { manifest = jf.getManifest(); if (!config.getBoolean("ClassNameTransform.keep_packages") && config.getBoolean("ClassNameTransform.exclude_mains")) { manifest = new Manifest(manifest); if (manifest.getMainAttributes().getValue("Main-Class") != null) { String manifestName = manifest.getMainAttributes().getValue("Main-Class"); if (manifestName.contains(".")) { manifestName = manifestName.substring(manifestName.lastIndexOf(".") + 1); manifest.getMainAttributes().putValue("Main-Class", manifestName); } } } } jf.close(); JarOutputStream jarOut = manifest == null ? new JarOutputStream(fout) : new JarOutputStream(fout, manifest); Logger.getLogger(getClass().getName()).fine("Restoring " + existingData.size() + " existing files"); if (!existingData.isEmpty()) { for (Map.Entry<JarEntry, Object> entry : existingData.entrySet()) { Logger.getLogger(getClass().getName()).fine("Restoring " + entry.getKey().getName()); jarOut.putNextEntry(entry.getKey()); jarOut.write((byte[]) entry.getValue()); jarOut.closeEntry(); } } for (ClassNode node : nodes()) { ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS); node.accept(writer); byte[] data = writer.toByteArray(); int index = node.name.lastIndexOf("/"); String fileName; if (index > 0) { fileName = node.name.substring(0, index + 1).replace(".", "/"); fileName += node.name.substring(index + 1).concat(".class"); } else { fileName = node.name.concat(".class"); } JarEntry entry = new JarEntry(fileName); jarOut.putNextEntry(entry); jarOut.write(data); jarOut.closeEntry(); } jarOut.close(); } else { if (nodes().size() == 1) { File outputFile = new File(out, in.getName()); ClassNode node = nodes().iterator().next(); ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS); byte[] data = writer.toByteArray(); FileOutputStream stream = new FileOutputStream(outputFile); stream.write(data); stream.close(); } } }
From source file:com.speed.ob.transforms.ClassNameTransform.java
License:Open Source License
public void run(ClassStore store, Config config) { //generate map of old names -> new names for (ClassNode node : store.nodes()) { LOGGER.fine("Processing class: " + node.name); boolean hasMain = false; if (excludeMains) { for (MethodNode mn : (List<MethodNode>) node.methods) { if (mn.name.equals("main") && mn.desc.equals("([Ljava/lang/String;)V")) { LOGGER.fine("Not renaming " + node.name + ", has a main method"); //continue outer; hasMain = true;/* ww w . jav a2s. co m*/ break; } } } if (excludedClasses != null && excludedClasses.contains(node.name)) { LOGGER.fine("Not renaming " + node.name + ", is excluded"); continue; } String newName; int ind = node.name.lastIndexOf('/'); if (excludeMains && hasMain) { if (ind > -1) { newName = node.name.substring(ind + 1); } else { newName = node.name; } } else { if (keepPackages && ind > -1) { newName = node.name.substring(0, ind) + '/' + nameGenerator.next(); } else { newName = nameGenerator.next(); } } LOGGER.finer("Renaming " + node.name + " to " + newName); namesMap.put(node.name, newName); } Iterator<ClassNode> iterator = store.nodes().iterator(); HashMap<String, ClassNode> newClasses = new HashMap<>(); while (iterator.hasNext()) { ClassNode cn = iterator.next(); ClassNode node = new ClassNode(); RemappingClassAdapter remapping = new RemappingClassAdapter(node, new ClassRemapper()); cn.accept(remapping); newClasses.put(node.name, node); } store.set(newClasses); }
From source file:com.thomas15v.packetlib.codegenerator.asm.ASMHelper.java
License:MIT License
/** * Runs textifier on the specified class node and dumps the output to the * specified output stream// w w w.j av a2 s. c o m * * @param classNode class to textify * @param out output stream */ public static void textify(ClassNode classNode, OutputStream out) { classNode.accept(new TraceClassVisitor(new PrintWriter(out))); }
From source file:com.thomas15v.packetlib.codegenerator.asm.ASMHelper.java
License:MIT License
/** * Dumps the output of CheckClassAdapter.verify to System.out * * @param classNode the classNode to verify *///ww w . j av a2s . c o m public static void dumpClass(ClassNode classNode) { ClassWriter cw = new ClassWriter(COMPUTE_MAXS | COMPUTE_FRAMES); classNode.accept(cw); ASMHelper.dumpClass(cw.toByteArray()); }
From source file:com.triage.bytecodemaster.BaseWeaverTest.java
protected Class createClassFromClassNode(ClassNode sourceNode, String className) throws Exception { //write a class ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES); sourceNode.accept(cw); byte[] classBytes = cw.toByteArray(); //make a classloader to load it. this wouldnt be necessary in a java agent-- we //just return the bytes. but this allows testing it //this classloader(System) cannot refer to the new class explicitly, so we have //to use reflection. but that proves the point. byteCodeClassLoader.addClassDef(className, classBytes); Class c = byteCodeClassLoader.findClass(className); return c;/*from w w w .j a v a 2 s .co m*/ }
From source file:com.triage.bytecodemaster.GroovyShardTransformer.java
protected byte[] transformClass(String tapScript, String className, ClassLoader cl, byte[] classFileBuffer) throws Exception { Timer timer = new Timer(); timer.start();//from w w w . j av a 2 s . c om //so that we can reference classes available in the caller when we compile the script //MAKES A KEY ASSUMPTION: that all classloaders we will have a path back to the system //classloader, and thus will have our groovy stuff in them! //if this isnt the case, we may want to have a dual-parent classloader where //we can search both the target classloader and the system CachingGroovyClassLoader groovyClassLoader = new CachingGroovyClassLoader(cl); //load the script in ASM ClassNode shimClassNode = new ClassNode(); String scriptName = className + "-Tap.groovy"; timer.mark("startParse"); Class groovyClass = groovyClassLoader.parseClass(tapScript, scriptName); timer.mark("endParse"); String generatedClassName = groovyClass.getName() + ".class"; byte[] classBytes = groovyClassLoader.getClassBytes(generatedClassName); timer.mark("getClassBytes"); ClassReader shimClassReader = new ClassReader(classBytes); shimClassReader.accept(shimClassNode, 0); timer.mark("readShimClass"); ClassNode targetClassNode = new ClassNode(); ClassReader targetClassReader = new ClassReader(classFileBuffer); targetClassReader.accept(targetClassNode, 0); timer.mark("readTargetClass"); //copy instructions //TODO: this is just a POC-- of course all this hardcoded stuff needs //to be replaced with real code MethodNode targetMethod = null; MethodNode sourceMethod = null; InsnList instructionsToInject = null; if (className.contains("TestFriend")) { targetMethod = findMethod(targetClassNode, "whatDoIThinkAbout"); sourceMethod = findMethod(shimClassNode, "beforeWhatDoIThinkAbout"); instructionsToInject = sourceMethod.instructions; } else if (className.contains("Calculator")) { targetMethod = findMethod(targetClassNode, "add"); sourceMethod = findMethod(shimClassNode, "beforeAdd"); //HACK: in the calculator script, we do not want a premature //return, so lets remove RETURNs from the source. //that DOESNT work in gneeral because sometimes we do want a return //but this will just see if removing the returns works instructionsToInject = sourceMethod.instructions; ListIterator li = instructionsToInject.iterator(); while (li.hasNext()) { AbstractInsnNode node = (AbstractInsnNode) li.next(); if (isReturnOpCode(node.getOpcode())) { li.remove(); } } } timer.mark("gotInstructionsToInject"); System.out.println("Transforming Target Method:"); printMethodNode(targetMethod); System.out.println("Transforming Source Method:"); printMethodNode(sourceMethod); //insert source instructions in target targetMethod.instructions.insert(sourceMethod.instructions); timer.mark("injectedInstructions"); //write a class ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES); targetClassNode.accept(cw); timer.mark("finishedWrite"); System.out.println("Successfully transformed class" + className); timer.stop(); System.out.println("Timings:" + timer); return cw.toByteArray(); }
From source file:com.triage.radium.agent.TestGroovyWeaver.java
public void testInjectingGroovyClassBodyIntoOtherClass() throws Exception { //get the dynamic source that has the donor body in it ClassNode donorSource = loadGroovyTestClassAsBytecode(GROOVY_CLASS); MethodNode donorMethod = findMethod(donorSource, "concat"); //load the target class String TARGETCLASSNAME = "com.triage.bytecodemaster.TestClass"; ClassNode targetSource = loadLocalClass(TARGETCLASSNAME); MethodNode targetMethod = findMethod(targetSource, "executeLogic"); System.out.println("Target Local Vars:"); printLocalVariables(targetMethod);//from www . ja v a 2 s. c om //stash the donorInto the target System.out.println("Parsed Donor Class."); printLocalVariables(donorMethod); System.out.println("Inserting These instructions in targetMethod:"); for (AbstractInsnNode aa : donorMethod.instructions.toArray()) { System.out.println(printNode(aa)); } targetMethod.instructions.insert(donorMethod.instructions); //write a class ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES); targetSource.accept(cw); byte[] classBytes = cw.toByteArray(); //make a classloader to load it. this wouldnt be necessary in a java agent-- we //just return the bytes. but this allows testing it //this classloader(System) cannot refer to the new class explicitly, so we have //to use reflection. but that proves the point. byteCodeClassLoader.addClassDef(TARGETCLASSNAME, classBytes); Class c = byteCodeClassLoader.findClass(TARGETCLASSNAME); Object o = c.newInstance(); Method m = o.getClass().getDeclaredMethod("executeLogic", String.class, Date.class); TestPerson tc = new TestPerson("Dave"); assertTrue(tc.executeLogic("FoorBar", new Date()).contains("FoorBar")); //should return FromGroovy<Date>, not String result = (String) m.invoke(o, "shouldntmatter", new Date()); assertTrue(result.contains("FromGroovy")); }
From source file:com.typesafe.path_hole.PathHole.java
License:Open Source License
private static byte[] prependToClassLoader() { Object[] ourEnhancementsToLoadClass = getMethodNode(PathHole.class, "bytecodeToPrepend", "(Ljava/lang/String;Z)V"); Object[] jlClassLoader = getMethodNode(ClassLoader.class, "loadClass", "(Ljava/lang/String;Z)Ljava/lang/Class;"); // get the bytecode to prepend InsnList prependInst = ((MethodNode) ourEnhancementsToLoadClass[1]).instructions; // lets get rid of the return statement // remove the optional label if (prependInst.getLast().getOpcode() < 0) { prependInst.remove(prependInst.getLast()); }// ww w .ja v a 2 s. c om // remove the return inst. It doesn't take any args so this is all we need prependInst.remove(prependInst.getLast()); // now add this to loadClass method of jlClassLoader InsnList baseInst = ((MethodNode) jlClassLoader[1]).instructions; baseInst.insertBefore(baseInst.getFirst(), prependInst); ClassNode clClassNode = (ClassNode) jlClassLoader[0]; // we just need to add any fields referenced by the prepended bytecode to the jlClassLoader // ClassNode prependClassNode = (ClassNode) ourEnhancementsToLoadClass[0]; // write the new bytecode ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES); clClassNode.accept(cw); return cw.toByteArray(); }