rex 2.0.8 → 2.0.9

data/lib/rex/java/serialization/model/long_utf.rb

@@ -11,11 +11,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @return [nil] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             raw_length = io.read(8)
             if raw_length.nil? || raw_length.length != 8
-              raise ::RuntimeError, 'Failed to unserialize LongUtf'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize LongUtf'
             end
             self.length = raw_length.unpack('Q>')[0]
 
@@ -24,7 +24,7 @@ module Rex
             else
               self.contents = io.read(length)
               if contents.nil? || contents.length != length
-                raise ::RuntimeError, 'Failed to unserialize LongUtf'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize LongUtf'
               end
             end
 

data/lib/rex/java/serialization/model/new_array.rb

@@ -31,7 +31,7 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             self.array_description = ClassDesc.decode(io, stream)
             stream.add_reference(self) unless stream.nil?
@@ -50,10 +50,10 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::NewArray
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             unless array_description.kind_of?(ClassDesc)
-              raise ::RuntimeError, 'Failed to serialize NewArray'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize NewArray'
             end
 
             encoded = ''
@@ -83,11 +83,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Integer] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode_values_length(io)
             values_length = io.read(4)
             if values_length.nil? || values_length.length != 4
-              raise ::RuntimeError, 'Failed to unserialize NewArray'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize NewArray'
             end
 
             values_length.unpack('N')[0]
@@ -96,15 +96,15 @@ module Rex
           # Extracts the NewArray data type
           #
           # @return [String]
-          # @raise [RuntimeError] if the NewArray description isn't valid
-          # @raise [RuntimeError] if the NewArray type isn't supported
+          # @raise [Rex::Java::Serialization::DecodeError] if the NewArray description isn't valid
+          #   or type isn't supported
           def array_type
             if array_description.nil?
-              raise ::RuntimeError, 'Empty NewArray description'
+              raise Rex::Java::Serialization::DecodeError, 'Empty NewArray description'
             end
 
             unless array_description.kind_of?(ClassDesc)
-              raise ::RuntimeError, 'Unsupported NewArray description class'
+              raise Rex::Java::Serialization::DecodeError, 'Unsupported NewArray description class'
             end
 
             desc = array_description.description
@@ -115,7 +115,7 @@ module Rex
             end
 
             unless desc.class_name.contents[0] == '[' # Array
-              raise ::RuntimeError, 'Unsupported NewArray description'
+              raise Rex::Java::Serialization::DecodeError, 'Unsupported NewArray description'
             end
 
             decoded_type = desc.class_name.contents[1]
@@ -124,7 +124,7 @@ module Rex
             elsif decoded_type == 'L' # L : Object
               return desc.class_name.contents[2..desc.class_name.contents.index(';')] # Object class
             else
-              raise ::RuntimeError, 'Unsupported NewArray Type'
+              raise Rex::Java::Serialization::DecodeError, 'Unsupported NewArray Type'
             end
           end
 
@@ -132,54 +132,54 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Fixnum, Float] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization fails
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization fails
           def decode_value(io)
             value = nil
 
             case type
             when 'byte'
               value = io.read(1)
-              raise ::RuntimeError, 'Failed to deserialize NewArray value' if value.nil?
+              raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value' if value.nil?
               value = value.unpack('c')[0]
             when 'char'
               value = io.read(2)
               unless value && value.length == 2
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value = value.unpack('s>')[0]
             when 'double'
               value = io.read(8)
               unless value && value.length == 8
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value = value.unpack('G')[0]
             when 'float'
               value = io.read(4)
               unless value && value.length == 4
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value = value.unpack('g')[0]
             when 'int'
               value = io.read(4)
               unless value && value.length == 4
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value = value.unpack('l>')[0]
             when 'long'
               value = io.read(8)
               unless value && value.length == 8
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value = value.unpack('q>')[0]
             when 'short'
               value = io.read(2)
               unless value && value.length == 2
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value = value.unpack('s>')[0]
             when 'boolean'
               value = io.read(1)
-              raise ::RuntimeError, 'Failed to deserialize NewArray value' if value.nil?
+              raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value' if value.nil?
               value = value.unpack('c')[0]
             else # object
               value = decode_content(io, stream)
@@ -190,10 +190,9 @@ module Rex
 
           # Serializes an NewArray value
           #
-          # @param value [Fixnum] the value to serialize
-          # @param value [Float] the value to serialize
+          # @param value [<Fixnum, Float>] the value to serialize
           # @return [String] the serialized value
-          # @raise [RuntimeError] if serialization fails
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization fails
           def encode_value(value)
             res = ''
 

data/lib/rex/java/serialization/model/new_class.rb

@@ -0,0 +1,57 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Java
+    module Serialization
+      module Model
+        # This class provides a NewArray (Java Array) representation
+        class NewClass < Element
+
+          include Rex::Java::Serialization::Model::Contents
+
+          # @!attribute array_description
+          #   @return [Java::Serialization::Model::ClassDesc] The description of the class
+          attr_accessor :class_description
+
+          # @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
+          def initialize(stream = nil)
+            super(stream)
+            self.class_description = nil
+          end
+
+          # Deserializes a Rex::Java::Serialization::Model::NewClass
+          #
+          # @param io [IO] the io to read from
+          # @return [self] if deserialization succeeds
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
+          def decode(io)
+            self.class_description = ClassDesc.decode(io, stream)
+            stream.add_reference(self) unless stream.nil?
+
+            self
+          end
+
+          # Serializes the Rex::Java::Serialization::Model::NewClass
+          #
+          # @return [String] if serialization succeeds
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
+          def encode
+            unless class_description.kind_of?(ClassDesc)
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize NewClass'
+            end
+
+            encoded = ''
+            encoded << class_description.encode
+          end
+
+          # Creates a print-friendly string representation
+          #
+          # @return [String]
+          def to_s
+            print_content(class_description)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rex/java/serialization/model/new_class_desc.rb

@@ -12,16 +12,16 @@ module Rex
           # @!attribute class_name
           #   @return [Rex::Java::Serialization::Model::Utf] The name of the class
           attr_accessor :class_name
-          # @!attribute name
-          #   @return [Integer] The java class serial version
+          # @!attribute serial_version
+          #   @return [Fixnum] The java class serial version
           attr_accessor :serial_version
           # @!attribute flags
-          #   @return [Integer] The java class flags
+          #   @return [Fixnum] The java class flags
           attr_accessor :flags
           # @!attribute fields
           #   @return [Array] The java class fields
           attr_accessor :fields
-          # @!attribute fields
+          # @!attribute class_annotation
           #   @return [Rex::Java::Serialization::Model::Annotation] The java class annotations
           attr_accessor :class_annotation
           # @!attribute super_class
@@ -39,11 +39,11 @@ module Rex
             self.super_class = nil
           end
 
-          # Deserializes a Rex::Java::Serialization::Model::ClassDescription
+          # Deserializes a Rex::Java::Serialization::Model::NewClassDesc
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             self.class_name = Utf.decode(io, stream)
             self.serial_version = decode_serial_version(io)
@@ -64,17 +64,16 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::ClassDescription
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             unless class_name.class == Rex::Java::Serialization::Model::Utf ||
                     class_annotation.class == Rex::Java::Serialization::Model::Annotation ||
                     super_class.class == Rex::Java::Serialization::Model::ClassDesc
-              raise ::RuntimeError, 'Filed to serialize NewClassDesc'
+              raise Rex::Java::Serialization::EncodeError, 'Filed to serialize NewClassDesc'
             end
             encoded = ''
             encoded << class_name.encode
-            encoded << [serial_version].pack('Q>')
-            stream.add_reference(self) unless stream.nil?
+            encoded << [serial_version].pack('q>')
             encoded << [flags].pack('C')
             encoded << [fields.length].pack('n')
             fields.each do |field|
@@ -113,11 +112,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Integer] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode_serial_version(io)
             raw_serial = io.read(8)
             if raw_serial.nil? || raw_serial.length != 8
-              raise ::RuntimeError, 'Failed to unserialize ClassDescription'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize ClassDescription'
             end
 
             raw_serial.unpack('Q>')[0]
@@ -127,10 +126,10 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Integer] if deserialization is possible
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode_flags(io)
             raw_flags = io.read(1)
-            raise ::RuntimeError, 'Failed to unserialize ClassDescription' if raw_flags.nil?
+            raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize ClassDescription' if raw_flags.nil?
 
             raw_flags.unpack('C')[0]
           end
@@ -139,11 +138,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Integer] if deserialization is possible
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode_fields_length(io)
             fields_length = io.read(2)
             if fields_length.nil? || fields_length.length != 2
-              raise ::RuntimeError, 'Failed to unserialize ClassDescription'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize ClassDescription'
             end
 
             fields_length.unpack('n')[0]

data/lib/rex/java/serialization/model/new_enum.rb

@@ -27,7 +27,7 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             self.enum_description = ClassDesc.decode(io, stream)
             stream.add_reference(self) unless stream.nil?
@@ -39,11 +39,11 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::NewEnum
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             unless enum_description.kind_of?(ClassDesc) &&
                    constant_name.kind_of?(Utf)
-              raise ::RuntimeError, 'Failed to serialize EnumDescription'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize EnumDescription'
             end
 
             encoded = ''
@@ -65,10 +65,10 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Rex::Java::Serialization::Model::Utf] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succed
           def decode_constant_name(io)
             content = decode_content(io, stream)
-            raise ::RuntimeError, 'Failed to unserialize NewEnum' unless content.kind_of?(Rex::Java::Serialization::Model::Utf)
+            raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize NewEnum' unless content.kind_of?(Rex::Java::Serialization::Model::Utf)
 
             content
           end

data/lib/rex/java/serialization/model/new_object.rb

@@ -27,7 +27,7 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             self.class_desc = ClassDesc.decode(io, stream)
             stream.add_reference(self) unless stream.nil?
@@ -46,10 +46,10 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::NewObject
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             unless class_desc.kind_of?(ClassDesc)
-              raise ::RuntimeError, 'Failed to serialize NewObject'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize NewObject'
             end
 
             encoded = ''
@@ -71,9 +71,12 @@ module Rex
           # @return [String]
           def to_s
             str  = ''
+
             case class_desc.description
             when NewClassDesc
               str << class_desc.description.class_name.to_s
+            when ProxyClassDesc
+              str << class_desc.description.interfaces.collect { |iface| iface.contents }.join(',')
             when Reference
               str << (class_desc.description.handle - BASE_WIRE_HANDLE).to_s(16)
             end
@@ -82,6 +85,8 @@ module Rex
             data_str = class_data.collect { |data| data.to_s }
             str << data_str.join(', ')
             str << ' }'
+
+            str
           end
 
           private
@@ -91,7 +96,7 @@ module Rex
           # @param io [IO] the io to read from
           # @param my_class_desc [Rex::Java::Serialization::Model::NewClassDesc] the class description whose data is being extracted
           # @return [Array] class_data values if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode_class_data(io, my_class_desc)
             values = []
 
@@ -114,7 +119,7 @@ module Rex
           # @param io [IO] the io to read from
           # @param my_class_desc [Rex::Java::Serialization::Model::NewClassDesc] the class description whose data is being extracted
           # @return [Array] class_data values if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode_class_fields(io, my_class_desc)
             values = []
 
@@ -135,57 +140,57 @@ module Rex
           # @param io [IO] the io to read from
           # @param type [String] the type of the value to deserialize
           # @return [Array(String, <Fixnum, Float>)] type and value if deserialization succeeds
-          # @raise [RuntimeError] if deserialization fails
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization fails
           def decode_value(io, type)
             value = []
 
             case type
             when 'byte'
               value_raw = io.read(1)
-              raise ::RuntimeError, 'Failed to deserialize NewArray value' if value_raw.nil?
+              raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value' if value_raw.nil?
               value.push('byte', value_raw.unpack('c')[0])
             when 'char'
               value_raw = io.read(2)
               unless value_raw && value_raw.length == 2
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value.push('char', value_raw.unpack('s>')[0])
             when 'double'
               value_raw = io.read(8)
               unless value_raw && value_raw.length == 8
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value.push('double', value = value_raw.unpack('G')[0])
             when 'float'
               value_raw = io.read(4)
               unless value_raw && value_raw.length == 4
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value.push('float', value_raw.unpack('g')[0])
             when 'int'
               value_raw = io.read(4)
               unless value_raw && value_raw.length == 4
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value.push('int', value_raw.unpack('l>')[0])
             when 'long'
               value_raw = io.read(8)
               unless value_raw && value_raw.length == 8
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value.push('long', value_raw.unpack('q>')[0])
             when 'short'
               value_raw = io.read(2)
               unless value_raw && value_raw.length == 2
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value.push('short', value_raw.unpack('s>')[0])
             when 'boolean'
               value_raw = io.read(1)
-              raise ::RuntimeError, 'Failed to deserialize NewArray value' if value_raw.nil?
+              raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value' if value_raw.nil?
               value.push('boolean', value_raw.unpack('c')[0])
             else
-              raise ::RuntimeError, 'Unsupported NewArray type'
+              raise Rex::Java::Serialization::DecodeError, 'Unsupported NewArray type'
             end
 
             value
@@ -195,7 +200,7 @@ module Rex
           #
           # @param value [Array] the type and value to serialize
           # @return [String] the serialized value
-          # @raise [RuntimeError] if serialization fails
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization fails
           def encode_value(value)
             res = ''
 
@@ -217,7 +222,7 @@ module Rex
             when 'boolean'
               res = [value[1]].pack('c')
             else
-              raise ::RuntimeError, 'Unsupported NewArray type'
+              raise Rex::Java::Serialization::EncodeError, 'Unsupported NewArray type'
             end
 
             res