y4er/weblogic-shiro-shellWebLogic nutzt CVE-2020-2883 aus, um die Shiro rememberMe-Deserialisierungslücke zu exploitieren und mit einem Klick eine AntSword-Filter-In-Memory-Shell zu registrieren.
Dieser Beitrag behandelt die folgenden Punkte:
Java-Serialisierung bezeichnet den Prozess der Umwandlung von Java-Objekten in eine Byte-Sequenz, um sie im Speicher, in Dateien oder in Datenbanken zu speichern. Die Methode writeObject() der Klasse ObjectOutputStream kann die Serialisierung durchführen und Java-Objekte in eine Byte-Sequenz umwandeln.
Java-Deserialisierung bezeichnet den Prozess der Wiederherstellung von Java-Objekten aus einer Byte-Sequenz. Die Methode readObject() der Klasse ObjectInputStream wird für die Deserialisierung verwendet.
Ein einfaches Beispiel: siehe Code SerializeAndDeserialize Hinweis: Achten Sie besonders auf die Typumwandlungen im Code```java
package org.chabug.demo;
import org.chabug.entity.Dog; import org.chabug.entity.Person; import org.chabug.util.Serializables;
/* 这个例子是为了证明只要实现了Serializable接口的类都可以被序列化 并且Java内置的几大数据类型也可被序列化，因为他们都继承了Object类 */
public class SerializeAndDeserialize {
public static void main(String[] args) throws Exception {
byte[] bytes;
String s1 = "I'm a String Object....";
bytes = Serializables.serializeToBytes(s1);
Object o1 = Serializables.deserializeFromBytes(bytes);
System.out.println(o1);
String[] s2 = new String[]{"tom", "bob", "jack"};
bytes = Serializables.serializeToBytes(s2);
String[] o2 = (String[])Serializables.deserializeFromBytes(bytes);
System.out.println(o2);
int i = 123;
bytes = Serializables.serializeToBytes(i);
int o3 = (Integer) Serializables.deserializeFromBytes(bytes);
System.out.println(o3);
// 一只名叫woody的狗
Dog dog = new Dog();
dog.setName("woody");
// tom
Person tom = new Person();
tom.setAge(14);
tom.setName("tom");
tom.setSex("男");
tom.setDog(dog);
bytes = Serializables.serializeToBytes(tom);
Person o = (Person) Serializables.deserializeFromBytes(bytes);
System.out.println(o);
}
}
String、Integer、Array、Object-Objekte und andere in Java eingebaute Datentypen können serialisiert werden. Unsere eigenen Klassen wie Person und Dog können serialisiert und deserialisiert werden, solange sie das Serializable-Interface implementieren.
## Warum entstehen Schwachstellen bei der Deserialisierung?
Sehen wir uns einen Code an: Es gibt jetzt eine bösartige Entity-Klasse EvilClass.```java
package org.chabug.entity;
import java.io.ObjectInputStream;
import java.io.Serializable;
public class EvilClass implements Serializable {
String name;
public EvilClass() {
System.out.println(this.getClass() + "的EvilClass()构造方法被调用!!!!!!");
}
public EvilClass(String name) {
System.out.println(this.getClass() + "的EvilClass(String name)构造方法被调用!!!!!!");
this.name = name;
}
public String getName() {
System.out.println(this.getClass() + "的getName被调用!!!!!!");
return name;
}
public void setName(String name) {
System.out.println(this.getClass() + "的setName被调用!!!!!!");
this.name = name;
}
@Override
public String toString() {
System.out.println(this.getClass() + "的toString()被调用!!!!!!");
return "EvilClass{" +
"name='" + getName() + '\'' +
'}';
}
private void readObject(ObjectInputStream in) throws Exception {
//执行默认的readObject()方法
in.defaultReadObject();
System.out.println(this.getClass() + "readObject()被调用!!!!!!");
Runtime.getRuntime().exec(new String[]{"cmd", "/c", name});
}
}
In seinem readObject gibt es Code, der einen Befehl ausführt: Runtime.getRuntime().exec(new String[]{"cmd", "/c", name}), der Parameter name ist der auszuführende Befehl. Also können wir ein bösartiges Objekt konstruieren, dessen name-Attribut auf den auszuführenden Befehl gesetzt wird. Wenn die Deserialisierung readObject auslöst, kommt es zur RCE. Wie folgt```java
package org.chabug.demo;
import org.chabug.entity.EvilClass; import org.chabug.util.Serializables;
public class EvilSerialize { public static void main(String[] args) throws Exception { EvilClass evilObj = new EvilClass(); evilObj.setName("calc"); byte[] bytes = Serializables.serializeToBytes(evilObj); EvilClass o = (EvilClass) Serializables.deserializeFromBytes(bytes); System.out.println(o); } }
Jetzt wissen wir also, wie Deserialisierung zu RCE führen kann, aber in der Entwicklung wird man es nicht direkt so schreiben, daher geht es um die Suche nach der Nutzungskette. Eine Deserialisierungsschwachstelle benötigt drei Dinge:
1. Einstiegspunkt der Deserialisierung (source)
2. Zielmethode (sink)
3. Nutzungskette (gadget chain)
Wenn man die Ausgabe im obigen Bild genau betrachtet, wird nicht nur die readObject-Methode ausgelöst, sondern auch toString(), der parameterlose Konstruktor, set- und get-Methoden. Bei der tatsächlichen Suche nach einer Nutzungskette muss man sich daher nicht nur auf die readObject()-Methode konzentrieren.
An diesem Punkt müssen wir das Konzept der **Reflexion** verstehen. Oben haben wir das Problem der **Zwangstypkonvertierung** erwähnt. In der realen Entwicklung wird in readObject eine logische Verarbeitung durchgeführt. Wenn der konkrete Datentyp des übergebenen Objekts nicht bekannt ist, wird durch Reflexion entschieden und aufgerufen. Reflexion ist ein wichtiges Mittel zur Erreichung von RCE.
## Java-Reflexion
Was ist Reflexion? Das Wort „Reflexion“ enthält das Zeichen „反“ (entgegen/umgekehrt). Um Reflexion zu erklären, müssen wir mit dem **normalen Aufruf** beginnen. Schauen wir uns den Code an. Dies ist meine Entitätsklasse.```java
package org.chabug.entity;
import java.io.IOException;
public class ReflectionClass {
String name;
public ReflectionClass(String name) {
this.name = name;
}
public ReflectionClass() {
}
public String say() {
return this.name;
}
private void evil(String cmd) {
try {
Runtime.getRuntime().exec(new String[]{"cmd","/c",cmd});
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public String toString() {
return "ReflectionClass{" +
"name='" + name + '\'' +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Normale Schreibweise```java package org.chabug.demo;
import org.chabug.entity.ReflectionClass;
public class ReflectionDemo { public static void main(String[] args) { ReflectionClass demo = new ReflectionClass(); demo.setName("hello"); System.out.println(demo.say()); // demo.evil("calc"); // 不能够调用private方法 } }
很简单就是通过new创建了一个ReflectionClass实例，然后通过实例去调用其所属方法，这就是"正射"。但是当你new的时候不知道类名怎么办？受private保护的方法怎么调用？反射的作用就体现出来了。看下面这一段代码