java_dissassembler 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 86d641d10b9d79aef55fda226790ce55102bd03d
+  data.tar.gz: b9c1df1dccff8a01540592bb0a556b65d855a61f
+SHA512:
+  metadata.gz: f8dd23e5f96f46ca8547f13bef5971d467c8a9e4e2dba9c96111577dbf793cdea470d5a208c393a036ab3ea492d5b147332fea0a48152685cf57b76dcf79b2cf
+  data.tar.gz: e851eb92bdc1ca3ffab7fce5f95554a1f65b6d45b043b2f2c78cc3085c12b6ba3a6a89ba44dbd79b664ea45af4e84c95f7af8bca5172a58626d92d70e7ca5b56

data/lib/java_dissassembler/annotatable.rb

@@ -0,0 +1,17 @@
+module Java
+  class Annotatable
+    attr_reader :annotations
+    def initialize(annotations)
+      @annotations = annotations
+    end
+
+    def has_annotation?(annotation_name)
+      @annotations.any? { |hash| hash.keys.any? { |key| key == annotation_name } }
+    end
+
+    def get_annotation(annotation_name)
+      hash = @annotations.find { |a| a.keys.include?(annotation_name) }
+      hash[annotation_name] unless hash.nil?
+    end
+  end
+end

data/lib/java_dissassembler/array.rb

@@ -0,0 +1,37 @@
+class Array
+  def u2
+    self.pack("C*").unpack("s>").first
+  end
+
+  def u4
+    self.pack("C*").unpack("N").first
+  end
+
+  def modified_utf8_to_s
+    new_str = ""
+    bytes = self
+    until bytes.empty?
+      # Code points in the range '\u0001' to '\u007F' are represented by a single byte
+      if (bytes[0] >> 7) == 0
+        new_str << bytes[0]
+        bytes.shift
+      # The null code point ('\u0000') and code points in the range '\u0080' to '\u07FF' are represented by a pair of bytes x and y
+      elsif (bytes[0] >> 5) == 0b110
+        new_str << [((bytes[0] & 0x1f) << 6) + (bytes[1] & 0x3f)].pack("U")
+        bytes.shift(2)
+      # Code points in the range '\u0800' to '\uFFFF' are represented by 3 bytes
+      elsif ((bytes[0] >> 4) == 0b1110) && (bytes[0] != 0b11101101)
+        new_str << [((bytes[0] & 0xf) << 12) + ((bytes[1] & 0x3f) << 6) + (bytes[2] & 0x3f)].pack("U")
+        bytes.shift(3)
+      # Characters with code points above U+FFFF (so-called supplementary characters) are represented by separately encoding the
+      # two surrogate code units of their UTF-16 representation
+      elsif (bytes[0] == 0b11101101) && (bytes[3] == 0b11101101)
+        new_str << [0x10000 + ((bytes[1] & 0x0f) << 16) + ((bytes[2] & 0x3f) << 10) + ((bytes[4] & 0x0f) << 6) + (bytes[5] & 0x3f)].pack("U")
+        bytes.shift(6)
+      else
+        raise "Invalid \"Modified\" UTF-8 byte `#{bytes[0]}'"
+      end
+    end
+    new_str
+  end
+end

data/lib/java_dissassembler/class.rb

@@ -0,0 +1,71 @@
+module Java
+  class Class < Annotatable
+    attr_reader :flags, :this_klass, :super_klass, :interfaces, :fields, :methods
+
+    ACC_PUBLIC      = 0x0001  # Declared public; may be accessed from outside its package.
+    ACC_FINAL       = 0x0010  # Declared final; no subclasses allowed.
+    ACC_SUPER       = 0x0020  # Treat superclass methods specially when invoked by the invokespecial instruction.
+    ACC_INTERFACE   = 0x0200  # Is an interface, not a class.
+    ACC_ABSTRACT    = 0x0400  # Declared abstract; must not be instantiated.
+    ACC_SYNTHETIC   = 0x1000  # Declared synthetic; not present in the source code.
+    ACC_ANNOTATION  = 0x2000  # Declared as an annotation type.
+    ACC_ENUM        = 0x4000  # Declared as an enum type.
+
+    def initialize(major, minor, flags, this_klass, super_klass, interfaces, fields, methods, annotations)
+      super(annotations)
+      @major = major
+      @minor = minor
+      @flags = flags
+      @this_klass = this_klass
+      @super_klass = super_klass
+      @interfaces = interfaces
+      @fields = fields
+      @methods = methods
+    end
+
+    def is_public?
+      (@flags & ACC_PUBLIC) != 0
+    end
+
+    def is_final?
+      (@flags & ACC_FINAL) != 0
+    end
+
+    def is_super?
+      (@flags & ACC_SUPER) != 0
+    end
+
+    def is_interface?
+      (@flags & ACC_INTERFACE) != 0
+    end
+
+    def is_abstract?
+      (@flags & ACC_ABSTRACT) != 0
+    end
+
+    def is_synthetic?
+      (@flags & ACC_SYNTHETIC) != 0
+    end
+
+    def is_annotation?
+      (@flags & ACC_ANNOTATION) != 0
+    end
+
+    def is_enum?
+      (@flags & ACC_ENUM) != 0
+    end
+
+    def java_version
+      case @major
+      when 46 then "1.2"
+      when 47 then "1.3"
+      when 48 then "1.4"
+      when 49 then "5"
+      when 50 then "6"
+      when 51 then "7"
+      when 52 then "8"
+      when 53 then "9"
+      end
+    end
+  end
+end

data/lib/java_dissassembler/erb_helper.rb

@@ -0,0 +1,193 @@
+module Java
+  class Method
+
+    # JNI Call Java from C/C++
+    # =========================================
+    def jni_c_parameters(prefix = "param")
+      cparams = Array.new
+      java_params.each_with_index do |param, i|
+        cparams << "#{java_to_c(param)} #{prefix}#{i}"
+      end
+      cparams
+    end
+
+    def jni_c_return_type
+      java_to_c(java_return_type)
+    end
+
+    def jni_return_type
+      return "" if java_return_type == "void"
+      java_to_jni(java_return_type)
+    end
+
+    def jni_convert_c_to_jni(prefix = "param")
+      conversions = Array.new
+      java_params.each_with_index do |param, i|
+        case param
+        when "java.lang.String"
+          conversions << "jstring jni#{prefix}#{i} = env->NewStringUTF(#{prefix}#{i})"
+        end
+      end
+      conversions
+    end
+
+    def jni_method_call
+      "Call#{is_static? ? "Static" : ""}#{java_return_type.capitalize}Method"
+    end
+
+    def jni_method_call_parameters(prefix = "param")
+      java_params.enum_for(:each_with_index).map do |param, i|
+        case param
+        when "java.lang.String" then "jni#{prefix}#{i}"
+        else "#{prefix}#{i}"
+        end
+      end
+    end
+
+    # JNI Call C from Java
+    # =========================================
+    def jni_mangled_name(klass_name, is_override)
+      mangled_name = mangle(name)
+      mangled_name << "__#{mangle(vm_signature_params)}" if is_override and not vm_signature_params.empty?
+      "Java_#{klass_name.gsub(".", "_")}_#{mangled_name}"
+    end
+
+    def jni_native_method_parameters(prefix = "param")
+      native_method_parameters = ["JNIEnv* env"]
+      native_method_parameters << (is_static? ? "jobject caller" : "jclass klass")
+      native_method_parameters + java_params.enum_for(:each_with_index).map { |param,i| "#{java_to_jni(param)} #{prefix}#{i}" }
+    end
+
+    def jni_convert_jni_to_c(prefix = "param")
+      conversions = Array.new
+      java_params.each_with_index do |param, i|
+        case param
+        when "java.lang.String"
+          conversions << "const char* c#{prefix}#{i} = env->GetStringUTFChars(#{prefix}#{i}, nullptr /* iscopy */)"
+        end
+      end
+      conversions
+    end
+
+    def jni_native_method_converted_parameters(prefix = "param")
+      conversions = Array.new
+      java_params.each_with_index do |param, i|
+        case param
+        when "java.lang.String"
+          conversions << "c#{prefix}#{i}"
+        else
+          conversions << "#{prefix}#{i}"
+        end
+      end
+      conversions
+    end
+
+    def jni_release_converted_to_c(prefix = "param")
+      releases = Array.new
+      java_params.each_with_index do |param, i|
+        case param
+        when "java.lang.String"
+          releases << "env->ReleaseStringUTFChars(#{prefix}#{i}, c#{prefix}#{i})"
+        end
+      end
+      releases
+    end
+
+    def vm_signature_params
+      vm_signature.match(/^\(([^\)]*)\)/)[1]
+    end
+
+    def java_params
+      java_signature.drop(1)
+    end
+
+    def java_return_type
+      java_signature.at(0)
+    end
+
+    def jni_params
+      java_params.map { |java_type| java_to_jni(java_type) }
+    end
+
+    def jni_return_value
+      java_to_jni(java_return_type)
+    end
+
+#private
+
+    def java_signature
+      types = vm_signature.scan(/(\[?([ZBCSIJFDV]|L[^;]*;))/).map do |match|
+        is_array = match[0].start_with? "["
+        val = vm_to_java(match[0])
+        if is_array
+          val << "[]"
+          val[1..-1]
+        else
+          val
+        end
+      end
+      back = types.pop
+      types.unshift(back)
+    end
+
+    def vm_to_java(vm_type)
+      case vm_type
+      when "Z" then "boolean"
+      when "B" then "byte"
+      when "C" then "char"
+      when "S" then "short"
+      when "I" then "int"
+      when "J" then "long"
+      when "F" then "float"
+      when "D" then "double"
+      when "V" then "void"
+      else 
+        vm_type.gsub("L", "").gsub(";", "").gsub("/", ".")
+      end
+    end
+
+    def java_to_c(java_type)
+      case java_type
+      when "boolean" then "bool"
+      when "byte" then "byte"
+      when "char" then "char"
+      when "short" then "short"
+      when "int" then "int"
+      when "long" then "long"
+      when "float" then "float"
+      when "double" then "double"
+      when "java.lang.String" then "const char*"
+      when "void" then "void"
+      else "jobject" end
+    end
+
+    def java_to_jni(java_type)
+      case java_type
+      when "boolean" then "jboolean"
+      when "byte" then "jbyte"
+      when "char" then "jchar"
+      when "short" then "jshort"
+      when "int" then "jint"
+      when "long" then "jlong"
+      when "float" then "jfloat"
+      when "double" then "jdouble"
+      when "java.lang.String" then "jstring"
+      when "void" then raise "Cannot convert `void' to JNI type"
+      else "jobject" end
+    end
+
+    # See https://docs.oracle.com/javase/7/docs/technotes/guides/jni/spec/design.html Table 2-1)
+    def mangle(str)
+      mangled_name = str.gsub("_", "_1")
+        .gsub(";", "_2")
+        .gsub("[", "_3")
+        .gsub("/", "_")
+      mangled_name.codepoints.map do |codepoint|
+        case
+        when codepoint <= 0xFF then codepoint.chr
+        else "_0#{"%04x" % codepoint}"
+        end
+      end.join
+    end
+  end
+end

data/lib/java_dissassembler/field.rb

@@ -0,0 +1,58 @@
+module Java
+  class Field < Annotatable
+    attr_reader :flags, :name, :vm_type, :java_type, :annotations
+
+    ACC_PUBLIC    = 0x0001 # Declared public; may be accessed from outside its package.
+    ACC_PRIVATE   = 0x0002 # Declared private; usable only within the defining class.
+    ACC_PROTECTED = 0x0004 # Declared protected; may be accessed within subclasses.
+    ACC_STATIC    = 0x0008 # Declared static.
+    ACC_FINAL     = 0x0010 # Declared final; never directly assigned to after object construction (JLS §17.5).
+    ACC_VOLATILE  = 0x0040 # Declared volatile; cannot be cached.
+    ACC_TRANSIENT = 0x0080 # Declared transient; not written or read by a persistent object manager.
+    ACC_SYNTHETIC = 0x1000 # Declared synthetic; not present in the source code.
+    ACC_ENUM      = 0x4000 # Declared as an element of an enum.
+
+    def initialize(flags, name, vm_type, annotations)
+      super(annotations)
+      @flags = flags
+      @name = name
+      @vm_type = vm_type
+    end
+
+    def is_public?
+      (@flags & ACC_PUBLIC) != 0
+    end
+
+    def is_private?
+      (@flags & ACC_PRIVATE) != 0
+    end
+
+    def is_protected?
+      (@flags & ACC_PROTECTED) != 0
+    end
+
+    def is_static?
+      (@flags & ACC_STATIC) != 0
+    end
+
+    def is_final?
+      (@flags & ACC_FINAL) != 0
+    end
+
+    def is_volatile?
+      (@flags & ACC_VOLATILE) != 0
+    end
+
+    def is_transient?
+      (@flags & ACC_TRANSIENT) != 0
+    end
+
+    def is_synthetic?
+      (@flags & ACC_SYNTHETIC) != 0
+    end
+
+    def is_enum?
+      (@flags & ACC_ENUM) != 0
+    end
+  end
+end

data/lib/java_dissassembler/method.rb

@@ -0,0 +1,91 @@
+module Java
+  class Method < Annotatable
+    attr_reader :flags, :name, :vm_signature
+
+    ACC_PUBLIC       = 0x0001 # Declared public; may be accessed from outside its package.
+    ACC_PRIVATE      = 0x0002 # Declared private; accessible only within the defining class.
+    ACC_PROTECTED    = 0x0004 # Declared protected; may be accessed within subclasses.
+    ACC_STATIC       = 0x0008 # Declared static.
+    ACC_FINAL        = 0x0010 # Declared final; must not be overridden (§5.4.5).
+    ACC_SYNCHRONIZED = 0x0020 # Declared synchronized; invocation is wrapped by a monitor use.
+    ACC_BRIDGE       = 0x0040 # A bridge method, generated by the compiler.
+    ACC_VARARGS      = 0x0080 # Declared with variable number of arguments.
+    ACC_NATIVE       = 0x0100 # Declared native; implemented in a language other than Java.
+    ACC_ABSTRACT     = 0x0400 # Declared abstract; no implementation is provided.
+    ACC_STRICT       = 0x0800 # Declared strictfp; floating-point mode is FP-strict.
+    ACC_SYNTHETIC    = 0x1000 # Declared synthetic; not present in the source code.
+
+    def initialize(flags, name, vm_signature, annotations)
+      super(annotations)
+      @flags = flags
+      @name = name
+      @vm_signature = vm_signature
+      #java_signature = vm_signature.scan(/\[?[ZBCSIJFDV]|\[?L[^\;]*;/).map { |m| vm_to_java(m) }
+    end
+
+    def is_public?
+      (@flags & ACC_PUBLIC) != 0
+    end
+
+    def is_private?
+      (@flags & ACC_PRIVATE) != 0
+    end
+
+    def is_protected?
+      (@flags & ACC_PROTECTED) != 0
+    end
+
+    def is_static?
+      (@flags & ACC_STATIC) != 0
+    end
+
+    def is_final?
+      (@flags & ACC_FINAL) != 0
+    end
+
+    def is_synchronized?
+      (@flags & ACC_SYNCHRONIZED) != 0
+    end
+
+    def is_bridge?
+      (@flags & ACC_BRIDGE) != 0
+    end
+
+    def is_varargs?
+      (@flags & ACC_VARARGS) != 0
+    end
+
+    def is_native?
+      (@flags & ACC_NATIVE) != 0
+    end
+
+    def is_abstract?
+      (@flags & ACC_ABSTRACT) != 0
+    end
+
+    def is_strict?
+      (@flags & ACC_STRICT) != 0
+    end
+
+    def is_synthetic?
+      (@flags & ACC_SYNTHETIC) != 0
+    end
+
+  #private
+  #  def vm_to_java(vm_type)
+  #    suffix = vm_type =~ /^\[/ ? "[]" : ""
+  #    case vm_type
+  #    when "V" then "void"
+  #    when "Z" then "boolean"
+  #    when "B" then "byte"
+  #    when "C" then "char"
+  #    when "S" then "short"
+  #    when "I" then "int"
+  #    when "J" then "long"
+  #    when "F" then "float"
+  #    when "D" then "double"
+  #    else vm_type.gsub(/[L;]/, "").gsub("/", ".")
+  #    end + suffix
+  #  end
+  end
+end

data/lib/java_dissassembler.rb

@@ -0,0 +1,226 @@
+require 'java_dissassembler/array'
+require 'java_dissassembler/annotatable'
+require 'java_dissassembler/class'
+require 'java_dissassembler/method'
+require 'java_dissassembler/field'
+
+# See https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html for JVM Class Binary Specification
+module Java
+  class Dissassembler
+    class << self
+      CONSTANT_UTF8               = 1
+      CONSTANT_INTEGER            = 3
+      CONSTANT_FLOAT              = 4
+      CONSTANT_LONG               = 5
+      CONSTANT_DOUBLE             = 6
+      CONSTANT_CLASS              = 7
+      CONSTANT_STRING             = 8
+      CONSTANT_FIELDREF           = 9
+      CONSTANT_METHODREF          = 10
+      CONSTANT_INTERFACEMETHODREF = 11
+      CONSTANT_NAMEANDTYPE        = 12
+      CONSTANT_METHODHANDLE       = 15
+      CONSTANT_METHODTYPE         = 16
+      CONSTANT_INVOKEDYNAMIC      = 18
+
+      MAGIC = "\xCA\xFE\xBA\xBE".each_byte.to_a.freeze
+
+      def dissassemble(bytes)
+        if bytes.is_a?(Array)
+          do_dissassemble(bytes)
+        elsif bytes.is_a?(String)
+          do_dissassemble(bytes.each_byte.to_a)
+        else
+          raise "Expected `bytes' to be Array of bytes or String of bytes"
+        end
+      end
+
+      def dissassemble_file(path)
+        File.open(path) do |file|
+          dissassemble(file.read)
+        end
+      end
+
+    private
+      def do_dissassemble(bytes)
+        raise "Missing magic number 0xCAFEBABE.  Not a .class file" unless bytes[0..3] == MAGIC
+
+        minor = bytes[4..5].u2
+        major = bytes[6..7].u2
+        offset = 8
+
+        # Constant Pool
+        constant_pool = {}
+        constant_pool_size = bytes[offset..offset + 1].u2 - 1
+        offset += 2
+        i = 0
+        while i < constant_pool_size
+          consumed, val, tag = constant_pool_info_size(bytes[offset..-1])
+          i += 1 if !tag.nil? && ((tag == 5) || (tag == 6)) # Floats and Doubles take up two constant pool entries :/
+          constant_pool[i + 1] = val unless val.nil?
+          offset += consumed
+          i += 1
+        end
+
+        # Class Info: 3 x u2 (access_flags, this_klass, super_klass)
+        access_flags = bytes[offset..offset + 1].u2
+        this_klass = constant_pool[constant_pool[bytes[offset + 2..offset + 3].u2]]
+        super_klass = constant_pool[constant_pool[bytes[offset + 4..offset + 5].u2]]
+        offset += 6
+
+        # Interfaces
+        interfaces = Array.new
+        interfaces_count = bytes[offset..offset + 1].u2
+        offset += 2
+        interfaces_count.times do 
+          interface_index = bytes[offset..offset + 1].u2
+          interfaces << constant_pool[interface_index]
+          offset += 2
+        end
+
+        # Fields
+        fields = Array.new
+        fields_count = bytes[offset..offset + 1].u2
+        offset += 2
+        fields_count.times do
+          flags = bytes[offset..offset + 1].u2
+          name = bytes[offset + 2..offset + 3].u2
+          sig = bytes[offset + 4..offset + 5].u2
+          offset += 6 # Skip the field header
+
+          consumed, annotations = parse_attributes(bytes[offset..-1], constant_pool)
+          fields << Java::Field.new(flags, constant_pool[name], constant_pool[sig], annotations.compact)
+          offset += consumed
+        end
+
+        # Parse methods
+        methods = Array.new
+        methods_count = bytes[offset..offset + 1].u2
+        offset += 2
+        methods_count.times do
+          flags = bytes[offset..offset + 1].u2
+          name = bytes[offset + 2..offset + 3].u2
+          sig = bytes[offset + 4..offset + 5].u2
+          offset += 6
+
+          consumed, annotations = parse_attributes(bytes[offset..-1], constant_pool)
+          methods << Java::Method.new(flags, constant_pool[name], constant_pool[sig], annotations.compact)
+          offset += consumed
+        end
+
+        # Parse class attributes
+        _, annotations = parse_attributes(bytes[offset..-1], constant_pool)
+        Java::Class.new(major, minor, access_flags, this_klass, super_klass, interfaces, fields, methods, annotations)
+      end
+
+      def to_double(fixnum)
+        case fixnum
+        when 0x7ff0000000000000 then Float::INFINITY
+        when 0xfff0000000000000 then -Float::INFINITY
+        #TODO: NaN
+        else
+          s = (fixnum >> 63) == 0 ? 1 : -1
+          e = (fixnum >> 52) & 0x7ff
+          m = e == 0 ? (fixnum & 0xfffffffffffff) << 1 : (fixnum & 0xfffffffffffff) | 0x10000000000000
+          (s * m * 2**(e - 1075)).to_f
+        end
+      end
+
+      def to_float(fixnum)
+        case fixnum
+        when 0x7f800000 then Float::INFINITY
+        when 0xff800000 then Float::INFINITY
+        #TODO: NaN
+        else
+          s = ((fixnum >> 31) == 0) ? 1 : -1
+          e = ((fixnum >> 23) & 0xff)
+          m = (e == 0) ?  (fixnum & 0x7fffff) << 1 : (fixnum & 0x7fffff) | 0x800000;
+          (s * m * 2**(e - 150)).to_f
+        end
+      end
+
+      def constant_pool_info_size(bytes)
+        constant_pool_tag = bytes[0]
+        case constant_pool_tag
+        when CONSTANT_UTF8
+          tag_content_size = bytes[1..2].u2
+          val = bytes[3..tag_content_size + 2].modified_utf8_to_s
+          return 3 + tag_content_size, val
+        when CONSTANT_INTEGER
+          val = bytes[1..4].u4
+          return 5, val
+        when CONSTANT_FLOAT
+          val = to_float(bytes[1..4].u4)
+          return 5, val
+        when CONSTANT_LONG
+          high_bytes = bytes[1..4].u4
+          low_bytes = bytes[5..8].u4
+          return 9, (high_bytes << 32) + low_bytes, constant_pool_tag
+        when CONSTANT_DOUBLE
+          high_bytes = bytes[1..4].u4
+          low_bytes = bytes[5..8].u4
+          return 9, to_double((high_bytes << 32) + low_bytes), constant_pool_tag
+        when CONSTANT_STRING, CONSTANT_CLASS
+          val = bytes[1..2].u2
+          return 3, val
+        when CONSTANT_FIELDREF, CONSTANT_METHODREF, CONSTANT_INTERFACEMETHODREF
+          klass_index = bytes[1..2].u2
+          name_and_type_index = bytes[3..4].u2
+          return 5, [klass_index, name_and_type_index]
+        when CONSTANT_NAMEANDTYPE
+          name_index = bytes[1..2].u2
+          descriptor_index = bytes[3..4].u2
+          return 5, [name_index, descriptor_index]
+        when CONSTANT_METHODHANDLE
+          reference_kind = bytes[1].u1
+          reference_index = bytes[2..3].u2
+          return 4, [reference_kind, reference_index]
+        when CONSTANT_METHODTYPE
+          return 3, bytes[1..2].u2
+        when CONSTANT_INVOKEDYNAMIC
+          bootstrap_method_attr_index = bytes[1..2].u2
+          name_and_type_index = bytes[3..4].u2
+          return 5, [bootstrap_method_attr_index, name_and_type_index]
+        else raise "Unknown Constant Pool Tag: 0x#{constant_pool_tag.to_s(16)}"
+        end
+      end
+
+      def parse_annotation(bytes, constant_pool)
+        annotations = {}
+        num_annotations = bytes[0..1].u2
+        offset = 2
+        num_annotations.times do |_annotation|
+          annotation_name_index = bytes[offset..offset + 1].u2
+          num_value_pairs = bytes[offset + 2..offset + 3].u2
+          offset += 4
+          key_values = annotations[ constant_pool[annotation_name_index] ] = []
+          num_value_pairs.times do |_value_pairs|
+            name = bytes[offset..offset + 1].u2
+            # TODO: Handle 4.7.16.1. The element_value structure
+            value = bytes[offset + 3..offset + 4].u2
+            key_values << constant_pool[name]
+            key_values << constant_pool[value]
+          end
+        end
+        return nil if annotations.empty?
+        annotations
+      end
+
+      def parse_attributes(bytes, constant_pool)
+        annotations = []
+        attr_count = bytes[0..1].u2
+        offset = 2 # Consume attr_count
+        attr_count.times do |_attr|
+          attr_name_index = bytes[offset..offset + 1].u2
+          attr_size = bytes[offset + 2..offset + 5].u4
+          offset += 6
+          if (constant_pool[attr_name_index] == "RuntimeInvisibleAnnotations") && (attr_size > 0)
+            annotations << parse_annotation(bytes[offset..offset + attr_size], constant_pool)
+          end
+          offset += attr_size
+        end
+        [offset, annotations]
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: java_dissassembler
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Josh Bodily
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-22 00:00:00.000000000 Z
+dependencies: []
+description: A Java .class file dissassembler.  Similar to javap, but w/ no JDK dependencies.  Pure
+  Ruby
+email: joshbodily@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/java_dissassembler.rb
+- lib/java_dissassembler/annotatable.rb
+- lib/java_dissassembler/array.rb
+- lib/java_dissassembler/class.rb
+- lib/java_dissassembler/erb_helper.rb
+- lib/java_dissassembler/field.rb
+- lib/java_dissassembler/method.rb
+homepage: http://rubygems.org/gems/java_dissassembler
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.7
+signing_key: 
+specification_version: 4
+summary: Java .class file dissassembler
+test_files: []