parshal 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7affbe32c6d373f81aaefbfaf744b43c5bb17f4269130c553aefb132ef374ec2
+  data.tar.gz: 958ac000e7eed19af712bd1d93cb92a3b970ce784a3eba471f873b9c6ff44912
+SHA512:
+  metadata.gz: 9d68df5fbca0219f1414b8be9b72cd45853e940bfa52c7ad3ae1ce612b635bfffacaa8f2b287d8f9822d59ae36a630d1858c021c30a57c0a8c531e954dae779b
+  data.tar.gz: 3cc129c365490ce6b43e6443e918a0f981b7e83d0c58ea429008845a556f9348e1c5037f7cfefffaddf5a38c4b2fb5186b77868df372e5a8df399b06e44c6fbc

data/lib/parshal.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative './parshal/marshal'
+require_relative './parshal/unmarshal'
+
+module Parshal
+end

data/lib/parshal/marshal.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Parshal
+  # A high-level marshal method that takes an object and tries to marshal the
+  # object into a byte array.
+  #
+  # == Parameters:
+  # [obj]   The object to serialize
+  #
+  # == Returns:
+  # A byte array of the marshalled object.
+  def self.marshal(obj, prepend_version: true)
+    ret = case obj
+          when NilClass, TrueClass, FalseClass, Symbol
+            marshal_raw(obj)
+          when Integer
+            ['i'.ord] +
+            marshal_raw(obj)
+          when String
+            ['I'.ord] +
+            marshal_raw(obj) +
+            marshal_raw(1) +
+            marshal_raw(:E) +
+            marshal_raw(true)
+          else
+            raise ArgumentError, "marshal doesn't support objects of class #{obj.class}"
+          end
+    ret = [4, 8] + ret if prepend_version
+    ret.pack('c*')
+  end
+
+  # A low-level marshal dump that dumps "raw" types. Intended primarily for
+  # #marshal to use but may be useful in other contexts. Main differences are
+  # that Integer doesn't include its prefix (as it's used raw in many contexts)
+  # and String doesn't turn into an IVAR, it's just the "raw String"
+  # representation that's inside the normal IVAR.
+  #
+  # == Parameters:
+  # [obj]   The object to be serialized.
+  #
+  # == Returns:
+  # The raw form of the serialized object.
+  def self.marshal_raw(obj)
+    case obj
+    when NilClass
+      ['0'.ord]
+    when TrueClass
+      ['T'.ord]
+    when FalseClass
+      ['F'.ord]
+    when Integer
+      marshal_raw_integer obj
+    when Symbol
+      [':'.ord] + marshal_raw(obj.size) + obj.to_s.unpack('c*')
+    when String
+      ['"'.ord] + marshal_raw(obj.size) + obj.unpack('c*')
+    else
+      raise ArgumentError, "marshal_raw doesn't support objects object of class #{obj.class}"
+    end
+  end
+
+  def self.marshal_raw_integer(obj)
+    raise ArgumentError, 'marshal_raw_integer only accepts Integers' unless obj.is_a? Integer
+
+    case obj
+    when (-2**30...-2**24)
+      [-4] + [obj].pack('V').unpack('c4')
+    when (-2**24...-2**16)
+      [-3] + [obj].pack('V').unpack('c3')
+    when (-2**16...-2**8)
+      [-2] + [obj].pack('V').unpack('c2')
+    when (-2**8...-123)
+      [-1] + [obj].pack('V').unpack('c1')
+    when (-123..-1)
+      [obj - 5]
+    when 0
+      [0]
+    when (1...123)
+      [obj + 5]
+    when (123...2**8)
+      [1] + [obj].pack('V').unpack('c1')
+    when (2**8...2**16)
+      [2] + [obj].pack('V').unpack('c2')
+    when (2**16...2**24)
+      [3] + [obj].pack('V').unpack('c3')
+    when (2**24...2**30)
+      [4] + [obj].pack('V').unpack('c4')
+    else
+      raise ArgumentError, 'marshal_raw_integer can only marshal integers between -2**30...2**30'
+    end
+  end
+end

data/lib/parshal/unmarshal.rb

@@ -0,0 +1,283 @@
+module Parshal
+  def self.remove_version_prefix(obj)
+    major, minor = obj[0..1].unpack('cc')
+
+    unless major == 4 && minor == 8
+      warn "WARNING: Reply specifies unsupported version of marshal format: #{major}.#{minor}"
+    end
+
+    obj[2..]
+  end
+
+  def self.unmarshal(raw_obj, remove_version: true, return_rem: false)
+    raise ArgumentError, "raw_obj must be a String type, got #{raw_obj.inspect}" unless raw_obj.is_a? String
+
+    obj = if remove_version
+            remove_version_prefix raw_obj
+          else
+            raw_obj
+          end
+
+    raise ArgumentError, 'Empty object passed to unmarshal' if obj.empty?
+
+    case obj[0]
+    when '0'
+      if return_rem
+        [nil, obj[1..]]
+      else
+        nil
+      end
+    when 'T'
+      if return_rem
+        [true, obj[1..]]
+      else
+        true
+      end
+    when 'F'
+      if return_rem
+        [false, obj[1..]]
+      else
+        false
+      end
+    when 'i'
+      # Integer
+      i, _, rem = unmarshal_raw_integer(obj[1..])
+
+      raise "Remaining data following Integer: #{rem.inspect}" if !return_rem && !rem.empty?
+
+      if return_rem
+        [i, rem]
+      else
+        i
+      end
+    when ':'
+      # Symbol
+      sym, _, rem = unmarshal_raw_string_symbol(obj)
+
+      warn "Remaining data following Symbol: #{rem.inspect}" if !return_rem && !rem.empty?
+
+      if return_rem
+        [sym, rem]
+      else
+        sym
+      end
+    when 'I'
+      # String wrapped in IVAR
+      # we only parse for strings and verify the rest of the basic IVAR parts at
+      # the end
+      # {I, {", marshal(len), raw str}, marshal(1), marshal(:E), marshal(true)}
+      if obj.length < (Marshal.dump('').length - 2) # -2 to strip the version number
+        raise "unexpected IVAR: #{raw_obj.inspect}, smaller than minimum length"
+      end
+
+      str, _, rem = unmarshal_raw_string_symbol(obj[1..])
+
+      raise 'Unexpected end of IVAR' if rem.empty?
+
+      ivar_count, _, rem = unmarshal_raw_integer(rem)
+
+
+      raise "IVAR with more than one instance variable unsupported: #{ivar_count.inspect}" if ivar_count > 1
+
+      raise 'Unexpected end of IVAR' if rem.empty?
+
+      if ivar_count == 0
+        if return_rem
+          return [str, rem]
+        else
+          return str
+        end
+      end
+
+      e, _, rem = unmarshal_raw_string_symbol(rem)
+
+      # :E=true for UTF-8 and :E=false for ASCII, :encoding=whatever for everything else
+      # we are not going to support custom encodings
+      raise "IVAR with unexpected instance variable: #{e.inspect}" unless e == :E
+
+      raise 'Unexpected end of IVAR' if rem.empty?
+      b, _, rem = unmarshal_raw_bool(rem)
+
+      if not b
+        str.force_encoding('ascii')
+      end
+
+      raise "Unexpected data at the end of IVAR: #{rem.inspect}" if !return_rem && !rem.empty?
+
+      if return_rem
+        [str, rem]
+      else
+        str
+      end
+    when '['
+      len, _, rem = unmarshal_raw_integer(obj[1..])
+      arr = []
+      for _ in 0...len
+        obj, rem = unmarshal(rem, remove_version: false, return_rem: true)
+        arr.push(obj)
+      end
+
+      raise "Unexpected data after the end of Array: #{rem.inspect}" if !return_rem && !rem.empty?
+
+      if return_rem
+        [arr, rem]
+      else
+        arr
+      end
+    when 'u'
+      # we pull out the symbol and attempt to decode the payload as a basic value
+      sym, _, rem = unmarshal_raw_string_symbol(obj[1..])
+
+      len, _, rem = unmarshal_raw_integer(rem)
+
+      raise "User-defined payload length mismatch, got #{len}, actual: #{rem.length}" if len != rem.length
+
+      payload = rem
+
+      payload_decoded = begin
+        unmarshal(payload)
+      rescue => e
+        puts e.inspect
+        nil
+      end
+
+      if return_rem
+        [[sym, [payload_decoded, payload]], rem]
+      else
+        [sym, [payload_decoded, payload]]
+      end
+    else
+      unmarshal_type_error obj
+    end
+  end
+
+  def self.unmarshal_type_error(obj)
+    case obj[0]
+    when ';'
+      raise 'Symbol links/references not supported'
+    when '@'
+      raise 'Object links/references not supported'
+    when 'e'
+      raise "'extended' not supported"
+    when 'l'
+      raise 'Bignum not supported'
+    when 'c'
+      raise 'Class not supported'
+    when 'm'
+      raise 'Module not supported'
+    when 'M'
+      raise 'Class/Module not supported'
+    when 'd'
+      raise 'Data objects not supported'
+    when 'f'
+      raise 'Float not supported'
+    when '{', '}'
+      raise 'Hash not supported'
+    when 'o'
+      raise "Object not supported: #{obj.inspect}"
+    when '/'
+      raise 'regular expressions not supported'
+    when 'S'
+      raise 'Struct not supported'
+    when 'C'
+      raise 'user-defined sublass not supported'
+    when 'U'
+      raise "User Marshal serialization not supported: #{obj.inspect}"
+    end
+  end
+
+  def self.unmarshal_raw(obj)
+    raise ArgumentError, 'unmarshal_raw passed Nil' if obj.nil?
+
+    raise ArgumentError, 'unmarshal_raw passed empty String' if obj.empty?
+
+    case obj[0]
+    when '0'
+      [nil, 1, obj[1..]]
+    when 'T', 'F'
+      unmarshal_raw_bool obj
+    when '"', ':'
+      unmarshal_raw_string_symbol obj
+    else
+      raise 'unmarshal_raw passed unknown argument'
+    end
+  end
+
+  def self.unmarshal_raw_bool(obj)
+    raise ArgumentError, 'unmarshal_raw_bool passed nil or empty string' if obj.nil? || obj.empty?
+
+    case obj[0]
+    when 'T'
+      [true, 1, obj[1..]]
+    when 'F'
+      [false, 1, obj[1..]]
+    else
+      raise "unmarshal_raw_bool not passed a bool to unmarshal: #{obj.inspect}"
+    end
+  end
+
+  def self.unmarshal_raw_string_symbol(obj)
+    raise 'unmarshal_raw_string_symbol passed nil or empty String' if obj.nil? || obj.empty?
+
+    raise 'unmarshal_raw_string_symbol not passed marshaled String or Symbol' unless obj[0] == '"' || obj[0] == ':'
+
+    sz, sz_sz, rem = unmarshal_raw_integer(obj[1..])
+
+    raise 'String or Symbol has negative size' if sz.negative?
+
+    str = rem[...sz]
+
+    raise 'Not enough data supplied to satisfy String or Symbol size' unless sz == str.size
+
+    consumed = 1 + sz_sz + sz
+
+    if obj[0] == '"'
+      [str, consumed, obj[consumed..]]
+    else
+      [str.to_sym, consumed, obj[consumed..]]
+    end
+  end
+
+  def self.unmarshal_raw_integer(obj)
+    raise ArgumentError, 'unmarshal_raw_integer passed invalid input' if obj.nil? || obj.empty?
+
+    case obj[0].unpack1('c')
+    when 0
+      # "0 -> Integer: 0"
+      [0, 1, obj[1..]]
+    when 1
+      # "1 -> Integer: (123...2**8)"
+      [obj[1].unpack1('C'), 2, obj[2..]]
+    when 2
+      # "2 -> Integer: (2**8...2**16)"
+      [obj[1..2].unpack1('S<'), 3, obj[3..]]
+    when 3
+      # "3 -> Integer: (2**16...2**24)"
+      ["#{obj[1..3]}\x00".unpack1('L<'), 4, obj[4..]]
+    when 4
+      # "4 -> Integer: (2**24...2**30)"
+      [obj[1..4].unpack1('L<'), 5, obj[5..]]
+    when -1
+      # "-1 -> Integer: (-2**8...-123)"
+      [obj[1].unpack1('C') + (-2**8), 2, obj[2..]]
+    when -2
+      # "-2 -> Integer: (-2**16...-2**8)"
+      [obj[1..2].unpack1('S<') + (-2**16), 3, obj[3..]]
+    when -3
+      # "-3 -> Integer: (-2**24...-2**16)"
+      ["#{obj[1..3]}\x00".unpack1('L<') + (-2**24), 4, obj[4..]]
+    when -4
+      # "-4 -> Integer: (-2**30...-2**24)"
+      [obj[1..4].unpack1('L<') + (-2**32), 5, obj[5..]]
+    when 6..127
+      # "1...123 -> Integer: i+5"
+      [obj[0].unpack1('c') - 5, 1, obj[1..]]
+    when -128..-6
+      # "-123...-1 -> Integer: i-5"
+      [obj[0].unpack1('c') + 5, 1, obj[1..]]
+    else # 5 and -5 are undefined
+      # "unknown: " + obj[0].ord
+      raise ArgumentError, '5 and -5 are undefined when marshaling integers'
+    end
+  end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: parshal
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Addison Amiri
+- Jeff Dileo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-05-20 00:00:00.000000000 Z
+dependencies: []
+description:
+email: jeff.dileo@nccgroup.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/parshal.rb
+- lib/parshal/marshal.rb
+- lib/parshal/unmarshal.rb
+homepage: https://github.com/nccgroup/drb-rb
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: A safer, minimal, partial implementation of Marshal
+test_files: []