So dekodieren Sie den Ansichtszustand
https://stackoverflow.com/questions/22814
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Ich muss den Inhalt des Ansichtsstatus einer asp.net-Seite sehen.Ich habe nach einem Viewstate-Decoder gesucht, gefunden Der ViewState-Decoder von Fridz Onion aber es fragt nach der URL einer Seite, um ihren Ansichtsstatus zu erhalten.Da mein Ansichtszustand nach einem Postback gebildet wird und das Ergebnis eines Vorgangs in einem Update-Panel ist, kann ich keine URL angeben.Ich muss die Viewstate-Zeichenfolge kopieren und einfügen und sehen, was darin enthalten ist.Gibt es ein Tool oder eine Website, die beim Anzeigen des Viewstate-Inhalts helfen kann?
Lösung
Verwenden Geiger Nehmen Sie den Ansichtsstatus in der Antwort, fügen Sie ihn in das Textfeld unten links ein und dekodieren Sie ihn.
Andere Tipps
Hier ist ein Online-ViewState-Decoder:
http://ignatu.co.uk/ViewStateDecoder.aspx
Bearbeiten: Leider ist der obige Link tot – hier ist ein weiterer ViewState-Decoder (aus den Kommentaren):
Hier ist der Quellcode für einen ViewState-Visualizer von Scott Mitchells Artikel auf ViewState (25 Seiten)
using System;
using System.Collections;
using System.Text;
using System.IO;
using System.Web.UI;
namespace ViewStateArticle.ExtendedPageClasses
{
/// <summary>
/// Parses the view state, constructing a viaully-accessible object graph.
/// </summary>
public class ViewStateParser
{
// private member variables
private TextWriter tw;
private string indentString = " ";
#region Constructor
/// <summary>
/// Creates a new ViewStateParser instance, specifying the TextWriter to emit the output to.
/// </summary>
public ViewStateParser(TextWriter writer)
{
tw = writer;
}
#endregion
#region Methods
#region ParseViewStateGraph Methods
/// <summary>
/// Emits a readable version of the view state to the TextWriter passed into the object's constructor.
/// </summary>
/// <param name="viewState">The view state object to start parsing at.</param>
public virtual void ParseViewStateGraph(object viewState)
{
ParseViewStateGraph(viewState, 0, string.Empty);
}
/// <summary>
/// Emits a readable version of the view state to the TextWriter passed into the object's constructor.
/// </summary>
/// <param name="viewStateAsString">A base-64 encoded representation of the view state to parse.</param>
public virtual void ParseViewStateGraph(string viewStateAsString)
{
// First, deserialize the string into a Triplet
LosFormatter los = new LosFormatter();
object viewState = los.Deserialize(viewStateAsString);
ParseViewStateGraph(viewState, 0, string.Empty);
}
/// <summary>
/// Recursively parses the view state.
/// </summary>
/// <param name="node">The current view state node.</param>
/// <param name="depth">The "depth" of the view state tree.</param>
/// <param name="label">A label to display in the emitted output next to the current node.</param>
protected virtual void ParseViewStateGraph(object node, int depth, string label)
{
tw.Write(System.Environment.NewLine);
if (node == null)
{
tw.Write(String.Concat(Indent(depth), label, "NODE IS NULL"));
}
else if (node is Triplet)
{
tw.Write(String.Concat(Indent(depth), label, "TRIPLET"));
ParseViewStateGraph(((Triplet) node).First, depth+1, "First: ");
ParseViewStateGraph(((Triplet) node).Second, depth+1, "Second: ");
ParseViewStateGraph(((Triplet) node).Third, depth+1, "Third: ");
}
else if (node is Pair)
{
tw.Write(String.Concat(Indent(depth), label, "PAIR"));
ParseViewStateGraph(((Pair) node).First, depth+1, "First: ");
ParseViewStateGraph(((Pair) node).Second, depth+1, "Second: ");
}
else if (node is ArrayList)
{
tw.Write(String.Concat(Indent(depth), label, "ARRAYLIST"));
// display array values
for (int i = 0; i < ((ArrayList) node).Count; i++)
ParseViewStateGraph(((ArrayList) node)[i], depth+1, String.Format("({0}) ", i));
}
else if (node.GetType().IsArray)
{
tw.Write(String.Concat(Indent(depth), label, "ARRAY "));
tw.Write(String.Concat("(", node.GetType().ToString(), ")"));
IEnumerator e = ((Array) node).GetEnumerator();
int count = 0;
while (e.MoveNext())
ParseViewStateGraph(e.Current, depth+1, String.Format("({0}) ", count++));
}
else if (node.GetType().IsPrimitive || node is string)
{
tw.Write(String.Concat(Indent(depth), label));
tw.Write(node.ToString() + " (" + node.GetType().ToString() + ")");
}
else
{
tw.Write(String.Concat(Indent(depth), label, "OTHER - "));
tw.Write(node.GetType().ToString());
}
}
#endregion
/// <summary>
/// Returns a string containing the <see cref="IndentString"/> property value a specified number of times.
/// </summary>
/// <param name="depth">The number of times to repeat the <see cref="IndentString"/> property.</param>
/// <returns>A string containing the <see cref="IndentString"/> property value a specified number of times.</returns>
protected virtual string Indent(int depth)
{
StringBuilder sb = new StringBuilder(IndentString.Length * depth);
for (int i = 0; i < depth; i++)
sb.Append(IndentString);
return sb.ToString();
}
#endregion
#region Properties
/// <summary>
/// Specifies the indentation to use for each level when displaying the object graph.
/// </summary>
/// <value>A string value; the default is three blank spaces.</value>
public string IndentString
{
get
{
return indentString;
}
set
{
indentString = value;
}
}
#endregion
}
}
Und hier ist eine einfache Seite, um den Ansichtszustand aus einem Textfeld zu lesen und ihn mit dem obigen Code grafisch darzustellen
private void btnParse_Click(object sender, System.EventArgs e)
{
// parse the viewState
StringWriter writer = new StringWriter();
ViewStateParser p = new ViewStateParser(writer);
p.ParseViewStateGraph(txtViewState.Text);
ltlViewState.Text = writer.ToString();
}
Wie eine andere Person gerade erwähnt hat, handelt es sich um eine Base64-codierte Zeichenfolge.In der Vergangenheit habe ich diese Website verwendet, um es zu entschlüsseln:
Hier ist ein weiterer Decoder, der seit 2014 gut funktioniert: http://viewstatedecoder.azurewebsites.net/
Dies funktionierte bei einer Eingabe, bei der der Ignatu-Decoder mit „Die serialisierten Daten sind ungültig“ fehlschlug (obwohl die mit BinaryFormatter serialisierten Daten nicht dekodiert blieben und nur ihre Länge angezeigt wurden).
JavaScript-ViewState-Parser:
- http://mutantzombie.github.com/JavaScript-ViewState-Parser/
- https://github.com/mutantzombie/JavaScript-ViewState-Parser/
Der Parser sollte mit den meisten unverschlüsselten ViewStates funktionieren.Es handelt sich nicht um das von .NET Version 1 verwendete Serialisierungsformat, da diese Version sehr veraltet ist und daher zu unwahrscheinlich ist, dass sie in einer wirklichen Situation auftritt.
http://deadliestwebattacks.com/2011/05/29/javascript-viewstate-parser/
Parsen von .NET ViewState
Ein spannender Einblick in ViewState, Teil I:
http://deadliestwebattacks.com/2011/05/13/a-spirited-peek-into-viewstate-part-i/
Ein spannender Einblick in ViewState, Teil II:
http://deadliestwebattacks.com/2011/05/25/a-spirited-peek-into-viewstate-part-ii/
Sie können das URL-Feld ignorieren und den Ansichtszustand einfach in das Zeichenfolgenfeld „Ansichtszustand“ einfügen.
Es sieht so aus, als hätten Sie eine alte Version;Die Serialisierungsmethoden haben sich in ASP.NET 2.0 geändert, also greifen Sie zu 2.0-Version
Dies ist etwas "natives" .NET -Weg, um ViewState von String in den StateBag -Code zu konvertieren, ist unten:
public static StateBag LoadViewState(string viewState)
{
System.Web.UI.Page converterPage = new System.Web.UI.Page();
HiddenFieldPageStatePersister persister = new HiddenFieldPageStatePersister(new Page());
Type utilClass = typeof(System.Web.UI.BaseParser).Assembly.GetType("System.Web.UI.Util");
if (utilClass != null && persister != null)
{
MethodInfo method = utilClass.GetMethod("DeserializeWithAssert", BindingFlags.NonPublic | BindingFlags.Static);
if (method != null)
{
PropertyInfo formatterProperty = persister.GetType().GetProperty("StateFormatter", BindingFlags.NonPublic | BindingFlags.Instance);
if (formatterProperty != null)
{
IStateFormatter formatter = (IStateFormatter)formatterProperty.GetValue(persister, null);
if (formatter != null)
{
FieldInfo pageField = formatter.GetType().GetField("_page", BindingFlags.NonPublic | BindingFlags.Instance);
if (pageField != null)
{
pageField.SetValue(formatter, null);
try
{
Pair pair = (Pair)method.Invoke(null, new object[] { formatter, viewState });
if (pair != null)
{
MethodInfo loadViewState = converterPage.GetType().GetMethod("LoadViewStateRecursive", BindingFlags.Instance | BindingFlags.NonPublic);
if (loadViewState != null)
{
FieldInfo postback = converterPage.GetType().GetField("_isCrossPagePostBack", BindingFlags.NonPublic | BindingFlags.Instance);
if (postback != null)
{
postback.SetValue(converterPage, true);
}
FieldInfo namevalue = converterPage.GetType().GetField("_requestValueCollection", BindingFlags.NonPublic | BindingFlags.Instance);
if (namevalue != null)
{
namevalue.SetValue(converterPage, new NameValueCollection());
}
loadViewState.Invoke(converterPage, new object[] { ((Pair)((Pair)pair.First).Second) });
FieldInfo viewStateField = typeof(Control).GetField("_viewState", BindingFlags.NonPublic | BindingFlags.Instance);
if (viewStateField != null)
{
return (StateBag)viewStateField.GetValue(converterPage);
}
}
}
}
catch (Exception ex)
{
if (ex != null)
{
}
}
}
}
}
}
}
return null;
}
Online Viewstate Viewer von Lachlan Keown:
http://lachlankeown.blogspot.com/2008/05/online-viewstate-viewer-decoder.html
Normalerweise sollte ViewState entschlüsselbar sein, wenn Sie den Maschinenschlüssel haben, oder?Schließlich muss ASP.net es entschlüsseln, und das ist sicherlich keine Black Box.
