miketracy-wwmd 0.2.11

data/lib/wwmd/viewstate/viewstate_class_helpers.rb

@@ -0,0 +1,35 @@
+module WWMD
+  class VSClassHelpers < ViewStateUtils
+    def to_sym
+      self.class.to_s.split(":").last.gsub(/[A-Z]+/,'\1_\0').downcase[1..-1].gsub(/\Avs/,"").to_sym
+    end
+
+    def opcode
+      return VIEWSTATE_TYPES.index(self.to_sym)
+    end
+
+    def size
+      return @value.size
+    end
+
+    def serialize
+      stack = ""
+      stack << self.write_byte(self.opcode)
+      if self.respond_to?(:typeref)
+        stack << self.serialize_type(self.typeref,self.typeval)
+      end
+      return stack
+    end
+
+    def to_xml
+      xml = REXML::Element.new(self.class.to_s.split(":").last)
+      if self.respond_to?(:typeref)
+        xml.add_attribute("typeref",self.typeref)
+        xml.add_attribute("typeval",self.typeval)
+      end
+#      xml.add_attribute("size",self.size)
+      xml
+    end
+ 
+  end
+end

data/lib/wwmd/viewstate/viewstate_deserializer_methods.rb

@@ -0,0 +1,213 @@
+module WWMD
+  class ViewState
+    # complex types
+    def pair(t=nil)
+      dlog t,"next = #{next_type}"
+      VSPair.new(self.deserialize_value,self.deserialize_value)
+    end
+
+    def triplet(t=nil)
+      dlog t,"next = #{next_type}"
+      VSTriplet.new(self.deserialize_value,self.deserialize_value,self.deserialize_value)
+    end
+
+    def type(t=nil)
+      typeref,typeval = self.deserialize_type
+      dlog(t,"typeref = #{typeref} typeval = #{typeval}")
+      VSType.new(typeref,typeval)
+    end
+
+    def string_formatted(t=nil)
+      typeref,typeval = self.deserialize_type
+      str = self.read_string
+      dlog(t,"typeref = #{typeref} typeval = #{typeval} string = #{str}")
+      VSStringFormatted.new(typeref,typeval,str)
+    end
+
+    def int_enum(t=nil)
+      typeref,typeval = self.deserialize_type
+      index = self.read_7bit_encoded_int
+      dlog(t,"typeref = #{typeref} typeval = #{typeval} index = #{index}")
+      VSIntEnum.new(typeref,typeval,index)
+    end
+
+    def binary_serialized(t=nil)
+      count = self.read_7bit_encoded_int
+      dlog(t,count)
+      bin = self.read(count)
+      me = VSBinarySerialized.new()
+      me.set(bin)
+      return me
+    end
+
+    def sparse_array(t=nil)
+      typeref,typeval = self.deserialize_type
+      size  = read_7bit_encoded_int
+      elems = read_7bit_encoded_int
+      dlog(t,"typeref = #{typeref} typeval = #{typeval} size = #{size} elems = #{elems}")
+      me = VSSparseArray.new(typeref,typeval,size,elems)
+      if elems > size
+        raise "Invalid sparse_array"
+      end
+      (1..elems).each do |i|
+        idx = read_7bit_encoded_int
+        me.add(idx,self.deserialize_value)
+      end
+      return me
+    end
+
+    def hashtable(t=nil)
+      len = read_7bit_encoded_int
+      dlog(t,"len = #{len}")
+      me = VSHashtable.new()
+      (1..len).each do |i|
+        me.add(self.deserialize_value,self.deserialize_value)
+      end
+      return me
+    end
+
+    def hybrid_dict(t=nil)
+      len = read_7bit_encoded_int
+      dlog(t,"len = #{len}")
+      me = VSHybridDict.new()
+      (1..len).each do |i|
+        me.add(self.deserialize_value,self.deserialize_value)
+      end
+      return me
+    end
+
+    def array(t=nil)
+      typeref,typeval = self.deserialize_type
+      len = read_7bit_encoded_int
+      dlog(t,"typeref = #{typeref} typeval = #{typeval} len = #{len}")
+      me = VSArray.new(typeref,typeval)
+      (1..len).each do |i|
+        me.add(self.deserialize_value)
+      end
+      return me
+    end
+
+    def string_array(t=nil)
+      len = read_7bit_encoded_int
+      dlog(t,"len = #{len}")
+      me = VSStringArray.new()
+      (1..len).each do |i|
+        str = self.read_string
+        me.add(str)
+        dlog(t,"string_array_elem: #{str}")
+      end
+      return me
+    end
+
+    def list(t=nil)
+      len = read_7bit_encoded_int
+      dlog(t,"len = #{len}")
+      me = VSList.new()
+      (1..len).each do |i|
+        me.add(self.deserialize_value)
+      end
+      return me
+    end
+
+    def unit(t=nil)
+      s1 = read_double
+      s2 = read_int32
+      dlog(t,"#{s1.to_s(16).rjust(16,"0")},#{s2.to_s(16).rjust(8,"0")}")
+      VSUnit.new(s1,s2)
+    end
+
+    def indexed_string(t=nil)
+      str = self.read_string
+      @indexed_strings << str
+      dlog(t,"idx = #{@indexed_strings.size - 1} val = #{str}")
+      VSIndexedString.new(str)
+    end
+
+    def indexed_string_ref(t=nil)
+      ref = self.read_int
+      dlog(t,"ref = #{ref} val = #{@indexed_strings[ref]}")
+      VSIndexedStringRef.new(ref)
+    end
+
+    def string(t=nil)
+      str = self.read_string
+      dlog(t,str)
+      VSString.new(str)
+    end
+
+    # VSReadValue types
+    def color(t=nil)
+      val = self.read_int32
+      dlog(t,val.to_s(16))
+      VSColor.new(val)
+    end
+
+    def known_color(t=nil)
+      index = self.read_7bit_encoded_int
+      dlog(t,"index = #{index.to_s(16)}")
+      VSKnownColor.new(index)
+    end
+
+    def int16(t=nil)
+      val = read_short
+      dlog(t,val)
+      VSInt16.new(val)
+    end
+
+    def int32(t=nil)
+      val = self.read_7bit_encoded_int
+      dlog(t,val)
+      VSInt32.new(val)
+    end
+
+    def byte(t=nil)
+      val = self.read_byte
+      dlog(t,val)
+      VSByte.new(val)
+    end
+
+    def char(t=nil)
+      val = self.read_byte
+      dlog(t,val)
+      VSChar.new(val)
+    end
+
+    def date_time(t=nil)
+      val = self.read_double
+      dlog(t,val)
+      VSDateTime.new(val)
+    end
+
+    def double(t=nil)
+      val = self.read_double
+      dlog(t,val)
+      VSDouble.new(val)
+    end
+
+    def single(t=nil)
+      val = self.read_single
+      dlog(t,val)
+      VSSingle.new(val)
+  end
+
+    # VSValue types
+    def null(t=nil);        dlog(t,nil); return VSValue.new(t); end
+    def empty_byte(t=nil);  dlog(t,nil); return VSValue.new(t); end
+    def zeroint32(t=nil);   dlog(t,nil); return VSValue.new(t); end
+    def bool_true(t=nil);   dlog(t,nil); return VSValue.new(t); end
+    def bool_false(t=nil);  dlog(t,nil); return VSValue.new(t); end
+    def empty_color(t=nil); dlog(t,nil); return VSValue.new(t); end
+    def empty_unit(t=nil);  dlog(t,nil); return VSValue.new(t); end
+
+    # deserialize_value
+    def deserialize_value
+      @last_offset = self.offset
+      token = self.read_byte # self.read_raw_byte
+      raise "Invalid Type #{token.hexify} at #{last_offset}" if not (tsym = VIEWSTATE_TYPES[token])
+      nobj = self.send(tsym,token)
+      raise "Invalid Class Returned #{nobj.class}" if not VIEWSTATE_TYPES.include?(nobj.opcode)
+      return nobj
+    end
+
+  end
+end

data/lib/wwmd/viewstate/viewstate_from_xml.rb

@@ -0,0 +1,126 @@
+module WWMD
+  class ViewState
+# directly serialize into stack from received xml (the easy way)
+# this is pretty silly but it didn't take me very long so...
+
+    attr_reader :xmlstack
+
+    def get_sym(str)
+      str.split(":").last.gsub(/[A-Z]+/,'\1_\0').downcase[1..-1].gsub(/\Avs/,"").to_sym
+    end
+
+    def opcode(name,val)
+      sym = get_sym(name)
+      if sym == :value
+        ret = VIEWSTATE_TYPES.index(val.to_sym)
+      else
+        ret = VIEWSTATE_TYPES.index(sym)
+      end
+      ret
+    end
+
+    def serialize_hashtable(node)
+      tstack = ""
+      tstack << self.write_7bit_encoded_int(node['size'].to_i)
+      node.children.each do |c|
+        next if c.text?
+        raise "Invalid Hashtable: got #{c.name}" if not c.name == "Pair"
+      end
+      tstack
+    end
+
+    def decode_text(node)
+      case node['encoding']
+        when "quoted-printable"
+          node.inner_text.from_qp
+        when "base64"
+          node.inner_text.b64d
+        when "hexify"
+          node.inner_text.dehexify
+        else
+          node.inner_text
+      end
+    end
+
+    def write_node(node)
+      return false if node.text?
+      tstack = ""
+      # this is a hack to get sparse_array to work
+      return false if ["Pair","Key","Value"].include?(node.name) # skip and fall through
+      if ["Index","Size","Elements"].include?(node.name)
+        @xmlstack << self.write_7bit_encoded_int(node.inner_text.to_i)
+        return false
+      end
+      if node.name == "Mac"
+        @xmlstack << decode_text(node)
+        return false
+      end
+      # end hack
+      flag = true # begin; sillyness; rescue => me; end
+      case get_sym(node.name)
+        when :pair, :triplet, :value, :sparse_array, :type, :string_formatted
+        when :int_enum, :known_color, :int32
+          tstack << self.write_7bit_encoded_int(node.inner_text.to_i)
+        when :int16
+          tstack << self.write_short(node.inner_text.to_i)
+        when :byte, :char, :indexed_string_ref
+          tstack << self.write_byte(node.inner_text.to_i)
+        when :color, :single
+          tstack << self.write_int32(node.inner_text.to_i)
+        when :double, :date_time
+          tstack << self.write_double(node.inner_text.to_i)
+        when :unit
+          tstack << self.write_double(node['dword'].to_i)
+          tstack << self.write_single(node['word'].to_i)
+        when :list, :string_array, :array
+          tstack << self.write_7bit_encoded_int(node['size'].to_i)
+        when :string, :indexed_string, :binary_serialized
+          flag = false if ([:string_array,:string_formatted].include?(get_sym(node.parent.name)))
+          # get encoding
+          str = decode_text(node)
+          tstack << self.write_7bit_encoded_int(str.size)
+          tstack << str
+        when :hashtable, :hybrid_dict
+          tstack << serialize_hashtable(node)
+        else
+          raise "Invalid Node:\n#{node.name}"
+      end
+
+      # [flag] is a hack to get around string_array and string_formatted emitting opcodes
+      @xmlstack << self.write_byte(opcode(node.name,node.inner_text)) if flag
+      if node.has_attribute?("typeref")
+        if node['typeref'].to_i == 0x2b
+          @xmlstack << self.serialize_type(node['typeref'].to_i,node['typeval'].to_i)
+        else
+          @xmlstack << self.serialize_type(node['typeref'].to_i,node['typeval'])
+        end
+      end
+      @xmlstack << tstack
+    end
+
+    def serialize_xml(node)
+      begin
+        write_node(node)
+      rescue => e
+        STDERR.puts "ERROR parsing node:\n#{node.to_s}"
+        raise e
+      end
+      node.children.each do |c|
+        serialize_xml(c)
+      end
+    end
+
+    def from_xml(xml)
+      @xmlstack = ""
+      doc = Nokogiri::XML.parse(xml)
+      root = doc.root
+      raise "Invalid ViewState Version" if not root.has_attribute?("version")
+      @xmlstack << root['version'].b64d
+      root.children.each do |c|
+        serialize_xml(c)
+      end
+      self.deserialize(@xmlstack.b64e)
+    end
+
+  end
+end

data/lib/wwmd/viewstate/viewstate_types.rb

@@ -0,0 +1,51 @@
+module WWMD
+#    private const byte Marker_Format = 0xff;
+#    private const byte Marker_Version_1 = 1;
+#    private const int StringTableSize = 0xff;
+
+  VIEWSTATE_MAGIC = ["\xff\x01"] unless defined?(VIEWSTATE_MAGIC)
+
+  VIEWSTATE_TYPES = {
+# System.Web.UI.LosFormatter
+# System.Web.UI.ObjectStateFormatter
+#   .DeserializeValue
+
+    0x00 => :debug,               ##X  debugging
+    0x01 => :int16,               #RX  private const byte Token_Int16 = 1;
+    0x02 => :int32,               #RX  private const byte Token_Int32 = 2;
+    0x03 => :byte,                #RX  private const byte Token_Byte = 3;
+    0x04 => :char,                #RX  private const byte Token_Char = 4;
+    0x05 => :string,              ##X  private const byte Token_String = 5;
+    0x06 => :date_time,           #RX  private const byte Token_DateTime = 6;
+    0x07 => :double,              #RX  private const byte Token_Double = 7;
+    0x08 => :single,              #RX  private const byte Token_Single = 8;
+    0x09 => :color,               ##X  private const byte Token_Color = 9;
+    0x0a => :known_color,         ##X  private const byte Token_KnownColor = 10;
+    0x0b => :int_enum,            ##X  private const byte Token_IntEnum = 11;
+    0x0c => :empty_color,         #VX  private const byte Token_EmptyColor = 12;
+    0x0f => :pair,                ##X  private const byte Token_Pair = 15;
+    0x10 => :triplet,             ##X  private const byte Token_Triplet = 0x10;
+    0x14 => :array,               ##X  private const byte Token_Array = 20;
+    0x15 => :string_array,        ##X  private const byte Token_StringArray = 0x15;
+    0x16 => :list,                ##X  private const byte Token_ArrayList = 0x16;
+    0x17 => :hashtable,           ##X  private const byte Token_Hashtable = 0x17
+    0x18 => :hybrid_dict,         ##X  private const byte Token_HybridDictionary = 0x18;
+    0x19 => :type,                ##X  private const byte Token_Type = 0x19;
+    0x1b => :unit,                ##X  private const byte Token_Unit = 0x1b;
+    0x1c => :empty_unit,          #VX  private const byte Token_EmptyUnit = 0x1c;
+    0x1e => :indexed_string,      ##X  private const byte Token_IndexedStringAdd = 30;
+    0x1f => :indexed_string_ref,  ##X  private const byte Token_IndexedString = 0x1f;
+    0x28 => :string_formatted,    ##X  private const byte Token_StringFormatted = 40;
+    0x29 => :typeref_add,         ##X  private const byte Token_TypeRefAdd = 0x29;
+    0x2a => :typeref_add_local,   ##X  private const byte Token_TypeRefAddLocal = 0x2a;
+    0x2b => :typeref,             ##X  private const byte Token_TypeRef = 0x2b;
+    0x32 => :binary_serialized,   ##X  private const byte Token_BinarySerialized = 50;
+    0x3c => :sparse_array,        ##X  private const byte Token_SparseArray = 60;
+    0x64 => :null,                #VX  private const byte Token_Null = 100;
+    0x65 => :empty_byte,          #VX  private const byte Token_EmptyString = 0x65;
+    0x66 => :zeroint32,           #VX  private const byte Token_ZeroInt32 = 0x66;
+    0x67 => :bool_true,           #VX  private const byte Token_True = 0x67;
+    0x68 => :bool_false,          #VX  private const byte Token_False = 0x68;
+  } unless defined?(VIEWSTATE_TYPES)
+
+end

data/lib/wwmd/viewstate/viewstate_utils.rb

@@ -0,0 +1,157 @@
+module WWMD
+  class ViewStateUtils
+
+    def putd(msg)
+      puts(msg) if self.debug
+    end
+
+    def slog(obj,msg=nil)
+      raise "No @value" if not obj.respond_to?(:value)
+      raise "No @size"  if not obj.respond_to?(:size)
+      putd "#{@stack.size.to_s(16).rjust(8,"0")} [0x#{obj.opcode.to_s(16)}] #{obj.class}: #{msg}"
+    end
+
+    def dlog(t,msg)
+      raise "null token passed to dlog()" if t.nil?
+      putd "#{self.last_offset} [0x#{t.to_s(16).rjust(2,"0")}] #{VIEWSTATE_TYPES[t]}: #{msg}"
+    end
+
+    def write_7bit_encoded_int(val)
+      s = ""
+      while (val >= 0x80) do
+        s << [val | 0x80].pack("C")
+        val = val >> 7
+      end
+      s << [val].pack("C")
+      return s
+    end
+
+    # why oh why did I have to go find this?
+    # System.IO.BinaryReader.Read7BitEncodedInt
+    def read_7bit_encoded_int(buf=nil)
+      l = 0  # length
+      s = 0  # shift
+      b = "" # byte
+      buf = buf.scan(/./m) if buf
+      begin
+        if not buf
+          b = self.read_int
+        else
+          b = buf.shift.unpack("C").first
+        end
+        l |= (b & 0x7f) << s
+        s += 7
+      end while ((b & 0x80) != 0)
+      return l
+    end
+
+    def read_string
+      len = read_7bit_encoded_int
+      starr = []
+      (1..len).each { |i| starr << @bufarr.shift }
+      return starr.to_s
+#      @bufarr.slice!(0..(len - 1)).join("")
+    end
+
+    def read(count)
+      @bufarr.slice!(0..(count - 1)).join("")
+    end
+
+    def read_int
+      @bufarr.shift.unpack("C").first
+    end
+    alias_method :read_byte, :read_int
+
+    def write_int(val)
+      [val].pack("C")
+    end
+    alias_method :write_byte, :write_int
+
+    def read_short
+      self.read(2).unpack("S").first
+    end
+
+    def write_short(val)
+      [val].pack("n")
+    end
+
+    def read_int32
+      @bufarr.slice!(0..3).join("").unpack("L").first
+    end
+    alias_method :read_single, :read_int32
+
+    def write_int32(val)
+      [val].pack("I")
+    end
+    alias_method :write_single, :write_int32
+
+    def read_double
+      @bufarr.slice!(0..7).join("").unpack("Q").first
+    end
+
+    def write_double(val)
+      [val].pack("Q")
+    end
+
+    def magic?
+      @magic = [@bufarr.shift,@bufarr.shift].join("")
+      VIEWSTATE_MAGIC.include?(@magic)
+    end
+
+    def read_raw_byte
+      @bufarr.shift
+    end
+
+    def serialize_type(op,ref)
+      op_str = [op].pack("C")
+      s = op_str
+      case op
+        when VIEWSTATE_TYPES.index(:typeref)
+          s << write_7bit_encoded_int(ref)
+        when VIEWSTATE_TYPES.index(:typeref_add_local)
+          s << write_7bit_encoded_int(ref.size)
+          s << ref
+        when VIEWSTATE_TYPES.index(:typeref_add)
+          s << write_7bit_encoded_int(ref.size)
+          s << ref
+        else
+          raise "Invalid Type Error #{op.to_s(16)}"
+      end
+      return s
+    end
+
+    def deserialize_type(t=nil)
+      op = self.read_byte
+      case op
+        when VIEWSTATE_TYPES.index(:typeref)
+          type = read_7bit_encoded_int
+          return [op,type]
+        when VIEWSTATE_TYPES.index(:typeref_add_local)
+          name  = read_string
+          return [op,name]
+        when VIEWSTATE_TYPES.index(:typeref_add)
+          name  = read_string
+          return [op,name]
+        else
+          raise "Invalid Type Error 0x#{op.to_s(16)}"
+      end
+    end
+
+    def offset(cur=nil)
+        (self.size - @bufarr.size).to_s(16).rjust(8,"0")
+    end
+
+    def throw(t=nil)
+      STDERR.puts "==== Error at Type 0x#{t.to_s(16).rjust(2,"0")}"
+      STDERR.puts "offset: #{self.offset}"
+      STDERR.puts "left:   #{@bufarr.size}"
+      STDERR.puts @bufarr[0..31].join("").hexdump
+    end
+
+    def next_type
+      t = @bufarr.first.unpack("C").first
+      throw(t) if not VIEWSTATE_TYPES.include?(t)
+      VIEWSTATE_TYPES[t]
+    end
+  end
+end