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

परिचय

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

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

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

एप्लिकेशन कोड में निष्पादन योग्य कोड को डाउनलोड करने और चलाने की क्षमता का पता चला, जो 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" /> 

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

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



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



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

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

चलो सर्वर प्रतिक्रिया को डिक्रिप्ट करने की कोशिश करते हैं। हम कक्षा के कोड को देखते हैं। com.uc.deployment.UpgradeDeployService : onStartCommand विधि से, 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(); mb(v3_4); h v4_2 = new h(); mb(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.baacgetCpuArch())); v3_2.add(g.fs("cpu_arch", com.uc.baacPb())); String v4_3 = com.uc.baacPd(); 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.baacPc())); 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.baacJl()))); v3_2.add(g.fs("ram_1", String.valueOf(com.uc.baahPo()))); v3_2.add(g.fs("totalram", String.valueOf(com.uc.baahOL()))); 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 = gi(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.dci 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.dci$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); mb(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 = gj(arg11[2], v7); } if(v7 == null) { goto label_57; } if(v5 != 0) { v1_1 = gP(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 = gb(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 = cc(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, ""); } 

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

 package com.alibaba.wireless.security.ai; // ... 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 का अर्थ है डिक्रिप्शन, जैसे कि javax.crypto.Cipher सिस्टम क्लास की सामान्य विधि में। और यह सब 10601 नंबर के साथ एक निश्चित राउटर में स्थानांतरित किया जाता है - यह, जाहिरा तौर पर, कमांड नंबर है।

अगली संक्रमण श्रृंखला के बाद, हमें एक वर्ग मिलता है जो IRouterComponent इंटरफ़ेस और 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); } } 

और JNICLibrary क्लास भी, जिसमें 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 । इसे आईडीए में खोलें और त्रुटियों के साथ संवाद बक्से का एक गुच्छा प्राप्त करें। समस्या यह है कि अनुभाग शीर्ष लेख तालिका अमान्य है। यह विशेष रूप से विश्लेषण को जटिल करने के लिए किया जाता है।



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



फिर से आईडीए में फ़ाइल खोलें।

जावा वर्चुअल मशीन को बताने के दो तरीके हैं, जहां मूल पुस्तकालय में मूल के रूप में जावा कोड में घोषित विधि का कार्यान्वयन है। सबसे पहले इसे फॉर्म का नाम देना है Java_package_name_ClassName_Method_name ।

दूसरा पुस्तकालय को लोड करते समय इसे पंजीकृत करना है ( JNI_OnLoad फ़ंक्शन में)
RegisterNatives फ़ंक्शन को कॉल करके।

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

निर्यात किए गए कार्यों में, ऐसा कोई भी नहीं है, इसलिए आपको पंजीकरणकर्ताओं के लिए कॉल देखने की आवश्यकता है।
हम JNI_OnLoad फ़ंक्शन पर जाते हैं और निम्न चित्र देखते हैं:



यहाँ क्या हो रहा है? पहली नज़र में, फ़ंक्शन की शुरुआत और अंत एआरएम वास्तुकला के विशिष्ट हैं। स्टैक पर पहला निर्देश रजिस्टरों की सामग्री को संग्रहीत करता है जिसे फ़ंक्शन अपने काम में उपयोग करेगा (इस मामले में R0, R1 और R2), साथ ही रजिस्टर LR की सामग्री, जिसमें फ़ंक्शन से वापसी पता स्थित है। अंतिम निर्देश के साथ, सहेजे गए रजिस्टरों को बहाल किया जाता है, और रिटर्न पता तुरंत पीसी रजिस्टर में रखा जाता है - इस प्रकार फ़ंक्शन से वापस आ जाता है। लेकिन अगर आप बारीकी से देखते हैं, तो आप देखेंगे कि पेनल्टीट्यूट अनुदेश स्टैक पर संग्रहीत रिटर्न एड्रेस को बदल देता है। हम गणना करते हैं कि इसके बाद क्या होगा
कोड निष्पादन। एक निश्चित पता 0xB130 को R1 में लोड किया जाता है, 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 को LR में जोड़ा जाता है, ताकि फ़ंक्शन से लौटने के बाद इसी ऑफसेट को कूद सकें। तब 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] == '\x5d\xf8\x04': 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 लाइब्रेरी में मशीन कोड की गड़बड़ी से कैसे निपटें और JNI_OnLoad फ़ंक्शन के लिए कोड प्राप्त करें।

 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); 

उप_73E24 फ़ंक्शन स्पष्ट रूप से वर्ग नाम को डिक्रिप्ट करता है। , , . , , . . FindClass , . , — . , , . , sub_73E24.

 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; } 

sub_7AF78 ( ). : «DcO/lcK+h?m3c*q@» ( , ), — . , sub_6115C . 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; } 

switch , 3. case 3: sub_6364C , , . . . sub_6364C , RC4.

. . : com/taobao/wireless/security/adapter/JNICLibrary . बहुत बढ़िया! .

RegisterNatives , doCommandNative . , JNI_OnLoad, sub_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.

, : command / 10000 , command % 10000 / 100 command % 10 , . ., , 1, 6 1. , JNIEnv , , . ( N1, N2 N3) .

:



JNI_OnLoad .
. . — . , , , ( , ).

, : 0x5F1AC. : UC Browser .

, Java-,
0x4D070. .

R7 R4 :



R11:



, :



, R4. 230 .

इसके बारे में क्या करना है? IDA, switch: Edit -> Other -> Specify switch idiom.



. , , sub_6115C :



switch, case 3 RC4. , doCommandNative . , magicInt 16. case – , .



AES!

, : , , , ( AES). - sub_6115C , , , .

, Android Studio, , , , , , .

UC Browser «». , , . :) , , , . . .

:



ARM R0-R3, , — . LR . , , . , , PUSH.W {R0-R10,LR}. R7 , .

fopen /data/local/tmp/aes «ab»,
. . . R0 , R1 — . , . , , .



fopen .

aes int . , fwrite .



, , .



, aes .

APK , , /, . , , . , . - , . , UC Browser , , , : 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, . . null.

, : «META-INF/» ".RSA". , . . , , , . , «META-INF/» «BLABLINF/», APK .

, , , . बिंगो! !

MitM

, . CBC.



URL , - MD5, «extract_unzipsize» . : MD5 , . . , , Intent «PWNED!». : puds.ucweb.com/upgrade/index.xhtml . MD5 ( ), .

, . , -
. , :



LEB128. , , , .

… – ! :) .

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

UC Browser, . , . — , , , .

UC Browser , , - . . , , , . 27
UC Browser 12.10.9.1193, HTTPS: puds.ucweb.com/upgrade/index.xhtml .

, «» PDF «, - !». PDF , , Google Play.