यूसी ब्राउज़र में कमजोरियों की तलाश

परिचय

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

कुछ समय पहले, यूसी ब्राउज़र को बहुत आक्रामक तरीके से विज्ञापित और वितरित किया गया था: यह मैलवेयर का उपयोग करके उपयोगकर्ताओं के उपकरणों पर स्थापित किया गया था, वीडियो फ़ाइलों की आड़ में विभिन्न साइटों से वितरित किया गया था (यानी, उपयोगकर्ताओं को लगा कि वे डाउनलोड कर रहे थे, उदाहरण के लिए, एक अश्लील वीडियो, लेकिन इसके बजाय इस ब्राउज़र के साथ एक एपीके प्राप्त हुआ), उन संदेशों के साथ डरावने बैनर का उपयोग किया गया कि ब्राउज़र पुराना, असुरक्षित और इसी तरह की चीजें थीं। वीके पर आधिकारिक यूसी ब्राउज़र समूह में है विषय, जिसमें उपयोगकर्ता अनुचित विज्ञापन के बारे में शिकायत कर सकते हैं, ऐसे कई उदाहरण हैं। 2016 में भी हुआ था वीडियो विज्ञापन रूसी में (हाँ, विज्ञापन-अवरोधक ब्राउज़र के लिए विज्ञापन)।

लेखन के समय, यूसी ब्राउज़र के Google Play पर 500 से अधिक इंस्टॉलेशन हैं। यह प्रभावशाली है - केवल Google Chrome में ही अधिक है। समीक्षाओं के बीच आप Google Play पर कुछ एप्लिकेशन पर विज्ञापन और रीडायरेक्ट के बारे में बहुत सारी शिकायतें देख सकते हैं। यही हमारे शोध का कारण था: हमने यह देखने का निर्णय लिया कि क्या यूसी ब्राउज़र कुछ बुरा कर रहा है। और यह पता चला कि वह ऐसा करता है!

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

नीचे लिखी हर बात यूसी ब्राउज़र के उस संस्करण के लिए प्रासंगिक है जो अध्ययन के समय Google Play पर उपलब्ध था:

package: com.UCMobile.intl
versionName: 12.10.8.1172
versionCode: 10598
sha1 APK-файла: f5edb2243413c777172f6362876041eb0c3a928c

आक्रमण सदिश

यूसी ब्राउज़र मेनिफेस्ट में आप स्व-व्याख्यात्मक नाम वाली एक सेवा पा सकते हैं com.uc.deployment.UpgradeDeployService.

    <service android_exported="false" android_name="com.uc.deployment.UpgradeDeployService" android_process=":deploy" />

जब यह सेवा प्रारंभ होती है, तो ब्राउज़र एक POST अनुरोध करता है puds.ucweb.com/upgrade/index.xhtmlजिसे शुरू होने के कुछ समय बाद ट्रैफिक में देखा जा सकता है। जवाब में, उसे कुछ अपडेट या नया मॉड्यूल डाउनलोड करने का आदेश प्राप्त हो सकता है। विश्लेषण के दौरान, सर्वर ने ऐसे आदेश नहीं दिए, लेकिन हमने देखा कि जब हम ब्राउज़र में पीडीएफ खोलने का प्रयास करते हैं, तो यह ऊपर निर्दिष्ट पते पर दूसरा अनुरोध करता है, जिसके बाद यह मूल लाइब्रेरी डाउनलोड करता है। हमले को अंजाम देने के लिए, हमने यूसी ब्राउज़र की इस सुविधा का उपयोग करने का निर्णय लिया: मूल लाइब्रेरी का उपयोग करके पीडीएफ खोलने की क्षमता, जो एपीके में नहीं है और यदि आवश्यक हो तो इसे इंटरनेट से डाउनलोड किया जाता है। यह ध्यान देने योग्य है कि, सैद्धांतिक रूप से, यूसी ब्राउज़र को उपयोगकर्ता इंटरैक्शन के बिना कुछ डाउनलोड करने के लिए मजबूर किया जा सकता है - यदि आप ब्राउज़र लॉन्च होने के बाद निष्पादित अनुरोध के लिए एक अच्छी तरह से गठित प्रतिक्रिया प्रदान करते हैं। लेकिन ऐसा करने के लिए, हमें सर्वर के साथ इंटरैक्शन के प्रोटोकॉल का अधिक विस्तार से अध्ययन करने की आवश्यकता है, इसलिए हमने निर्णय लिया कि इंटरसेप्टेड प्रतिक्रिया को संपादित करना और पीडीएफ के साथ काम करने के लिए लाइब्रेरी को बदलना आसान होगा।

इसलिए, जब कोई उपयोगकर्ता सीधे ब्राउज़र में पीडीएफ खोलना चाहता है, तो ट्रैफ़िक में निम्नलिखित अनुरोध देखे जा सकते हैं:

सबसे पहले एक POST अनुरोध है puds.ucweb.com/upgrade/index.xhtmlजिसके बाद
पीडीएफ और कार्यालय प्रारूप देखने के लिए लाइब्रेरी वाला एक संग्रह डाउनलोड किया गया है। यह मानना ​​तर्कसंगत है कि पहला अनुरोध सिस्टम के बारे में जानकारी प्रसारित करता है (कम से कम आवश्यक लाइब्रेरी प्रदान करने के लिए आर्किटेक्चर), और इसके जवाब में ब्राउज़र को लाइब्रेरी के बारे में कुछ जानकारी प्राप्त होती है जिसे डाउनलोड करने की आवश्यकता होती है: पता और, संभवतः , कुछ और। समस्या यह है कि यह अनुरोध एन्क्रिप्टेड है.

खंड का अनुरोध करें

उत्तर खंड

लाइब्रेरी स्वयं ज़िप में पैक की गई है और एन्क्रिप्टेड नहीं है।

ट्रैफ़िक डिक्रिप्शन कोड खोजें

आइए सर्वर प्रतिक्रिया को समझने का प्रयास करें। आइए क्लास कोड देखें com.uc.deployment.UpgradeDeployService: विधि से ऑनस्टार्टकमांड जाओ com.uc.deployment.bx, और इससे तक com.uc.browser.core.dcfe:

    public final void e(l arg9) {
int v4_5;
String v3_1;
byte[] v3;
byte[] v1 = null;
if(arg9 == null) {
v3 = v1;
}
else {
v3_1 = arg9.iGX.ipR;
StringBuilder v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]product:");
v4.append(arg9.iGX.ipR);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]version:");
v4.append(arg9.iGX.iEn);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]upgrade_type:");
v4.append(arg9.iGX.mMode);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]force_flag:");
v4.append(arg9.iGX.iEo);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]silent_mode:");
v4.append(arg9.iGX.iDQ);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]silent_type:");
v4.append(arg9.iGX.iEr);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]silent_state:");
v4.append(arg9.iGX.iEp);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]silent_file:");
v4.append(arg9.iGX.iEq);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apk_md5:");
v4.append(arg9.iGX.iEl);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]download_type:");
v4.append(arg9.mDownloadType);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]download_group:");
v4.append(arg9.mDownloadGroup);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]download_path:");
v4.append(arg9.iGH);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_child_version:");
v4.append(arg9.iGX.iEx);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_series:");
v4.append(arg9.iGX.iEw);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_cpu_arch:");
v4.append(arg9.iGX.iEt);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_cpu_vfp3:");
v4.append(arg9.iGX.iEv);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_cpu_vfp:");
v4.append(arg9.iGX.iEu);
ArrayList v3_2 = arg9.iGX.iEz;
if(v3_2 != null && v3_2.size() != 0) {
Iterator v3_3 = v3_2.iterator();
while(v3_3.hasNext()) {
Object v4_1 = v3_3.next();
StringBuilder v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]component_name:");
v5.append(((au)v4_1).getName());
v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]component_ver_name:");
v5.append(((au)v4_1).aDA());
v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]component_ver_code:");
v5.append(((au)v4_1).gBl);
v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]component_req_type:");
v5.append(((au)v4_1).gBq);
}
}
j v3_4 = new j();
m.b(v3_4);
h v4_2 = new h();
m.b(v4_2);
ay v5_1 = new ay();
v3_4.hS("");
v3_4.setImsi("");
v3_4.hV("");
v5_1.bPQ = v3_4;
v5_1.bPP = v4_2;
v5_1.yr(arg9.iGX.ipR);
v5_1.gBF = arg9.iGX.mMode;
v5_1.gBI = arg9.iGX.iEz;
v3_2 = v5_1.gAr;
c.aBh();
v3_2.add(g.fs("os_ver", c.getRomInfo()));
v3_2.add(g.fs("processor_arch", com.uc.b.a.a.c.getCpuArch()));
v3_2.add(g.fs("cpu_arch", com.uc.b.a.a.c.Pb()));
String v4_3 = com.uc.b.a.a.c.Pd();
v3_2.add(g.fs("cpu_vfp", v4_3));
v3_2.add(g.fs("net_type", String.valueOf(com.uc.base.system.a.Jo())));
v3_2.add(g.fs("fromhost", arg9.iGX.iEm));
v3_2.add(g.fs("plugin_ver", arg9.iGX.iEn));
v3_2.add(g.fs("target_lang", arg9.iGX.iEs));
v3_2.add(g.fs("vitamio_cpu_arch", arg9.iGX.iEt));
v3_2.add(g.fs("vitamio_vfp", arg9.iGX.iEu));
v3_2.add(g.fs("vitamio_vfp3", arg9.iGX.iEv));
v3_2.add(g.fs("plugin_child_ver", arg9.iGX.iEx));
v3_2.add(g.fs("ver_series", arg9.iGX.iEw));
v3_2.add(g.fs("child_ver", r.aVw()));
v3_2.add(g.fs("cur_ver_md5", arg9.iGX.iEl));
v3_2.add(g.fs("cur_ver_signature", SystemHelper.getUCMSignature()));
v3_2.add(g.fs("upgrade_log", i.bjt()));
v3_2.add(g.fs("silent_install", String.valueOf(arg9.iGX.iDQ)));
v3_2.add(g.fs("silent_state", String.valueOf(arg9.iGX.iEp)));
v3_2.add(g.fs("silent_file", arg9.iGX.iEq));
v3_2.add(g.fs("silent_type", String.valueOf(arg9.iGX.iEr)));
v3_2.add(g.fs("cpu_archit", com.uc.b.a.a.c.Pc()));
v3_2.add(g.fs("cpu_set", SystemHelper.getCpuInstruction()));
boolean v4_4 = v4_3 == null || !v4_3.contains("neon") ? false : true;
v3_2.add(g.fs("neon", String.valueOf(v4_4)));
v3_2.add(g.fs("cpu_cores", String.valueOf(com.uc.b.a.a.c.Jl())));
v3_2.add(g.fs("ram_1", String.valueOf(com.uc.b.a.a.h.Po())));
v3_2.add(g.fs("totalram", String.valueOf(com.uc.b.a.a.h.OL())));
c.aBh();
v3_2.add(g.fs("rom_1", c.getRomInfo()));
v4_5 = e.getScreenWidth();
int v6 = e.getScreenHeight();
StringBuilder v7 = new StringBuilder();
v7.append(v4_5);
v7.append("*");
v7.append(v6);
v3_2.add(g.fs("ss", v7.toString()));
v3_2.add(g.fs("api_level", String.valueOf(Build$VERSION.SDK_INT)));
v3_2.add(g.fs("uc_apk_list", SystemHelper.getUCMobileApks()));
Iterator v4_6 = arg9.iGX.iEA.entrySet().iterator();
while(v4_6.hasNext()) {
Object v6_1 = v4_6.next();
v3_2.add(g.fs(((Map$Entry)v6_1).getKey(), ((Map$Entry)v6_1).getValue()));
}
v3 = v5_1.toByteArray();
}
if(v3 == null) {
this.iGY.iGI.a(arg9, "up_encode", "yes", "fail");
return;
}
v4_5 = this.iGY.iGw ? 0x1F : 0;
if(v3 == null) {
}
else {
v3 = g.i(v4_5, v3);
if(v3 == null) {
}
else {
v1 = new byte[v3.length + 16];
byte[] v6_2 = new byte[16];
Arrays.fill(v6_2, 0);
v6_2[0] = 0x5F;
v6_2[1] = 0;
v6_2[2] = ((byte)v4_5);
v6_2[3] = -50;
System.arraycopy(v6_2, 0, v1, 0, 16);
System.arraycopy(v3, 0, v1, 16, v3.length);
}
}
if(v1 == null) {
this.iGY.iGI.a(arg9, "up_encrypt", "yes", "fail");
return;
}
if(TextUtils.isEmpty(this.iGY.mUpgradeUrl)) {
this.iGY.iGI.a(arg9, "up_url", "yes", "fail");
return;
}
StringBuilder v0 = new StringBuilder("[");
v0.append(arg9.iGX.ipR);
v0.append("]url:");
v0.append(this.iGY.mUpgradeUrl);
com.uc.browser.core.d.c.i v0_1 = this.iGY.iGI;
v3_1 = this.iGY.mUpgradeUrl;
com.uc.base.net.e v0_2 = new com.uc.base.net.e(new com.uc.browser.core.d.c.i$a(v0_1, arg9));
v3_1 = v3_1.contains("?") ? v3_1 + "&dataver=pb" : v3_1 + "?dataver=pb";
n v3_5 = v0_2.uc(v3_1);
m.b(v3_5, false);
v3_5.setMethod("POST");
v3_5.setBodyProvider(v1);
v0_2.b(v3_5);
this.iGY.iGI.a(arg9, "up_null", "yes", "success");
this.iGY.iGI.b(arg9);
}

हम यहां एक POST अनुरोध का गठन देखते हैं। हम 16 बाइट्स की एक सरणी बनाने और उसे भरने पर ध्यान देते हैं: 0x5F, 0, 0x1F, -50 (=0xCE)। उपरोक्त अनुरोध में हमने जो देखा, उससे मेल खाता है।

उसी क्लास में आप एक नेस्टेड क्लास देख सकते हैं जिसमें एक और दिलचस्प तरीका है:

        public final void a(l arg10, byte[] arg11) {
f v0 = this.iGQ;
StringBuilder v1 = new StringBuilder("[");
v1.append(arg10.iGX.ipR);
v1.append("]:UpgradeSuccess");
byte[] v1_1 = null;
if(arg11 == null) {
}
else if(arg11.length < 16) {
}
else {
if(arg11[0] != 0x60 && arg11[3] != 0xFFFFFFD0) {
goto label_57;
}
int v3 = 1;
int v5 = arg11[1] == 1 ? 1 : 0;
if(arg11[2] != 1 && arg11[2] != 11) {
if(arg11[2] == 0x1F) {
}
else {
v3 = 0;
}
}
byte[] v7 = new byte[arg11.length - 16];
System.arraycopy(arg11, 16, v7, 0, v7.length);
if(v3 != 0) {
v7 = g.j(arg11[2], v7);
}
if(v7 == null) {
goto label_57;
}
if(v5 != 0) {
v1_1 = g.P(v7);
goto label_57;
}
v1_1 = v7;
}
label_57:
if(v1_1 == null) {
v0.iGY.iGI.a(arg10, "up_decrypt", "yes", "fail");
return;
}
q v11 = g.b(arg10, v1_1);
if(v11 == null) {
v0.iGY.iGI.a(arg10, "up_decode", "yes", "fail");
return;
}
if(v0.iGY.iGt) {
v0.d(arg10);
}
if(v0.iGY.iGo != null) {
v0.iGY.iGo.a(0, ((o)v11));
}
if(v0.iGY.iGs) {
v0.iGY.a(((o)v11));
v0.iGY.iGI.a(v11, "up_silent", "yes", "success");
v0.iGY.iGI.a(v11);
return;
}
v0.iGY.iGI.a(v11, "up_silent", "no", "success");
}
}

विधि इनपुट के रूप में बाइट्स की एक सरणी लेती है और जांच करती है कि शून्य बाइट 0x60 है या तीसरी बाइट 0xD0 है, और दूसरी बाइट 1, 11 या 0x1F है। हम सर्वर से प्रतिक्रिया को देखते हैं: शून्य बाइट 0x60 है, दूसरा 0x1F है, तीसरा 0x60 है। ऐसा लगता है जैसे हमें इसकी आवश्यकता है। पंक्तियों (उदाहरण के लिए "up_decrypt") को देखते हुए, यहां एक विधि को कॉल किया जाना चाहिए जो सर्वर की प्रतिक्रिया को डिक्रिप्ट करेगा।
चलिए विधि पर आगे बढ़ते हैं जी जे. ध्यान दें कि पहला तर्क ऑफसेट 2 पर बाइट है (यानी हमारे मामले में 0x1F), और दूसरा बिना सर्वर प्रतिक्रिया है
पहले 16 बाइट्स.

     public static byte[] j(int arg1, byte[] arg2) {
if(arg1 == 1) {
arg2 = c.c(arg2, c.adu);
}
else if(arg1 == 11) {
arg2 = m.aF(arg2);
}
else if(arg1 != 0x1F) {
}
else {
arg2 = EncryptHelper.decrypt(arg2);
}
return arg2;
}

जाहिर है, यहां हम एक डिक्रिप्शन एल्गोरिदम का चयन करते हैं, और वही बाइट जो हमारे पास है
0x1F के बराबर का मामला, तीन संभावित विकल्पों में से एक को दर्शाता है।

हम कोड का विश्लेषण करना जारी रखते हैं। कुछ छलाँगों के बाद हम स्वयं को एक स्व-व्याख्यात्मक नाम वाली विधि में पाते हैं डिक्रिप्टबाइट्सबायकी.

यहां हमारी प्रतिक्रिया से दो और बाइट्स अलग किए जाते हैं, और उनसे एक स्ट्रिंग प्राप्त की जाती है। यह स्पष्ट है कि इस प्रकार संदेश को डिक्रिप्ट करने की कुंजी का चयन किया जाता है।

    private static byte[] decryptBytesByKey(byte[] bytes) {
byte[] v0 = null;
if(bytes != null) {
try {
if(bytes.length < EncryptHelper.PREFIX_BYTES_SIZE) {
}
else if(bytes.length == EncryptHelper.PREFIX_BYTES_SIZE) {
return v0;
}
else {
byte[] prefix = new byte[EncryptHelper.PREFIX_BYTES_SIZE];  // 2 байта
System.arraycopy(bytes, 0, prefix, 0, prefix.length);
String keyId = c.ayR().d(ByteBuffer.wrap(prefix).getShort()); // Выбор ключа
if(keyId == null) {
return v0;
}
else {
a v2 = EncryptHelper.ayL();
if(v2 == null) {
return v0;
}
else {
byte[] enrypted = new byte[bytes.length - EncryptHelper.PREFIX_BYTES_SIZE];
System.arraycopy(bytes, EncryptHelper.PREFIX_BYTES_SIZE, enrypted, 0, enrypted.length);
return v2.l(keyId, enrypted);
}
}
}
}
catch(SecException v7_1) {
EncryptHelper.handleDecryptException(((Throwable)v7_1), v7_1.getErrorCode());
return v0;
}
catch(Throwable v7) {
EncryptHelper.handleDecryptException(v7, 2);
return v0;
}
}
return v0;
}

आगे देखते हुए, हम देखते हैं कि इस स्तर पर हमें अभी तक कोई कुंजी नहीं मिली है, बल्कि केवल उसका "पहचानकर्ता" मिला है। चाबी प्राप्त करना थोड़ा अधिक जटिल है।

अगली विधि में, मौजूदा मापदंडों में दो और पैरामीटर जोड़े जाते हैं, जिससे उनमें से चार बन जाते हैं: जादुई संख्या 16, कुंजी पहचानकर्ता, एन्क्रिप्टेड डेटा और एक समझ से बाहर स्ट्रिंग (हमारे मामले में, खाली)।

    public final byte[] l(String keyId, byte[] encrypted) throws SecException {
return this.ayJ().staticBinarySafeDecryptNoB64(16, keyId, encrypted, "");
}

परिवर्तनों की एक श्रृंखला के बाद हम विधि पर पहुँचते हैं staticBinarySafeDecryptNoB64 इंटरफेस com.alibaba.wireless.security.open.staticdataencrypt.IStaticDataEncryptComponent। मुख्य एप्लिकेशन कोड में ऐसी कोई कक्षा नहीं है जो इस इंटरफ़ेस को लागू करती हो। फ़ाइल में ऐसी एक क्लास है lib/armeabi-v7a/libsgmain.so, जो वास्तव में एक .so नहीं है, बल्कि एक .jar है। जिस विधि में हम रुचि रखते हैं उसे इस प्रकार कार्यान्वित किया जाता है:

package com.alibaba.wireless.security.a.i;
// ...
public class a implements IStaticDataEncryptComponent {
private ISecurityGuardPlugin a;
// ...
private byte[] a(int mode, int magicInt, int xzInt, String keyId, byte[] encrypted, String magicString) {
return this.a.getRouter().doCommand(10601, new Object[]{Integer.valueOf(mode), Integer.valueOf(magicInt), Integer.valueOf(xzInt), keyId, encrypted, magicString});
}
// ...
private byte[] b(int magicInt, String keyId, byte[] encrypted, String magicString) {
return this.a(2, magicInt, 0, keyId, encrypted, magicString);
}
// ...
public byte[] staticBinarySafeDecryptNoB64(int magicInt, String keyId, byte[] encrypted, String magicString) throws SecException {
if(keyId != null && keyId.length() > 0 && magicInt >= 0 && magicInt < 19 && encrypted != null && encrypted.length > 0) {
return this.b(magicInt, keyId, encrypted, magicString);
}
throw new SecException("", 301);
}
//...
}

यहां हमारे मापदंडों की सूची दो और पूर्णांकों के साथ पूरक है: 2 और 0
सब कुछ, 2 का अर्थ है डिक्रिप्शन, जैसा कि विधि में है doFinal सिस्टम क्लास javax.क्रिप्टो.सिफर. और यह सब 10601 नंबर के साथ एक निश्चित राउटर में स्थानांतरित किया जाता है - यह स्पष्ट रूप से कमांड नंबर है।

बदलावों की अगली श्रृंखला के बाद हमें एक वर्ग मिलता है जो इंटरफ़ेस को लागू करता है आईराउटरकंपोनेंट और विधि doCommand:

package com.alibaba.wireless.security.mainplugin;
import com.alibaba.wireless.security.framework.IRouterComponent;
import com.taobao.wireless.security.adapter.JNICLibrary;
public class a implements IRouterComponent {
public a() {
super();
}
public Object doCommand(int arg2, Object[] arg3) {
return JNICLibrary.doCommandNative(arg2, arg3);
}
}

और क्लास भी जेएनआईसीलाइब्रेरी, जिसमें मूल विधि घोषित की गई है doCommandNative:

package com.taobao.wireless.security.adapter;
public class JNICLibrary {
public static native Object doCommandNative(int arg0, Object[] arg1);
}

इसका मतलब है कि हमें मूल कोड में एक विधि खोजने की आवश्यकता है doCommandNative. और यहीं से मज़ा शुरू होता है।

मशीन कोड का अस्पष्टीकरण

फाइल मैं libsgmain.so (जो वास्तव में एक .jar है और जिसमें हमने ऊपर कुछ एन्क्रिप्शन-संबंधित इंटरफेस का कार्यान्वयन पाया है) एक मूल पुस्तकालय है: libsgmainso-6.4.36.so. हम इसे आईडीए में खोलते हैं और त्रुटियों वाले संवाद बॉक्स का एक समूह प्राप्त करते हैं। समस्या यह है कि अनुभाग शीर्षलेख तालिका अमान्य है. यह विश्लेषण को जटिल बनाने के उद्देश्य से किया गया है।

लेकिन इसकी आवश्यकता नहीं है: ईएलएफ फ़ाइल को सही ढंग से लोड करने और उसका विश्लेषण करने के लिए, एक प्रोग्राम हेडर टेबल पर्याप्त है। इसलिए, हम हेडर में संबंधित फ़ील्ड को शून्य करते हुए, अनुभाग तालिका को हटा देते हैं।

फ़ाइल को IDA में दोबारा खोलें.

जावा वर्चुअल मशीन को यह बताने के दो तरीके हैं कि मूल लाइब्रेरी में जावा कोड में मूल के रूप में घोषित विधि का कार्यान्वयन कहाँ स्थित है। सबसे पहले इसे एक प्रजाति का नाम देना है Java_package_name_ClassName_MethodName.

दूसरा है लाइब्रेरी लोड करते समय (फ़ंक्शन में) इसे पंजीकृत करना जेएनआई_ऑनलोड)
फ़ंक्शन कॉल का उपयोग करना रजिस्टरनेटिव्स.

हमारे मामले में, यदि हम पहली विधि का उपयोग करते हैं, तो नाम इस प्रकार होना चाहिए: Java_com_taobao_wireless_security_adapter_JNICLibrary_doCommandNative.

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

यहाँ क्या चल रहा है? पहली नज़र में, फ़ंक्शन की शुरुआत और अंत एआरएम आर्किटेक्चर के लिए विशिष्ट हैं। स्टैक पर पहला निर्देश उन रजिस्टरों की सामग्री को संग्रहीत करता है जिन्हें फ़ंक्शन अपने संचालन में उपयोग करेगा (इस मामले में, आर0, आर1 और आर2), साथ ही एलआर रजिस्टर की सामग्री, जिसमें फ़ंक्शन से रिटर्न पता शामिल है . अंतिम निर्देश सहेजे गए रजिस्टरों को पुनर्स्थापित करता है, और रिटर्न पता तुरंत पीसी रजिस्टर में डाल दिया जाता है - इस प्रकार फ़ंक्शन से वापस आ जाता है। लेकिन अगर आप बारीकी से देखेंगे, तो आप देखेंगे कि अंतिम निर्देश स्टैक पर संग्रहीत रिटर्न पते को बदल देता है। आइए गणना करें कि इसके बाद यह कैसा होगा
कोड निष्पादन. एक निश्चित पता 1xB0 को R130 में लोड किया जाता है, इसमें से 5 घटाया जाता है, फिर इसे R0 में स्थानांतरित किया जाता है और 0x10 को इसमें जोड़ा जाता है। यह 0xB13B निकला। इस प्रकार, आईडीए सोचता है कि अंतिम निर्देश एक सामान्य फ़ंक्शन रिटर्न है, लेकिन वास्तव में यह गणना किए गए पते 0xB13B पर जा रहा है।

यहां यह याद रखने योग्य है कि एआरएम प्रोसेसर में दो मोड और निर्देशों के दो सेट होते हैं: एआरएम और थंब। पते का सबसे कम महत्वपूर्ण बिट प्रोसेसर को बताता है कि किस निर्देश सेट का उपयोग किया जा रहा है। यानी, पता वास्तव में 0xB13A है, और सबसे कम महत्वपूर्ण बिट में से एक थंब मोड को इंगित करता है।

इस लाइब्रेरी में प्रत्येक फ़ंक्शन की शुरुआत में एक समान "एडेप्टर" जोड़ा गया है
कचरा कोड. हम उन पर आगे विस्तार से ध्यान नहीं देंगे - हम बस याद करते हैं
कि लगभग सभी कार्यों की वास्तविक शुरुआत थोड़ी दूर है।

चूंकि कोड स्पष्ट रूप से 0xB13A पर नहीं जाता है, आईडीए ने स्वयं नहीं पहचाना कि कोड इस स्थान पर स्थित था। इसी कारण से, यह लाइब्रेरी के अधिकांश कोड को कोड के रूप में नहीं पहचानता है, जिससे विश्लेषण कुछ हद तक कठिन हो जाता है। हम आईडीए को बताते हैं कि यह कोड है, और यही होता है:

तालिका स्पष्ट रूप से 0xB144 से शुरू होती है। Sub_494C में क्या है?

इस फ़ंक्शन को LR रजिस्टर में कॉल करने पर, हमें पहले उल्लिखित तालिका (0xB144) का पता मिलता है। R0 में - इस तालिका में सूचकांक। अर्थात्, मान तालिका से लिया जाता है, एलआर में जोड़ा जाता है और परिणाम होता है
जाने का पता. आइए इसकी गणना करने का प्रयास करें: 0xB144 + [0xB144 + 8* 4] = 0xB144 + 0x120 = 0xB264। हम प्राप्त पते पर जाते हैं और वस्तुतः कुछ उपयोगी निर्देश देखते हैं और फिर से 0xB140 पर जाते हैं:

अब तालिका से सूचकांक 0x20 के साथ ऑफसेट पर एक संक्रमण होगा।

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

def put_unconditional_branch(source, destination):
offset = (destination - source - 4) >> 1
if offset > 2097151 or offset < -2097152:
raise RuntimeError("Invalid offset")
if offset > 1023 or offset < -1024:
instruction1 = 0xf000 | ((offset >> 11) & 0x7ff)
instruction2 = 0xb800 | (offset & 0x7ff)
patch_word(source, instruction1)
patch_word(source + 2, instruction2)
else:
instruction = 0xe000 | (offset & 0x7ff)
patch_word(source, instruction)
ea = here()
if get_wide_word(ea) == 0xb503: #PUSH {R0,R1,LR}
ea1 = ea + 2
if get_wide_word(ea1) == 0xbf00: #NOP
ea1 += 2
if get_operand_type(ea1, 0) == 1 and get_operand_value(ea1, 0) == 0 and get_operand_type(ea1, 1) == 2:
index = get_wide_dword(get_operand_value(ea1, 1))
print "index =", hex(index)
ea1 += 2
if get_operand_type(ea1, 0) == 7:
table = get_operand_value(ea1, 0) + 4
elif get_operand_type(ea1, 1) == 2:
table = get_operand_value(ea1, 1) + 4
else:
print "Wrong operand type on", hex(ea1), "-", get_operand_type(ea1, 0), get_operand_type(ea1, 1)
table = None
if table is None:
print "Unable to find table"
else:
print "table =", hex(table)
offset = get_wide_dword(table + (index << 2))
put_unconditional_branch(ea, table + offset)
else:
print "Unknown code", get_operand_type(ea1, 0), get_operand_value(ea1, 0), get_operand_type(ea1, 1) == 2
else:
print "Unable to detect first instruction"

कर्सर को लाइन 0xB26A पर रखें, स्क्रिप्ट चलाएँ और 0xB4B0 में संक्रमण देखें:

आईडीए ने फिर इस क्षेत्र को कोड के रूप में मान्यता नहीं दी। हम उसकी मदद करते हैं और वहां एक और डिज़ाइन देखते हैं:

बीएलएक्स के बाद के निर्देशों का कोई विशेष अर्थ नहीं लगता है, यह किसी प्रकार के विस्थापन जैसा है। आइए उप_4964 देखें:

और वास्तव में, यहां एलआर में पड़े पते पर एक शब्द लिया जाता है, इस पते पर जोड़ा जाता है, जिसके बाद परिणामी पते पर मूल्य लिया जाता है और स्टैक पर डाल दिया जाता है। इसके अलावा, 4 को एलआर में जोड़ा जाता है ताकि फ़ंक्शन से लौटने के बाद, यही ऑफ़सेट छोड़ दिया जाए। जिसके बाद POP {R1} कमांड स्टैक से परिणामी मान लेता है। यदि आप देखते हैं कि पता 0xB4BA + 0xEA = 0xB5A4 पर क्या स्थित है, तो आपको पता तालिका के समान कुछ दिखाई देगा:

इस डिज़ाइन को पैच करने के लिए, आपको कोड से दो पैरामीटर प्राप्त करने की आवश्यकता होगी: ऑफ़सेट और रजिस्टर नंबर जिसमें आप परिणाम डालना चाहते हैं। प्रत्येक संभावित रजिस्टर के लिए, आपको पहले से कोड का एक टुकड़ा तैयार करना होगा।

patches = {}
patches[0] = (0x00, 0xbf, 0x01, 0x48, 0x00, 0x68, 0x02, 0xe0)
patches[1] = (0x00, 0xbf, 0x01, 0x49, 0x09, 0x68, 0x02, 0xe0)
patches[2] = (0x00, 0xbf, 0x01, 0x4a, 0x12, 0x68, 0x02, 0xe0)
patches[3] = (0x00, 0xbf, 0x01, 0x4b, 0x1b, 0x68, 0x02, 0xe0)
patches[4] = (0x00, 0xbf, 0x01, 0x4c, 0x24, 0x68, 0x02, 0xe0)
patches[5] = (0x00, 0xbf, 0x01, 0x4d, 0x2d, 0x68, 0x02, 0xe0)
patches[8] = (0x00, 0xbf, 0xdf, 0xf8, 0x06, 0x80, 0xd8, 0xf8, 0x00, 0x80, 0x01, 0xe0)
patches[9] = (0x00, 0xbf, 0xdf, 0xf8, 0x06, 0x90, 0xd9, 0xf8, 0x00, 0x90, 0x01, 0xe0)
patches[10] = (0x00, 0xbf, 0xdf, 0xf8, 0x06, 0xa0, 0xda, 0xf8, 0x00, 0xa0, 0x01, 0xe0)
patches[11] = (0x00, 0xbf, 0xdf, 0xf8, 0x06, 0xb0, 0xdb, 0xf8, 0x00, 0xb0, 0x01, 0xe0)
ea = here()
if (get_wide_word(ea) == 0xb082 #SUB SP, SP, #8
and get_wide_word(ea + 2) == 0xb503): #PUSH {R0,R1,LR}
if get_operand_type(ea + 4, 0) == 7:
pop = get_bytes(ea + 12, 4, 0)
if pop[1] == 'xbc':
register = -1
r = get_wide_byte(ea + 12)
for i in range(8):
if r == (1 << i):
register = i
break
if register == -1:
print "Unable to detect register"
else:
address = get_wide_dword(ea + 8) + ea + 8
for b in patches[register]:
patch_byte(ea, b)
ea += 1
if ea % 4 != 0:
ea += 2
patch_dword(ea, address)
elif pop[:3] == 'x5dxf8x04':
register = ord(pop[3]) >> 4
if register in patches:
address = get_wide_dword(ea + 8) + ea + 8
for b in patches[register]:
patch_byte(ea, b)
ea += 1
patch_dword(ea, address)
else:
print "POP instruction not found"
else:
print "Wrong operand type on +4:", get_operand_type(ea + 4, 0)
else:
print "Unable to detect first instructions"

हम कर्सर को उस संरचना की शुरुआत में रखते हैं जिसे हम बदलना चाहते हैं - 0xB4B2 - और स्क्रिप्ट चलाते हैं:

पहले से उल्लिखित संरचनाओं के अलावा, कोड में निम्नलिखित भी शामिल हैं:

पिछले मामले की तरह, BLX निर्देश के बाद एक ऑफसेट है:

हम ऑफसेट को एलआर से पते पर लेते हैं, इसे एलआर में जोड़ते हैं और वहां जाते हैं। 0x72044 + 0xC = 0x72050. इस डिज़ाइन की स्क्रिप्ट काफी सरल है:

def put_unconditional_branch(source, destination):
offset = (destination - source - 4) >> 1
if offset > 2097151 or offset < -2097152:
raise RuntimeError("Invalid offset")
if offset > 1023 or offset < -1024:
instruction1 = 0xf000 | ((offset >> 11) & 0x7ff)
instruction2 = 0xb800 | (offset & 0x7ff)
patch_word(source, instruction1)
patch_word(source + 2, instruction2)
else:
instruction = 0xe000 | (offset & 0x7ff)
patch_word(source, instruction)
ea = here()
if get_wide_word(ea) == 0xb503: #PUSH {R0,R1,LR}
ea1 = ea + 6
if get_wide_word(ea + 2) == 0xbf00: #NOP
ea1 += 2
offset = get_wide_dword(ea1)
put_unconditional_branch(ea, (ea1 + offset) & 0xffffffff)
else:
print "Unable to detect first instruction"

स्क्रिप्ट निष्पादन का परिणाम:

एक बार फ़ंक्शन में सब कुछ पैच हो जाने पर, आप आईडीए को इसकी वास्तविक शुरुआत की ओर इंगित कर सकते हैं। यह सभी फ़ंक्शन कोड को एक साथ जोड़ देगा, और इसे HexRays का उपयोग करके विघटित किया जा सकता है।

डिकोडिंग स्ट्रिंग्स

हमने लाइब्रेरी में मशीन कोड की गड़बड़ी से निपटना सीख लिया है libsgmainso-6.4.36.so यूसी ब्राउज़र से और फ़ंक्शन कोड प्राप्त किया जेएनआई_ऑनलोड.

int __fastcall real_JNI_OnLoad(JavaVM *vm)
{
int result; // r0
jclass clazz; // r0 MAPDST
int v4; // r0
JNIEnv *env; // r4
int v6; // [sp-40h] [bp-5Ch]
int v7; // [sp+Ch] [bp-10h]
v7 = *(_DWORD *)off_8AC00;
if ( !vm )
goto LABEL_39;
sub_7C4F4();
env = (JNIEnv *)sub_7C5B0(0);
if ( !env )
goto LABEL_39;
v4 = sub_72CCC();
sub_73634(v4);
sub_73E24(&unk_83EA6, &v6, 49);
clazz = (jclass)((int (__fastcall *)(JNIEnv *, int *))(*env)->FindClass)(env, &v6);
if ( clazz
&& (sub_9EE4(),
sub_71D68(env),
sub_E7DC(env) >= 0
&& sub_69D68(env) >= 0
&& sub_197B4(env, clazz) >= 0
&& sub_E240(env, clazz) >= 0
&& sub_B8B0(env, clazz) >= 0
&& sub_5F0F4(env, clazz) >= 0
&& sub_70640(env, clazz) >= 0
&& sub_11F3C(env) >= 0
&& sub_21C3C(env, clazz) >= 0
&& sub_2148C(env, clazz) >= 0
&& sub_210E0(env, clazz) >= 0
&& sub_41B58(env, clazz) >= 0
&& sub_27920(env, clazz) >= 0
&& sub_293E8(env, clazz) >= 0
&& sub_208F4(env, clazz) >= 0) )
{
result = (sub_B7B0(env, clazz) >> 31) | 0x10004;
}
else
{
LABEL_39:
result = -1;
}
return result;
}

आइए निम्नलिखित पंक्तियों पर करीब से नज़र डालें:

  sub_73E24(&unk_83EA6, &v6, 49);
clazz = (jclass)((int (__fastcall *)(JNIEnv *, int *))(*env)->FindClass)(env, &v6);

समारोह में उप_73ई24 वर्ग का नाम स्पष्ट रूप से डिक्रिप्ट किया जा रहा है। इस फ़ंक्शन के पैरामीटर के रूप में, एन्क्रिप्टेड डेटा के समान डेटा का एक संकेतक, एक निश्चित बफर और एक संख्या पारित की जाती है। जाहिर है, फ़ंक्शन को कॉल करने के बाद, बफर में एक डिक्रिप्टेड लाइन होगी, क्योंकि यह फ़ंक्शन को पास कर दी जाती है फाइंडक्लास, जो क्लास नाम को दूसरे पैरामीटर के रूप में लेता है। इसलिए, संख्या बफ़र का आकार या रेखा की लंबाई है। आइए कक्षा के नाम को समझने का प्रयास करें, इससे हमें पता चलेगा कि हम सही दिशा में जा रहे हैं या नहीं। आइए बारीकी से देखें कि इसमें क्या होता है उप_73ई24.

int __fastcall sub_73E56(unsigned __int8 *in, unsigned __int8 *out, size_t size)
{
int v4; // r6
int v7; // r11
int v8; // r9
int v9; // r4
size_t v10; // r5
int v11; // r0
struc_1 v13; // [sp+0h] [bp-30h]
int v14; // [sp+1Ch] [bp-14h]
int v15; // [sp+20h] [bp-10h]
v4 = 0;
v15 = *(_DWORD *)off_8AC00;
v14 = 0;
v7 = sub_7AF78(17);
v8 = sub_7AF78(size);
if ( !v7 )
{
v9 = 0;
goto LABEL_12;
}
(*(void (__fastcall **)(int, const char *, int))(v7 + 12))(v7, "DcO/lcK+h?m3c*q@", 16);
if ( !v8 )
{
LABEL_9:
v4 = 0;
goto LABEL_10;
}
v4 = 0;
if ( !in )
{
LABEL_10:
v9 = 0;
goto LABEL_11;
}
v9 = 0;
if ( out )
{
memset(out, 0, size);
v10 = size - 1;
(*(void (__fastcall **)(int, unsigned __int8 *, size_t))(v8 + 12))(v8, in, v10);
memset(&v13, 0, 0x14u);
v13.field_4 = 3;
v13.field_10 = v7;
v13.field_14 = v8;
v11 = sub_6115C(&v13, &v14);
v9 = v11;
if ( v11 )
{
if ( *(_DWORD *)(v11 + 4) == v10 )
{
qmemcpy(out, *(const void **)v11, v10);
v4 = *(_DWORD *)(v9 + 4);
}
else
{
v4 = 0;
}
goto LABEL_11;
}
goto LABEL_9;
}
LABEL_11:
sub_7B148(v7);
LABEL_12:
if ( v8 )
sub_7B148(v8);
if ( v9 )
sub_7B148(v9);
return v4;
}

समारोह उप_7एएफ78 निर्दिष्ट आकार के बाइट सरणियों के लिए एक कंटेनर का एक उदाहरण बनाता है (हम इन कंटेनरों पर विस्तार से ध्यान नहीं देंगे)। यहां दो ऐसे कंटेनर बनाए गए हैं: एक में लाइन है "DcO/lcK+h?m3c*q@" (यह अनुमान लगाना आसान है कि यह एक कुंजी है), दूसरे में एन्क्रिप्टेड डेटा है। इसके बाद, दोनों वस्तुओं को एक निश्चित संरचना में रखा जाता है, जिसे फ़ंक्शन में भेज दिया जाता है उप_6115सी. आइए इस संरचना में मान 3 के साथ एक फ़ील्ड भी चिह्नित करें। आइए देखें कि इस संरचना के साथ आगे क्या होता है।

int __fastcall sub_611B4(struc_1 *a1, _DWORD *a2)
{
int v3; // lr
unsigned int v4; // r1
int v5; // r0
int v6; // r1
int result; // r0
int v8; // r0
*a2 = 820000;
if ( a1 )
{
v3 = a1->field_14;
if ( v3 )
{
v4 = a1->field_4;
if ( v4 < 0x19 )
{
switch ( v4 )
{
case 0u:
v8 = sub_6419C(a1->field_0, a1->field_10, v3);
goto LABEL_17;
case 3u:
v8 = sub_6364C(a1->field_0, a1->field_10, v3);
goto LABEL_17;
case 0x10u:
case 0x11u:
case 0x12u:
v8 = sub_612F4(
a1->field_0,
v4,
*(_QWORD *)&a1->field_8,
*(_QWORD *)&a1->field_8 >> 32,
a1->field_10,
v3,
a2);
goto LABEL_17;
case 0x14u:
v8 = sub_63A28(a1->field_0, v3);
goto LABEL_17;
case 0x15u:
sub_61A60(a1->field_0, v3, a2);
return result;
case 0x16u:
v8 = sub_62440(a1->field_14);
goto LABEL_17;
case 0x17u:
v8 = sub_6226C(a1->field_10, v3);
goto LABEL_17;
case 0x18u:
v8 = sub_63530(a1->field_14);
LABEL_17:
v6 = 0;
if ( v8 )
{
*a2 = 0;
v6 = v8;
}
return v6;
default:
LOWORD(v5) = 28032;
goto LABEL_5;
}
}
}
}
LOWORD(v5) = -27504;
LABEL_5:
HIWORD(v5) = 13;
v6 = 0;
*a2 = v5;
return v6;
}

स्विच पैरामीटर एक संरचना फ़ील्ड है जिसे पहले मान 3 निर्दिष्ट किया गया था। फ़ंक्शन के मामले 3 को देखें उप_6364सी पैरामीटर उस संरचना से पारित किए जाते हैं जो पिछले फ़ंक्शन में जोड़े गए थे, यानी कुंजी और एन्क्रिप्टेड डेटा। अगर आप गौर से देखेंगे उप_6364सी, आप इसमें RC4 एल्गोरिदम को पहचान सकते हैं।

हमारे पास एक एल्गोरिदम और एक कुंजी है. आइए कक्षा के नाम को समझने का प्रयास करें। यहाँ क्या हुआ: com/taobao/वायरलेस/सुरक्षा/एडाप्टर/JNICLibrary. महान! हम सही रास्ते पर हैं.

आदेश वृक्ष

अब हमें एक चुनौती ढूंढनी होगी रजिस्टरनेटिव्स, जो हमें फ़ंक्शन की ओर इंगित करेगा doCommandNative. आइए से बुलाए गए फ़ंक्शंस को देखें जेएनआई_ऑनलोड, और हम इसे इसमें पाते हैं उप_B7B0:

int __fastcall sub_B7F6(JNIEnv *env, jclass clazz)
{
char signature[41]; // [sp+7h] [bp-55h]
char name[16]; // [sp+30h] [bp-2Ch]
JNINativeMethod method; // [sp+40h] [bp-1Ch]
int v8; // [sp+4Ch] [bp-10h]
v8 = *(_DWORD *)off_8AC00;
decryptString((unsigned __int8 *)&unk_83ED9, (unsigned __int8 *)name, 0x10u);// doCommandNative
decryptString((unsigned __int8 *)&unk_83EEA, (unsigned __int8 *)signature, 0x29u);// (I[Ljava/lang/Object;)Ljava/lang/Object;
method.name = name;
method.signature = signature;
method.fnPtr = sub_B69C;
return ((int (__fastcall *)(JNIEnv *, jclass, JNINativeMethod *, int))(*env)->RegisterNatives)(env, clazz, &method, 1) >> 31;
}

और वास्तव में, नाम के साथ एक मूल विधि यहां पंजीकृत है doCommandNative. अब हमें उसका पता मालूम है. देखते हैं वह क्या करता है.

int __fastcall doCommandNative(JNIEnv *env, jobject obj, int command, jarray args)
{
int v5; // r5
struc_2 *a5; // r6
int v9; // r1
int v11; // [sp+Ch] [bp-14h]
int v12; // [sp+10h] [bp-10h]
v5 = 0;
v12 = *(_DWORD *)off_8AC00;
v11 = 0;
a5 = (struc_2 *)malloc(0x14u);
if ( a5 )
{
a5->field_0 = 0;
a5->field_4 = 0;
a5->field_8 = 0;
a5->field_C = 0;
v9 = command % 10000 / 100;
a5->field_0 = command / 10000;
a5->field_4 = v9;
a5->field_8 = command % 100;
a5->field_C = env;
a5->field_10 = args;
v5 = sub_9D60(command / 10000, v9, command % 100, 1, (int)a5, &v11);
}
free(a5);
if ( !v5 && v11 )
sub_7CF34(env, v11, &byte_83ED7);
return v5;
}

नाम से आप अनुमान लगा सकते हैं कि यहां उन सभी कार्यों का प्रवेश बिंदु है जिन्हें डेवलपर्स ने मूल पुस्तकालय में स्थानांतरित करने का निर्णय लिया है। हम फ़ंक्शन संख्या 10601 में रुचि रखते हैं।

आप कोड से देख सकते हैं कि कमांड नंबर तीन नंबर उत्पन्न करता है: कमांड/10000, कमांड % 10000/100 и आदेश % 10, अर्थात्, हमारे मामले में, 1, 6 और 1। ये तीन संख्याएँ, साथ ही एक सूचक भी जेएनआईएनवी और फ़ंक्शन में दिए गए तर्कों को एक संरचना में जोड़ा जाता है और आगे बढ़ाया जाता है। प्राप्त तीन संख्याओं का उपयोग करके (आइए उन्हें N1, N2 और N3 निरूपित करें), एक कमांड ट्री बनाया गया है।

कुछ इस तरह:

पेड़ गतिशील रूप से भरा हुआ है जेएनआई_ऑनलोड.
तीन संख्याएँ पेड़ में पथ को कूटबद्ध करती हैं। पेड़ के प्रत्येक पत्ते में संबंधित फ़ंक्शन का पॉक्ड पता होता है। कुंजी मूल नोड में है. कोड में वह स्थान ढूंढना जहां हमें जिस फ़ंक्शन की आवश्यकता है उसे पेड़ में जोड़ा जाता है, यदि आप उपयोग की गई सभी संरचनाओं को समझते हैं तो मुश्किल नहीं है (हम उनका वर्णन नहीं करते हैं ताकि पहले से ही बड़े लेख को फूला न जाए)।

अधिक भ्रम

हमें उस फ़ंक्शन का पता प्राप्त हुआ जो ट्रैफ़िक को डिक्रिप्ट करना चाहिए: 0x5F1AC। लेकिन अभी खुश होना जल्दबाजी होगी: यूसी ब्राउज़र के डेवलपर्स ने हमारे लिए एक और आश्चर्य तैयार किया है।

जावा कोड में बने ऐरे से पैरामीटर प्राप्त करने के बाद, हमें मिलता है
पते 0x4D070 पर फ़ंक्शन के लिए। और यहां एक अन्य प्रकार की कोड अस्पष्टता हमारा इंतजार कर रही है।

हमने R7 और R4 में दो सूचकांक रखे हैं:

हम पहले सूचकांक को R11 पर स्थानांतरित करते हैं:

किसी तालिका से पता प्राप्त करने के लिए, एक अनुक्रमणिका का उपयोग करें:

पहले पते पर जाने के बाद दूसरे इंडेक्स का उपयोग किया जाता है, जो R4 में होता है। तालिका में 230 तत्व हैं।

इसके बारे में क्या करना है? आप आईडीए को बता सकते हैं कि यह एक स्विच है: संपादित करें -> अन्य -> ​​स्विच मुहावरा निर्दिष्ट करें।

परिणामी कोड डरावना है. लेकिन, इसके जंगल के माध्यम से अपना रास्ता बनाते हुए, आप पहले से ही हमारे परिचित एक समारोह में कॉल को देख सकते हैं उप_6115सी:

एक स्विच था जिसमें केस 3 में RC4 एल्गोरिथम का उपयोग करके डिक्रिप्शन था। और इस मामले में, फ़ंक्शन को दी गई संरचना पास किए गए पैरामीटर से भरी जाती है doCommandNative. आइए याद करें कि हमारे पास वहां क्या था मैजिकइंट मान 16 के साथ। हम संबंधित मामले को देखते हैं - और कई बदलावों के बाद हमें वह कोड मिलता है जिसके द्वारा एल्गोरिदम की पहचान की जा सकती है।

यह एईएस है!

एल्गोरिदम मौजूद है, जो कुछ बचा है वह इसके पैरामीटर प्राप्त करना है: मोड, कुंजी और, संभवतः, प्रारंभिक वेक्टर (इसकी उपस्थिति एईएस एल्गोरिदम के ऑपरेटिंग मोड पर निर्भर करती है)। उनके साथ संरचना फ़ंक्शन कॉल से पहले कहीं बननी चाहिए उप_6115सी, लेकिन कोड का यह हिस्सा विशेष रूप से अच्छी तरह से अस्पष्ट है, इसलिए कोड को पैच करने का विचार उठता है ताकि डिक्रिप्शन फ़ंक्शन के सभी पैरामीटर एक फ़ाइल में डंप हो जाएं।

पैच

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

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

पहला भाग:

एआरएम आर्किटेक्चर में, पहले चार फ़ंक्शन पैरामीटर रजिस्टर R0-R3 के माध्यम से पारित किए जाते हैं, बाकी, यदि कोई हो, स्टैक के माध्यम से पारित किए जाते हैं। एलआर रजिस्टर में रिटर्न का पता होता है। यह सब सहेजने की आवश्यकता है ताकि फ़ंक्शन इसके मापदंडों को डंप करने के बाद काम कर सके। हमें उन सभी रजिस्टरों को भी सहेजने की ज़रूरत है जिनका हम इस प्रक्रिया में उपयोग करेंगे, इसलिए हम PUSH.W {R0-R10,LR} करते हैं। R7 में हमें स्टैक के माध्यम से फ़ंक्शन को दिए गए पैरामीटर की सूची का पता मिलता है।

फ़ंक्शन का उपयोग करना फोपेन आइए फ़ाइल खोलें /डेटा/स्थानीय/टीएमपी/एईएस "अब" मोड में
यानी जोड़ने के लिए. R0 में हम फ़ाइल नाम का पता लोड करते हैं, R1 में - मोड को इंगित करने वाली लाइन का पता। और यहां कचरा कोड समाप्त होता है, इसलिए हम अगले फ़ंक्शन पर आगे बढ़ते हैं। इसे काम करना जारी रखने के लिए, हम शुरुआत में कचरे को दरकिनार करते हुए फ़ंक्शन के वास्तविक कोड में बदलाव करते हैं, और कचरे के बजाय हम पैच की निरंतरता जोड़ते हैं।

कॉलिंग फोपेन.

फ़ंक्शन के पहले तीन पैरामीटर एईएस प्रकार है int. चूँकि हमने शुरुआत में रजिस्टरों को स्टैक में सहेजा था, हम आसानी से फ़ंक्शन को पास कर सकते हैं fwrite स्टैक पर उनके पते.

आगे हमारे पास तीन संरचनाएं हैं जिनमें डेटा आकार और कुंजी, आरंभीकरण वेक्टर और एन्क्रिप्टेड डेटा के लिए डेटा का एक संकेतक शामिल है।

अंत में, फ़ाइल को बंद करें, रजिस्टरों को पुनर्स्थापित करें और नियंत्रण को वास्तविक फ़ंक्शन पर स्थानांतरित करें एईएस.

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

    const/16 v1, 0x62
new-array v1, v1, [B
fill-array-data v1, :encrypted_data
const/16 v0, 0x1f
invoke-static {v0, v1}, Lcom/uc/browser/core/d/c/g;->j(I[B)[B
move-result-object v1
array-length v2, v1
invoke-static {v2}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
move-result-object v2
const-string v0, "ololo"
invoke-static {v0, v2}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I

हम इकट्ठा करते हैं, हस्ताक्षर करते हैं, स्थापित करते हैं, लॉन्च करते हैं। हमें एक NullPointerException प्राप्त होता है क्योंकि विधि शून्य हो गई है।

कोड के आगे के विश्लेषण के दौरान, एक फ़ंक्शन की खोज की गई जो दिलचस्प पंक्तियों को समझता है: "META-INF/" और ".RSA"। ऐसा लगता है कि एप्लिकेशन अपने प्रमाणपत्र का सत्यापन कर रहा है। या उससे चाबियाँ भी उत्पन्न करता है। मैं वास्तव में प्रमाणपत्र के साथ क्या हो रहा है उससे निपटना नहीं चाहता, इसलिए हम इसे सही प्रमाणपत्र ही दे देंगे। आइए एन्क्रिप्टेड लाइन को पैच करें ताकि "META-INF/" के बजाय हमें "BLABLINF/" मिले, एपीके में उस नाम के साथ एक फ़ोल्डर बनाएं और वहां स्क्विरल ब्राउज़र प्रमाणपत्र जोड़ें।

हम इकट्ठा करते हैं, हस्ताक्षर करते हैं, स्थापित करते हैं, लॉन्च करते हैं। बिंगो! हमारे पास चाबी है!

MITM

हमें कुंजी के बराबर एक कुंजी और एक आरंभीकरण वेक्टर प्राप्त हुआ। आइए सीबीसी मोड में सर्वर प्रतिक्रिया को डिक्रिप्ट करने का प्रयास करें।

हम संग्रह URL देखते हैं, जो कुछ हद तक MD5, "extract_unzipsize" और एक संख्या के समान है। हम जाँचते हैं: संग्रह का MD5 समान है, अनपैक्ड लाइब्रेरी का आकार समान है। हम इस लाइब्रेरी को पैच करके ब्राउज़र को देने का प्रयास कर रहे हैं। यह दिखाने के लिए कि हमारी पैच की गई लाइब्रेरी लोड हो गई है, हम "PWNED!" टेक्स्ट के साथ एक एसएमएस बनाने का इरादा लॉन्च करेंगे। हम सर्वर से दो प्रतिक्रियाएँ प्रतिस्थापित करेंगे: puds.ucweb.com/upgrade/index.xhtml और पुरालेख डाउनलोड करने के लिए. पहले में हम MD5 को प्रतिस्थापित करते हैं (अनपॅकिंग के बाद आकार नहीं बदलता है), दूसरे में हम पैच लाइब्रेरी के साथ संग्रह देते हैं।

ब्राउज़र कई बार संग्रह को डाउनलोड करने का प्रयास करता है, जिसके बाद यह एक त्रुटि देता है। जाहिरा तौर पर कुछ
वह पसंद नहीं करता। इस अस्पष्ट प्रारूप का विश्लेषण करने के परिणामस्वरूप, यह पता चला कि सर्वर संग्रह का आकार भी प्रसारित करता है:

यह LEB128 में एन्कोड किया गया है। पैच के बाद, लाइब्रेरी के साथ संग्रह का आकार थोड़ा बदल गया, इसलिए ब्राउज़र ने माना कि संग्रह टेढ़ा डाउनलोड किया गया था, और कई प्रयासों के बाद इसमें एक त्रुटि आ गई।

हम संग्रह का आकार समायोजित करते हैं... और - जीत! 🙂 नतीजा वीडियो में है.

https://www.youtube.com/watch?v=Nfns7uH03J8

परिणाम और डेवलपर प्रतिक्रिया

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

हमने यूसी ब्राउज़र के डेवलपर्स से संपर्क किया और उन्हें मिली समस्या के बारे में बताया, भेद्यता और उसके खतरे को इंगित करने की कोशिश की, लेकिन उन्होंने हमारे साथ कोई चर्चा नहीं की। इस बीच, ब्राउज़र ने स्पष्ट रूप से अपनी खतरनाक विशेषता का प्रदर्शन जारी रखा। लेकिन एक बार जब हमने भेद्यता का विवरण प्रकट कर दिया, तो इसे पहले की तरह अनदेखा करना संभव नहीं रह गया था। 27 मार्च था
यूसी ब्राउज़र का एक नया संस्करण 12.10.9.1193 जारी किया गया, जो HTTPS के माध्यम से सर्वर तक पहुंचा: puds.ucweb.com/upgrade/index.xhtml.

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

स्रोत: www.habr.com