/*
Copyright (c) 2009, Neohapsis, Inc.
All rights reserved.

Implementation by Patrick Toomey

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

– Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
– Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.
– Neither the name of Neohapsis nor the names of its contributors may be used to
endorse or promote products derived from this software without specific prior
written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.Xml;
using System.IO;
using System.Collections.Specialized;
using System.Drawing;
using System.Web.UI;
using System.Web;
using System.Text.RegularExpressions;
using System.Reflection;
using System.ComponentModel;

namespace ViewState
{
abstract class ViewState
{
protected internal int m_version = 0; // ex. 1 (for ASP.Net 1.1)
protected internal bool m_encrypted = false;
protected internal bool m_MACProtected = false;
protected internal String m_versionString = “”; // ex. ASP.Net 2.0
protected internal String m_viewStateBase64 = “”; // stores the serialized after decoding the original viewstate and then reenncoding it (all MACs and such will be removed)
protected internal String m_viewStateXML = “”;
protected internal String m_MAC = “None”;

public ViewState(String viewStateBase64)
{
m_viewStateBase64 = viewStateBase64;
computeVersionInfo();
computeMACInfo();
m_viewStateXML = getViewStateXMLFromBase64(m_viewStateBase64);

}

public ViewState(XmlDocument viewStateXMLDocument)
{
m_version = Int32.Parse(viewStateXMLDocument.GetElementsByTagName(“Version”).Item(0).InnerText);
m_versionString = viewStateXMLDocument.GetElementsByTagName(“VersionString”).Item(0).InnerText;
m_MAC = viewStateXMLDocument.GetElementsByTagName(“MAC”).Item(0).InnerText;
if (m_MAC == “None”)
{
m_MACProtected = false;
}
else
{
m_MACProtected = true;
}
StringBuilder sb = new StringBuilder();
//XmlWriterSettings xws = new XmlWriterSettings();
//xws.Indent = false;
//XmlWriter xw = XmlWriter.Create(sb, xws);
StringWriter writer = new StringWriter(sb);
viewStateXMLDocument.Save(writer);
m_viewStateXML = sb.ToString();
m_viewStateBase64 = getViewStateBase64FromXMLTree(viewStateXMLDocument);

}

public static byte[] toByteArray(String HexString)
{

int NumberChars = HexString.Length;

byte[] bytes = new byte[NumberChars / 2];

for (int i = 0; i < NumberChars; i += 2)
{

bytes[i / 2] = Convert.ToByte(HexString.Substring(i, 2), 16);

}

return bytes;

}
protected abstract void computeMACInfo();
protected abstract String getViewStateXMLFromBase64(String viewStateBase64);
protected abstract String getViewStateBase64FromXMLTree(XmlDocument dom);
protected String getViewStateBase64WithMAC()
{
if (!m_MACProtected)
{
return m_viewStateBase64;
}
byte[] viewStateBytes = System.Convert.FromBase64String(m_viewStateBase64);
byte[] MACBytes = ViewState.toByteArray(m_MAC);
byte[] combinedBytes = new byte[viewStateBytes.Length + MACBytes.Length];
viewStateBytes.CopyTo(combinedBytes, 0);
MACBytes.CopyTo(combinedBytes, viewStateBytes.Length);
return System.Convert.ToBase64String(combinedBytes);
}

protected static object buildObjectElement(XmlNode xmlNode)
{
String type = xmlNode.Name;
if (type == "System.Web.UI.Pair")
{
Pair pair = new Pair();
pair.First = buildObjectElement((XmlNode)xmlNode.ChildNodes.Item(0));
pair.Second = buildObjectElement((XmlNode)xmlNode.ChildNodes.Item(1));
return pair;
}
else if (type == "System.Web.UI.Triplet")
{
Triplet triplet = new Triplet();
triplet.First = buildObjectElement((XmlNode)xmlNode.ChildNodes.Item(0));
triplet.Second = buildObjectElement((XmlNode)xmlNode.ChildNodes.Item(1));
triplet.Third = buildObjectElement((XmlNode)xmlNode.ChildNodes.Item(2));
return triplet;
}
else if (type == "System.Collections.ArrayList")
{
ArrayList arrayList = new ArrayList();
foreach (XmlNode innerXmlNode in xmlNode)
{
arrayList.Add(buildObjectElement(innerXmlNode));
}
return arrayList;
}
else if (type.StartsWith("System.Array-"))
{
Array array = null;
String arrayTypeString = type.Substring("System.Array-".Length);
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
Type arrayType = null;
foreach (Assembly assembly in assemblies)
{
arrayType = assembly.GetType(arrayTypeString);
if (arrayType != null)
break;
}

if (arrayType != null)
{
array = Array.CreateInstance(arrayType,xmlNode.ChildNodes.Count);
for (int i = array.GetLowerBound(0); i <= array.GetUpperBound(0); i++)
{
array.SetValue(buildObjectElement((XmlNode)xmlNode.ChildNodes.Item(i)),i);
}
}
return array;
}
else if (type == "System.Collections.Hashtable")
{
Hashtable hashTable = new Hashtable();
return hashTable; // this needs to be fixed…I don't know what the child elements are

}
else if (type == "System.Collections.Specialized.HybridDictionary")
{
HybridDictionary hybridDictionary = new HybridDictionary();
foreach (XmlNode innerXmlNode in xmlNode)
{
DictionaryEntry dictionaryEntry = (DictionaryEntry)buildObjectElement((XmlNode)innerXmlNode);
hybridDictionary.Add(dictionaryEntry.Key, dictionaryEntry.Value);
}
return hybridDictionary;
}
/*else if (type == "System.Collections.IDictionary")
{
IDictionary iDictionary = new IDictionary();
return iDictionary; // hmmm…not quite sure if we will ever see an IDicionary itself since it is an interface
}*/

else if (type == "System.Collections.DictionaryEntry")
{
DictionaryEntry dictionaryEnry = new DictionaryEntry();
dictionaryEnry.Key = buildObjectElement((XmlNode)xmlNode.ChildNodes.Item(0));
dictionaryEnry.Value = buildObjectElement((XmlNode)xmlNode.ChildNodes.Item(1));
return dictionaryEnry;
}
else if (type == "System.String")
{
// horrible hack because XML doesn't like to keep around whitespace. All empty strings in our original xml get turned into
// a newline followed by any number of spaces. We'll just regex it and return the correct empty string.
// this occurs because we are using xml:space=preserve attributes. If we don't use attributes we have issues with
// elements composed only of spaces…ugh
String pattern = @"^\r\n +$";
Match match = Regex.Match(xmlNode.InnerText, pattern, RegexOptions.Multiline);
if (match.Success)
{
return "";
}
else
{
return xmlNode.InnerText;
}
}
else if (type == "System.Web.UI.IndexedString")
{
return new IndexedString(xmlNode.InnerText);
}
else if (type == "System.Int64")
{
return Int64.Parse(xmlNode.InnerText);
}
else if (type == "System.Int32")
{
return Int32.Parse(xmlNode.InnerText);
}
else if (type == "System.Int16")
{
return Int16.Parse(xmlNode.InnerText);
}
else if (type == "System.Boolean")
{
if (xmlNode.InnerText == "True")
{
return true;
}
else
{
return false;
}
}
else if (type == "System.Drawing.Color")
{
//we use the type converter instead of instantiating a new color, as most colors are not dynamic and are pulled form teh color struct
String colorString = xmlNode.InnerText;
#if DEBUG
try
{
Color color = (Color)TypeDescriptor.GetConverter(typeof(Color)).ConvertFromString(colorString);
return color;
}
catch (Exception colorEx)
{
return new Color();

}
#else
Color color = (Color)TypeDescriptor.GetConverter(typeof(Color)).ConvertFromString(colorString);

return color;
#endif

}
else if (type == "Null" && xmlNode.InnerText == "True")
{
return null;
}
// we try to do a best guess for unknown types using reflection
else
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
Type realType = null;
foreach (Assembly assembly in assemblies)
{
realType = assembly.GetType(type);
if (realType != null)
break;
}
object[] args = new object[1];
args[0] = xmlNode.InnerText;

// Change being

//if (Utils.InheritFrom(realType, typeof(System.Enum)))
//{
if (realType.IsSubclassOf(typeof(System.Enum)))
{
return Enum.Parse(realType, xmlNode.InnerText);
}
else
{

#if DEBUG
try
{
return System.Activator.CreateInstance(realType, args);
}
catch (Exception ex)
{

return null;
}
}
#else
return System.Activator.CreateInstance(realType, args);
#endif
}

}

public virtual String viewStateXML
{
get
{
return m_viewStateXML;
}

}
public String viewStateBase64
{
get
{
return getViewStateBase64WithMAC();
}
}

public String MAC
{
get
{
return m_MAC;
}
}

public bool MACProected
{
get
{
return m_MACProtected;
}
}
public int version
{
get
{
return m_version;
}
}

public String versionString
{
get
{
return m_versionString;
}
}
public bool encrypted
{
get
{
return m_encrypted;
}
}

protected void computeVersionInfo()
{
if (m_viewStateBase64 == null)
{
return;
}

m_version = getViewStateVersionFromBase64String(m_viewStateBase64);
switch (m_version)
{
case 2:
m_versionString = "ASP.Net 2.X";
m_encrypted = false;
break;
case 1:
m_versionString = "ASP.Net 1.X";
m_encrypted = false;
break;
default:
m_versionString = "Unknown";
m_encrypted = true; //this isn't guranteed…but we'll assume it is true for now
break;
}

return;
}

public static ViewState newViewStateFromBase64String(String viewStateString)
{
ViewState viewState = null;
int viewStateVersion = getViewStateVersionFromBase64String(viewStateString);
switch (viewStateVersion)
{
case 1:
viewState = new ViewState_Dot_Net_1_0(viewStateString);
break;
case 2:
viewState = new ViewState_Dot_Net_2_0(viewStateString);
break;
default:
viewState = null;
break;

}
return viewState;
}

public static ViewState newViewStateFromXMLString(String viewStateXML)
{
ViewState viewState = null;
int viewStateVersion = 0;
String versionPattern = @"(.+)”;
Match match = Regex.Match(viewStateXML, versionPattern, RegexOptions.Singleline);
if (match.Success)
{
viewStateVersion = Int32.Parse(match.Groups[1].Value);
}
// if this is viewstate version 1 we need to patch a few things up
if (viewStateVersion == 1)
{
String viewStatePattern = @”(.+)”;
match = Regex.Match(viewStateXML, viewStatePattern, RegexOptions.Singleline);
if (match.Success)
{
viewStateXML = viewStateXML.Replace(match.Groups[1].Value, HttpUtility.HtmlEncode(match.Groups[1].Value));
}

}

// horrible horrible hack to account for RichTextBox removing CRLF with a LF…anyone have a better idea???
viewStateXML = viewStateXML.Replace(“\n”, “\r\n”);

XmlDocument dom = new XmlDocument();

StringReader reader = new StringReader(viewStateXML);
//dom.PreserveWhitespace = true;
dom.Load(reader);
switch (viewStateVersion)
{
case 1:
viewState = new ViewState_Dot_Net_1_0(dom);
break;
case 2:
viewState = new ViewState_Dot_Net_2_0(dom);
break;
default:
viewState = null;
break;

}
return viewState;
}

public static Int32 getViewStateVersionFromBase64String(String viewStateBase64)
{
byte[] viewStateBytes;
try
{
viewStateBytes = System.Convert.FromBase64String(viewStateBase64);
}
catch (System.ArgumentNullException)
{
return 0;
}
if (viewStateBytes.Length >= 2 &&
viewStateBytes[0] == ‘\xff’ &&
viewStateBytes[1] == ‘\x01′)
{
return 2;
}
else if (viewStateBytes.Length >= 2 &&
viewStateBytes[0] == ‘t’ &&
viewStateBytes[1] == ‘<')
{
return 1;
}
else
{
return 0;
}
}

}
}

Nice work.

I am facing some issues with this plugin. It smoothly deserializes the viewstate but when i try to r-serialize it, even without making a change, it throws an error: “cannot encode malformed xml”. This is regardless of making any changes to the xml in lower half of plugin window.

Kindly help.

/sauby