diff --git a/lib/rex/java/serialization.rb b/lib/rex/java/serialization.rb
index 0761c15fdb..c556ab7540 100644
--- a/lib/rex/java/serialization.rb
+++ b/lib/rex/java/serialization.rb
@@ -51,5 +51,7 @@ module Rex
   end
 end
 
+require 'rex/java/serialization/decode_error'
+require 'rex/java/serialization/encode_error'
 require 'rex/java/serialization/model'
 require 'rex/java/serialization/builder'
\ No newline at end of file
diff --git a/lib/rex/java/serialization/decode_error.rb b/lib/rex/java/serialization/decode_error.rb
new file mode 100644
index 0000000000..e45964abfb
--- /dev/null
+++ b/lib/rex/java/serialization/decode_error.rb
@@ -0,0 +1,11 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Java
+    module Serialization
+      class DecodeError < ::RuntimeError
+
+      end
+    end
+  end
+end
\ No newline at end of file
diff --git a/lib/rex/java/serialization/encode_error.rb b/lib/rex/java/serialization/encode_error.rb
new file mode 100644
index 0000000000..483ad3401e
--- /dev/null
+++ b/lib/rex/java/serialization/encode_error.rb
@@ -0,0 +1,11 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Java
+    module Serialization
+      class EncodeError < ::RuntimeError
+
+      end
+    end
+  end
+end
\ No newline at end of file
diff --git a/lib/rex/java/serialization/model/annotation.rb b/lib/rex/java/serialization/model/annotation.rb
index d4ef420d9b..95b3bd9fa7 100644
--- a/lib/rex/java/serialization/model/annotation.rb
+++ b/lib/rex/java/serialization/model/annotation.rb
@@ -24,7 +24,7 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             loop do
               content = decode_content(io, stream)
@@ -38,9 +38,9 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::Annotation
           #
           # @return [String] if serialization suceeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
-            raise ::RuntimeError, 'Failed to serialize Annotation with empty contents' if contents.empty?
+            raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Annotation with empty contents' if contents.empty?
 
             encoded = ''
 
diff --git a/lib/rex/java/serialization/model/block_data.rb b/lib/rex/java/serialization/model/block_data.rb
index 7f103ebf12..c92edaed13 100644
--- a/lib/rex/java/serialization/model/block_data.rb
+++ b/lib/rex/java/serialization/model/block_data.rb
@@ -26,10 +26,10 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             raw_length = io.read(1)
-            raise RuntimeError, 'Failed to unserialize BlockData' if raw_length.nil?
+            raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockData' if raw_length.nil?
             self.length = raw_length.unpack('C')[0]
 
             if length == 0
@@ -37,7 +37,7 @@ module Rex
             else
               self.contents = io.read(length)
               if contents.nil? || contents.length != length
-                raise RuntimeError, 'Failed to unserialize BlockData'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockData'
               end
             end
 
diff --git a/lib/rex/java/serialization/model/block_data_long.rb b/lib/rex/java/serialization/model/block_data_long.rb
index 34adbac6d5..55002ebad2 100644
--- a/lib/rex/java/serialization/model/block_data_long.rb
+++ b/lib/rex/java/serialization/model/block_data_long.rb
@@ -26,11 +26,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             raw_length = io.read(4)
             if raw_length.nil? || raw_length.length != 4
-              raise ::RuntimeError, 'Failed to unserialize BlockDataLong'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockDataLong'
             end
             self.length = raw_length.unpack('N')[0]
 
@@ -39,7 +39,7 @@ module Rex
             else
               self.contents = io.read(length)
               if contents.nil? || contents.length != length
-                raise ::RuntimeError, 'Failed to unserialize BlockData'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockData'
               end
             end
 
diff --git a/lib/rex/java/serialization/model/class_desc.rb b/lib/rex/java/serialization/model/class_desc.rb
index 02ce6e2b11..927e2ef47e 100644
--- a/lib/rex/java/serialization/model/class_desc.rb
+++ b/lib/rex/java/serialization/model/class_desc.rb
@@ -21,13 +21,13 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             content = decode_content(io, stream)
             allowed_contents = [NullReference, NewClassDesc, Reference, ProxyClassDesc]
 
             unless allowed_contents.include?(content.class)
-              raise ::RuntimeError, 'ClassDesc unserialize failed'
+              raise Rex::Java::Serialization::DecodeError, 'ClassDesc unserialize failed'
             end
 
             self.description = content
@@ -37,13 +37,13 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::ClassDesc
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @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 ::RuntimeError, 'Failed to serialize ClassDesc'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize ClassDesc'
             end
 
             encoded << encode_content(description)
diff --git a/lib/rex/java/serialization/model/contents.rb b/lib/rex/java/serialization/model/contents.rb
index b170fc4827..1f70781ff2 100644
--- a/lib/rex/java/serialization/model/contents.rb
+++ b/lib/rex/java/serialization/model/contents.rb
@@ -11,10 +11,10 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Rex::Java::Serialization::Model::Element] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed or unsupported content
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed or unsupported content
           def decode_content(io, stream)
             opcode = io.read(1)
-            raise ::RuntimeError, 'Failed to unserialize content' if opcode.nil?
+            raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize content' if opcode.nil?
             opcode = opcode.unpack('C')[0]
             content = nil
 
@@ -48,11 +48,11 @@ module Rex
             when TC_NULL
               content = NullReference.decode(io, stream)
             when TC_EXCEPTION
-              raise ::RuntimeError, 'Failed to unserialize unsupported TC_EXCEPTION content'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize unsupported TC_EXCEPTION content'
             when TC_RESET
               content = Reset.decode(io, stream)
             else
-              raise ::RuntimeError, 'Failed to unserialize content'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize content'
             end
 
             content
@@ -62,7 +62,7 @@ module Rex
           #
           # @param content [Rex::Java::Serialization::Model::Element] the content to serialize
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode_content(content)
             encoded = ''
 
@@ -96,7 +96,7 @@ module Rex
             when Reference
               encoded << [TC_REFERENCE].pack('C')
             else
-              raise ::RuntimeError, 'Failed to serialize content'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize content'
             end
 
             encoded << content.encode
@@ -107,6 +107,7 @@ module Rex
           #
           # @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 = ''
 
@@ -140,7 +141,7 @@ module Rex
             when Reference
               str << "#{print_class(content)} { #{content.to_s} }"
             else
-              raise ::RuntimeError, 'Failed to serialize content'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize content'
             end
 
             str
diff --git a/lib/rex/java/serialization/model/field.rb b/lib/rex/java/serialization/model/field.rb
index 49d58585cf..b560e3606a 100644
--- a/lib/rex/java/serialization/model/field.rb
+++ b/lib/rex/java/serialization/model/field.rb
@@ -32,12 +32,12 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             code = io.read(1)
 
             unless code && is_valid?(code)
-              raise ::RuntimeError, 'Failed to unserialize Field'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Field'
             end
 
             self.type = TYPE_CODES[code]
@@ -53,14 +53,14 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::Field
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             unless name.kind_of?(Rex::Java::Serialization::Model::Utf)
-              raise ::RuntimeError, 'Failed to serialize Field'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Field'
             end
 
             unless is_type_valid?
-              raise ::RuntimeError, 'Failed to serialize Field'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Field'
             end
 
             encoded = ''
@@ -138,11 +138,12 @@ module Rex
           # 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 ::RuntimeError, 'Failed to serialize Field'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Field'
             end
 
             encoded = encode_content(field_type)
@@ -154,13 +155,13 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Java::Serialization::Model::Utf]
-          # @raise [RuntimeError] if unserialization doesn't succeed
+          # @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 ::RuntimeError, 'Failed to unserialize Field field_type'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Field field_type'
             end
 
             type
diff --git a/lib/rex/java/serialization/model/long_utf.rb b/lib/rex/java/serialization/model/long_utf.rb
index 8ba2413200..df567bb6f0 100644
--- a/lib/rex/java/serialization/model/long_utf.rb
+++ b/lib/rex/java/serialization/model/long_utf.rb
@@ -11,11 +11,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @return [nil] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             raw_length = io.read(8)
             if raw_length.nil? || raw_length.length != 8
-              raise ::RuntimeError, 'Failed to unserialize LongUtf'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize LongUtf'
             end
             self.length = raw_length.unpack('Q>')[0]
 
@@ -24,7 +24,7 @@ module Rex
             else
               self.contents = io.read(length)
               if contents.nil? || contents.length != length
-                raise ::RuntimeError, 'Failed to unserialize LongUtf'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize LongUtf'
               end
             end
 
diff --git a/lib/rex/java/serialization/model/new_array.rb b/lib/rex/java/serialization/model/new_array.rb
index 8f86942f2c..86ff3b0acb 100644
--- a/lib/rex/java/serialization/model/new_array.rb
+++ b/lib/rex/java/serialization/model/new_array.rb
@@ -31,7 +31,7 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             self.array_description = ClassDesc.decode(io, stream)
             stream.add_reference(self) unless stream.nil?
@@ -50,10 +50,10 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::NewArray
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             unless array_description.kind_of?(ClassDesc)
-              raise ::RuntimeError, 'Failed to serialize NewArray'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize NewArray'
             end
 
             encoded = ''
@@ -83,11 +83,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Integer] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode_values_length(io)
             values_length = io.read(4)
             if values_length.nil? || values_length.length != 4
-              raise ::RuntimeError, 'Failed to unserialize NewArray'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize NewArray'
             end
 
             values_length.unpack('N')[0]
@@ -96,15 +96,15 @@ module Rex
           # Extracts the NewArray data type
           #
           # @return [String]
-          # @raise [RuntimeError] if the NewArray description isn't valid
-          # @raise [RuntimeError] if the NewArray type isn't supported
+          # @raise [Rex::Java::Serialization::DecodeError] if the NewArray description isn't valid
+          #   or type isn't supported
           def array_type
             if array_description.nil?
-              raise ::RuntimeError, 'Empty NewArray description'
+              raise Rex::Java::Serialization::DecodeError, 'Empty NewArray description'
             end
 
             unless array_description.kind_of?(ClassDesc)
-              raise ::RuntimeError, 'Unsupported NewArray description class'
+              raise Rex::Java::Serialization::DecodeError, 'Unsupported NewArray description class'
             end
 
             desc = array_description.description
@@ -115,7 +115,7 @@ module Rex
             end
 
             unless desc.class_name.contents[0] == '[' # Array
-              raise ::RuntimeError, 'Unsupported NewArray description'
+              raise Rex::Java::Serialization::DecodeError, 'Unsupported NewArray description'
             end
 
             decoded_type = desc.class_name.contents[1]
@@ -124,7 +124,7 @@ module Rex
             elsif decoded_type == 'L' # L : Object
               return desc.class_name.contents[2..desc.class_name.contents.index(';')] # Object class
             else
-              raise ::RuntimeError, 'Unsupported NewArray Type'
+              raise Rex::Java::Serialization::DecodeError, 'Unsupported NewArray Type'
             end
           end
 
@@ -132,54 +132,54 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Fixnum, Float] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization fails
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization fails
           def decode_value(io)
             value = nil
 
             case type
             when 'byte'
               value = io.read(1)
-              raise ::RuntimeError, 'Failed to deserialize NewArray value' if value.nil?
+              raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value' if value.nil?
               value = value.unpack('c')[0]
             when 'char'
               value = io.read(2)
               unless value && value.length == 2
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value = value.unpack('s>')[0]
             when 'double'
               value = io.read(8)
               unless value && value.length == 8
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value = value.unpack('G')[0]
             when 'float'
               value = io.read(4)
               unless value && value.length == 4
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value = value.unpack('g')[0]
             when 'int'
               value = io.read(4)
               unless value && value.length == 4
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value = value.unpack('l>')[0]
             when 'long'
               value = io.read(8)
               unless value && value.length == 8
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value = value.unpack('q>')[0]
             when 'short'
               value = io.read(2)
               unless value && value.length == 2
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value = value.unpack('s>')[0]
             when 'boolean'
               value = io.read(1)
-              raise ::RuntimeError, 'Failed to deserialize NewArray value' if value.nil?
+              raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value' if value.nil?
               value = value.unpack('c')[0]
             else # object
               value = decode_content(io, stream)
@@ -192,7 +192,7 @@ module Rex
           #
           # @param value [<Fixnum, Float>] the value to serialize
           # @return [String] the serialized value
-          # @raise [RuntimeError] if serialization fails
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization fails
           def encode_value(value)
             res = ''
 
diff --git a/lib/rex/java/serialization/model/new_class_desc.rb b/lib/rex/java/serialization/model/new_class_desc.rb
index 36101dd683..b7b98a307b 100644
--- a/lib/rex/java/serialization/model/new_class_desc.rb
+++ b/lib/rex/java/serialization/model/new_class_desc.rb
@@ -43,7 +43,7 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             self.class_name = Utf.decode(io, stream)
             self.serial_version = decode_serial_version(io)
@@ -64,12 +64,12 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::ClassDescription
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             unless class_name.class == Rex::Java::Serialization::Model::Utf ||
                     class_annotation.class == Rex::Java::Serialization::Model::Annotation ||
                     super_class.class == Rex::Java::Serialization::Model::ClassDesc
-              raise ::RuntimeError, 'Filed to serialize NewClassDesc'
+              raise Rex::Java::Serialization::EncodeError, 'Filed to serialize NewClassDesc'
             end
             encoded = ''
             encoded << class_name.encode
@@ -112,11 +112,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Integer] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode_serial_version(io)
             raw_serial = io.read(8)
             if raw_serial.nil? || raw_serial.length != 8
-              raise ::RuntimeError, 'Failed to unserialize ClassDescription'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize ClassDescription'
             end
 
             raw_serial.unpack('Q>')[0]
@@ -126,10 +126,10 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Integer] if deserialization is possible
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode_flags(io)
             raw_flags = io.read(1)
-            raise ::RuntimeError, 'Failed to unserialize ClassDescription' if raw_flags.nil?
+            raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize ClassDescription' if raw_flags.nil?
 
             raw_flags.unpack('C')[0]
           end
@@ -138,11 +138,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Integer] if deserialization is possible
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode_fields_length(io)
             fields_length = io.read(2)
             if fields_length.nil? || fields_length.length != 2
-              raise ::RuntimeError, 'Failed to unserialize ClassDescription'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize ClassDescription'
             end
 
             fields_length.unpack('n')[0]
diff --git a/lib/rex/java/serialization/model/new_enum.rb b/lib/rex/java/serialization/model/new_enum.rb
index c4ec80fd3a..89c700c7a7 100644
--- a/lib/rex/java/serialization/model/new_enum.rb
+++ b/lib/rex/java/serialization/model/new_enum.rb
@@ -27,7 +27,7 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             self.enum_description = ClassDesc.decode(io, stream)
             stream.add_reference(self) unless stream.nil?
@@ -39,11 +39,11 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::NewEnum
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             unless enum_description.kind_of?(ClassDesc) &&
                    constant_name.kind_of?(Utf)
-              raise ::RuntimeError, 'Failed to serialize EnumDescription'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize EnumDescription'
             end
 
             encoded = ''
@@ -65,10 +65,10 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Rex::Java::Serialization::Model::Utf] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succed
           def decode_constant_name(io)
             content = decode_content(io, stream)
-            raise ::RuntimeError, 'Failed to unserialize NewEnum' unless content.kind_of?(Rex::Java::Serialization::Model::Utf)
+            raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize NewEnum' unless content.kind_of?(Rex::Java::Serialization::Model::Utf)
 
             content
           end
diff --git a/lib/rex/java/serialization/model/new_object.rb b/lib/rex/java/serialization/model/new_object.rb
index b37025dacc..9b84548cb2 100644
--- a/lib/rex/java/serialization/model/new_object.rb
+++ b/lib/rex/java/serialization/model/new_object.rb
@@ -27,7 +27,7 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             self.class_desc = ClassDesc.decode(io, stream)
             stream.add_reference(self) unless stream.nil?
@@ -46,10 +46,10 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::NewObject
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             unless class_desc.kind_of?(ClassDesc)
-              raise ::RuntimeError, 'Failed to serialize NewObject'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize NewObject'
             end
 
             encoded = ''
@@ -93,7 +93,7 @@ module Rex
           # @param io [IO] the io to read from
           # @param my_class_desc [Rex::Java::Serialization::Model::NewClassDesc] the class description whose data is being extracted
           # @return [Array] class_data values if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode_class_data(io, my_class_desc)
             values = []
 
@@ -116,7 +116,7 @@ module Rex
           # @param io [IO] the io to read from
           # @param my_class_desc [Rex::Java::Serialization::Model::NewClassDesc] the class description whose data is being extracted
           # @return [Array] class_data values if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode_class_fields(io, my_class_desc)
             values = []
 
@@ -137,57 +137,57 @@ module Rex
           # @param io [IO] the io to read from
           # @param type [String] the type of the value to deserialize
           # @return [Array(String, <Fixnum, Float>)] type and value if deserialization succeeds
-          # @raise [RuntimeError] if deserialization fails
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization fails
           def decode_value(io, type)
             value = []
 
             case type
             when 'byte'
               value_raw = io.read(1)
-              raise ::RuntimeError, 'Failed to deserialize NewArray value' if value_raw.nil?
+              raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value' if value_raw.nil?
               value.push('byte', value_raw.unpack('c')[0])
             when 'char'
               value_raw = io.read(2)
               unless value_raw && value_raw.length == 2
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value.push('char', value_raw.unpack('s>')[0])
             when 'double'
               value_raw = io.read(8)
               unless value_raw && value_raw.length == 8
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value.push('double', value = value_raw.unpack('G')[0])
             when 'float'
               value_raw = io.read(4)
               unless value_raw && value_raw.length == 4
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value.push('float', value_raw.unpack('g')[0])
             when 'int'
               value_raw = io.read(4)
               unless value_raw && value_raw.length == 4
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value.push('int', value_raw.unpack('l>')[0])
             when 'long'
               value_raw = io.read(8)
               unless value_raw && value_raw.length == 8
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value.push('long', value_raw.unpack('q>')[0])
             when 'short'
               value_raw = io.read(2)
               unless value_raw && value_raw.length == 2
-                raise ::RuntimeError, 'Failed to deserialize NewArray value'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value'
               end
               value.push('short', value_raw.unpack('s>')[0])
             when 'boolean'
               value_raw = io.read(1)
-              raise ::RuntimeError, 'Failed to deserialize NewArray value' if value_raw.nil?
+              raise Rex::Java::Serialization::DecodeError, 'Failed to deserialize NewArray value' if value_raw.nil?
               value.push('boolean', value_raw.unpack('c')[0])
             else
-              raise ::RuntimeError, 'Unsupported NewArray type'
+              raise Rex::Java::Serialization::DecodeError, 'Unsupported NewArray type'
             end
 
             value
@@ -197,7 +197,7 @@ module Rex
           #
           # @param value [Array] the type and value to serialize
           # @return [String] the serialized value
-          # @raise [RuntimeError] if serialization fails
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization fails
           def encode_value(value)
             res = ''
 
@@ -219,7 +219,7 @@ module Rex
             when 'boolean'
               res = [value[1]].pack('c')
             else
-              raise ::RuntimeError, 'Unsupported NewArray type'
+              raise Rex::Java::Serialization::EncodeError, 'Unsupported NewArray type'
             end
 
             res
diff --git a/lib/rex/java/serialization/model/proxy_class_desc.rb b/lib/rex/java/serialization/model/proxy_class_desc.rb
index ba9cb40169..61ad5de9b4 100644
--- a/lib/rex/java/serialization/model/proxy_class_desc.rb
+++ b/lib/rex/java/serialization/model/proxy_class_desc.rb
@@ -31,7 +31,7 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             stream.add_reference(self) unless stream.nil?
 
@@ -49,11 +49,11 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::ProxyClassDesc
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             unless class_annotation.class == Rex::Java::Serialization::Model::Annotation ||
                     super_class.class == Rex::Java::Serialization::Model::ClassDesc
-              raise ::RuntimeError, 'Filed to serialize ProxyClassDesc'
+              raise Rex::Java::Serialization::EncodeError, 'Filed to serialize ProxyClassDesc'
             end
             encoded = ''
             encoded << [interfaces.length].pack('N')
@@ -93,11 +93,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Fixnum] if deserialization is possible
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @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 ::RuntimeError, 'Failed to unserialize ProxyClassDesc'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize ProxyClassDesc'
             end
 
             fields_length.unpack('N')[0]
diff --git a/lib/rex/java/serialization/model/reference.rb b/lib/rex/java/serialization/model/reference.rb
index 71c7765dae..3e8b27ca2f 100644
--- a/lib/rex/java/serialization/model/reference.rb
+++ b/lib/rex/java/serialization/model/reference.rb
@@ -21,11 +21,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             handle_raw = io.read(4)
             unless handle_raw && handle_raw.length == 4
-              raise ::RuntimeError, 'Failed to unserialize Reference'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Reference'
             end
 
             self.handle = handle_raw.unpack('N')[0]
@@ -36,10 +36,10 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::Reference
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             if handle < BASE_WIRE_HANDLE
-              raise ::RuntimeError, 'Failed to serialize Reference'
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Reference'
             end
 
             encoded = ''
diff --git a/lib/rex/java/serialization/model/stream.rb b/lib/rex/java/serialization/model/stream.rb
index 97107e2481..d01edd2bb2 100644
--- a/lib/rex/java/serialization/model/stream.rb
+++ b/lib/rex/java/serialization/model/stream.rb
@@ -34,7 +34,7 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             self.magic = decode_magic(io)
             self.version = decode_version(io)
@@ -50,7 +50,7 @@ module Rex
           # Serializes the Rex::Java::Serialization::Model::Stream
           #
           # @return [String] if serialization succeeds
-          # @raise [RuntimeError] if serialization doesn't succeed
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
           def encode
             encoded = ''
             encoded << [magic].pack('n')
@@ -92,12 +92,12 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [String] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @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 ::RuntimeError, 'Failed to unserialize Stream'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Stream'
             end
 
             STREAM_MAGIC
@@ -107,11 +107,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [Fixnum] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @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 ::RuntimeError, 'Failed to unserialize Stream'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Stream'
             end
 
             STREAM_VERSION
diff --git a/lib/rex/java/serialization/model/utf.rb b/lib/rex/java/serialization/model/utf.rb
index 7ec45f8684..72a58dc139 100644
--- a/lib/rex/java/serialization/model/utf.rb
+++ b/lib/rex/java/serialization/model/utf.rb
@@ -26,11 +26,11 @@ module Rex
           #
           # @param io [IO] the io to read from
           # @return [self] if deserialization succeeds
-          # @raise [RuntimeError] if deserialization doesn't succeed
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
           def decode(io)
             raw_length = io.read(2)
             if raw_length.nil? || raw_length.length != 2
-              raise ::RuntimeError, 'Failed to unserialize Utf'
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Utf'
             end
             self.length = raw_length.unpack('n')[0]
 
@@ -39,7 +39,7 @@ module Rex
             else
               self.contents = io.read(length)
               if contents.nil? || contents.length != length
-                raise ::RuntimeError, 'Failed to unserialize Utf'
+                raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Utf'
               end
             end
 
diff --git a/spec/lib/rex/java/serialization/model/block_data_long_spec.rb b/spec/lib/rex/java/serialization/model/block_data_long_spec.rb
index ce9eb43d12..333b124551 100644
--- a/spec/lib/rex/java/serialization/model/block_data_long_spec.rb
+++ b/spec/lib/rex/java/serialization/model/block_data_long_spec.rb
@@ -48,7 +48,7 @@ describe Rex::Java::Serialization::Model::BlockDataLong do
   describe "#decode" do
     context "when stream contains empty string" do
       it "returns nil" do
-        expect { block.decode(empty_io) }.to raise_error(::RuntimeError)
+        expect { block.decode(empty_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
       end
     end
 
@@ -70,7 +70,7 @@ describe Rex::Java::Serialization::Model::BlockDataLong do
 
     context "when stream contains incomplete block" do
       it "returns nil" do
-        expect { block.decode(incomplete_block_io) }.to raise_error(::RuntimeError)
+        expect { block.decode(incomplete_block_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
       end
     end
 
diff --git a/spec/lib/rex/java/serialization/model/block_data_spec.rb b/spec/lib/rex/java/serialization/model/block_data_spec.rb
index d12d342cdc..a328084a8c 100644
--- a/spec/lib/rex/java/serialization/model/block_data_spec.rb
+++ b/spec/lib/rex/java/serialization/model/block_data_spec.rb
@@ -48,7 +48,7 @@ describe Rex::Java::Serialization::Model::BlockData do
   describe "#decode" do
     context "when stream contains empty string" do
       it "returns nil" do
-        expect { block.decode(empty_io) }.to raise_error(::RuntimeError)
+        expect { block.decode(empty_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
       end
     end
 
@@ -70,7 +70,7 @@ describe Rex::Java::Serialization::Model::BlockData do
 
     context "when stream contains incomplete block" do
       it "returns nil" do
-        expect { block.decode(incomplete_block_io) }.to raise_error(::RuntimeError)
+        expect { block.decode(incomplete_block_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
       end
     end
 
diff --git a/spec/lib/rex/java/serialization/model/field_spec.rb b/spec/lib/rex/java/serialization/model/field_spec.rb
index 10a167042c..151e8e0ad5 100644
--- a/spec/lib/rex/java/serialization/model/field_spec.rb
+++ b/spec/lib/rex/java/serialization/model/field_spec.rb
@@ -34,7 +34,7 @@ describe Rex::Java::Serialization::Model::Field do
 
   describe "#encode" do
     context "when empty field" do
-      it { expect { field.encode }.to raise_error(::RuntimeError) }
+      it { expect { field.encode }.to raise_error(Rex::Java::Serialization::EncodeError) }
     end
 
     context "when primitive field" do
diff --git a/spec/lib/rex/java/serialization/model/long_utf_spec.rb b/spec/lib/rex/java/serialization/model/long_utf_spec.rb
index c72d54cca5..1e9b59d4b8 100644
--- a/spec/lib/rex/java/serialization/model/long_utf_spec.rb
+++ b/spec/lib/rex/java/serialization/model/long_utf_spec.rb
@@ -47,8 +47,8 @@ describe Rex::Java::Serialization::Model::LongUtf do
 
   describe "#decode" do
     context "when stream contains empty string" do
-      it "raises RuntimeError" do
-        expect { long_utf.decode(empty_io) }.to raise_error(::RuntimeError)
+      it "raises Rex::Java::Serialization::DecodeError" do
+        expect { long_utf.decode(empty_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
       end
     end
 
@@ -70,7 +70,7 @@ describe Rex::Java::Serialization::Model::LongUtf do
 
     context "when stream contains incomplete long_utf" do
       it "returns nil" do
-        expect { long_utf.decode(incomplete_utf_io) }.to raise_error(::RuntimeError)
+        expect { long_utf.decode(incomplete_utf_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
       end
     end
 
diff --git a/spec/lib/rex/java/serialization/model/utf_spec.rb b/spec/lib/rex/java/serialization/model/utf_spec.rb
index a022cf9e18..4104912f8e 100644
--- a/spec/lib/rex/java/serialization/model/utf_spec.rb
+++ b/spec/lib/rex/java/serialization/model/utf_spec.rb
@@ -47,8 +47,8 @@ describe Rex::Java::Serialization::Model::Utf do
 
   describe "#decode" do
     context "when stream contains empty string" do
-      it "raises RuntimeError" do
-        expect { utf.decode(empty_io) }.to raise_error(::RuntimeError)
+      it "raises Rex::Java::Serialization::DecodeError" do
+        expect { utf.decode(empty_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
       end
     end
 
@@ -69,8 +69,8 @@ describe Rex::Java::Serialization::Model::Utf do
     end
 
     context "when stream contains incomplete utf" do
-      it "raises RuntimeError" do
-        expect { utf.decode(incomplete_utf_io) }.to raise_error(::RuntimeError)
+      it "raises Rex::Java::Serialization::DecodeError" do
+        expect { utf.decode(incomplete_utf_io) }.to raise_error(Rex::Java::Serialization::DecodeError)
       end
     end