ब्रेकिंग यूसी ब्राउज़र

परिचय

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

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

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

हमारे अध्ययन के समय Google Play के माध्यम से वितरित किए गए UC ब्राउज़र के संस्करण पर लागू होने वाली सब कुछ इस प्रकार है:

package: com.UCMobile.intl versionName: 12.10.8.1172 versionCode: 10598 sha1 APK-file: f5edb2243413c777172f6362876041eb0c3a928c 

हमला वेक्टर

UC Browser के प्रकटीकरण में 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 अनुरोध है, फिर PDF फ़ाइलों और कार्यालय दस्तावेज़ों को देखने के लिए संपीड़ित लाइब्रेरी डाउनलोड की जाती है। तार्किक रूप से, हम मान सकते हैं कि पहला अनुरोध सिस्टम के बारे में जानकारी भेजता है (कम से कम आर्किटेक्चर, क्योंकि सर्वर को एक उपयुक्त पुस्तकालय का चयन करने की आवश्यकता है), और सर्वर उस लाइब्रेरी के बारे में कुछ जानकारी के साथ प्रतिक्रिया करता है जिसे डाउनलोड करने की आवश्यकता है, जैसे उसका पता और शायद कुछ और। समस्या यह है कि यह अनुरोध एन्क्रिप्टेड है।


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

ट्रैफ़िक डिक्रिप्शन कोड की खोज करना

आइए कोशिश करते हैं और सर्वर की प्रतिक्रिया को डिक्रिप्ट करते हैं। Com.uc.deployment.UpgradeDeployService वर्ग के कोड पर एक नज़र डालें: onStartCommand विधि से , हम com.uc.deployment.bx पर जाएँ , और फिर com.uc.bodser.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", उदाहरण के लिए) को देखते हुए, सर्वर की प्रतिक्रिया को डिक्रिप्ट करने के लिए एक विधि को यहां कहा जाता है। अब हम gj विधि को देखते हैं। ध्यान दें कि पहला तर्क ऑफसेट 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 में निहित है , जो वास्तव में नहीं है। इसके अलावा, बल्कि .JAR जिस विधि में हम रुचि रखते हैं, वह इस प्रकार लागू की जाती है:

 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 की संख्या के साथ एक निश्चित राउटर को प्रेषित की जाती है, जो स्पष्ट रूप से कमांड नंबर है।

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

जेएनआईसी लाइब्रेरी क्लास भी है, जहां देशी doCandandNative पद्धति घोषित की गई है:

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



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



फिर हम आईडीए में फाइल को फिर से खोलते हैं।

जावा वर्चुअल मशीन को बताने के लिए हमारे पास दो तरीके हैं जहां मूल लाइब्रेरी में जावा कोड में मूल के रूप में घोषित विधि का कार्यान्वयन शामिल है। पहला यह है कि इसे इस तरह एक नाम दिया जाए: Java_package_name_ClassName_methodName । दूसरा पंजीकरण रजिस्टर करने वाले फ़ंक्शन को कॉल करके लाइब्रेरी (JNI_OnLoad फ़ंक्शन में) लोड करते समय इसे पंजीकृत करना है। हमारे मामले में, यदि आप पहली विधि का उपयोग करते हैं, तो नाम इस तरह होना चाहिए: Java_com_taobao_wireless_security_adapter_JNICLibrary_doCommandNative । निर्यात किए गए कार्यों की सूची में यह नाम शामिल नहीं है, जिसका अर्थ है कि हमें RegisterNatives की तलाश करनी होगी। इस प्रकार, हम JNI_OnLoad फ़ंक्शन पर जाते हैं और निम्नलिखित देखते हैं:



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

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

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



0xB144 से शुरू होकर, हमारे पास स्पष्ट रूप से टेबल है। लेकिन sub_494C के बारे में क्या?



एलआर रजिस्टर में इस फ़ंक्शन को कॉल करते समय, हमें उपरोक्त तालिका (0xB144) का पता मिलता है। इस तालिका में R0 में सूचकांक है। यही है, हम तालिका से मूल्य लेते हैं, इसे LR में जोड़ते हैं, और उस पते को प्राप्त करते हैं जिसे हमें जाने की आवश्यकता है। आइए इसे गणना करने का प्रयास करें: 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 को देखते हैं:



दरअसल, यह LR से पते पर DWORD लेता है, इस पते पर जोड़ता है, फिर परिणामी पते पर मान लेता है और स्टैक में संग्रहीत करता है। इसके अतिरिक्त, यह फ़ंक्शन से लौटने के बाद इसी ऑफसेट को कूदने के लिए 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 निर्देश के बाद एक ऑफसेट है:



हम LR से पते पर ऑफसेट लेते हैं, इसे LR में जोड़ते हैं, और वहां नेविगेट करते हैं। 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 फ़ंक्शन वर्ग नाम को डिक्रिप्ट करता है। इस फ़ंक्शन के पैरामीटर्स में डेटा के लिए एक संकेतक होता है जो एन्क्रिप्टेड, एक प्रकार के बफर और एक नंबर के समान दिखता है। जाहिर है, एक डिक्रिप्टेड स्ट्रिंग फ़ंक्शन के लिए एक कॉल के बाद बफर में होगी, क्योंकि बफर फाइंडक्लास फ़ंक्शन में जाता है, जो दूसरे पैरामीटर के समान वर्ग नाम प्राप्त करता है। तो संख्या बफर के आकार या स्ट्रिंग की लंबाई है। कक्षा के नाम को डिक्रिप्ट करने का प्रयास करते हैं। यह इंगित करना चाहिए कि क्या हम सही दिशा में जा रहे हैं। आइए 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; } 

उप_7AF78 फ़ंक्शन निर्दिष्ट आकार के बाइट सरणियों के लिए एक कंटेनर उदाहरण बनाता है (हम उन पर विस्तार से ध्यान नहीं देंगे)। ऐसे दो कंटेनर यहां बनाए गए हैं: एक में स्ट्रिंग " DcO / lcK + h? M3c * q @ " है (यह अनुमान लगाना आसान है कि यह कुंजी है), दूसरे में एन्क्रिप्टेड डेटा है। दोनों ऑब्जेक्ट्स को एक निश्चित संरचना में रखा जाता है, जो सब_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; } 

पहले से असाइन किए गए मान 3 के साथ फ़ील्ड को स्विच पैरामीटर के रूप में परिवर्तित किया जाता है। आइए केस 3 पर एक नज़र डालें - पैरामीटर जो पिछले फ़ंक्शन को संरचना में जोड़ा गया है (यानी, कुंजी और एन्क्रिप्टेड डेटा) सब_6364C फ़ंक्शन में परिवर्तित हो जाते हैं। यदि हम sub_6364C को करीब से देखते हैं, तो हम RC4 एल्गोरिथम को पहचान सकते हैं।

इसलिए हमारे पास एक एल्गोरिथ्म और एक कुंजी है। कक्षा के नाम को डिक्रिप्ट करने का प्रयास करते हैं। यह वही है जो हमें मिला है: कॉम / टैयूबोइस / वायरलेस / सुरक्षा / एडाप्टर / जेएनआईसीयूलेट्स। शानदार! हम सही रास्ते पर हैं।

कमान का पेड़

अब हमें RegisterNatives पर कॉल खोजने की आवश्यकता है, जो हमें doCommandNative फ़ंक्शन के लिए इंगित करेगा। इसलिए हम JNI_OnLoad से बुलाए गए कार्यों को देखते हैं , और इसे सब_7B0 में खोजें :

 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)। ये तीन नंबर, साथ ही जेएनआईएनईवी के सूचक और फ़ंक्शन में स्थानांतरित किए गए तर्क, एक संरचना बनाते हैं और पास किए जाते हैं। इन तीन नंबरों के साथ (हम उन्हें एन 1, एन 2 और एन 3 का संकेत देंगे), एक कमांड ट्री का निर्माण किया जाता है। कुछ इस तरह:



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

अधिक आपत्ति

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

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

हम तो R7 और R4 में दो सूचकांकों को धक्का देते हैं:



पहला सूचकांक R11 में जाता है:



तालिका से पता प्राप्त करने के लिए हम इस सूचकांक का उपयोग करते हैं:



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

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



परिणामी कोड भयावह है।हालाँकि, हम कॉल को देख सकते हैं परिचित उप_6115C फ़ंक्शन को इसकी स्पर्शरेखा में:



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



यह एईएस है!

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

पैच

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

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



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

फोपेन फ़ंक्शन का उपयोग करके, हम "ab" मोड में / डेटा / स्थानीय / tmp / aes फ़ाइल खोलते हैं (ताकि हम कुछ जोड़ सकें)। फिर हम फ़ाइल नाम पते को R0 और स्ट्रिंग पते में लोड करते हैं जो R1 में मोड को इंगित करता है। यह वह जगह है जहां कचरा कोड समाप्त होता है, इसलिए हम अगले फ़ंक्शन पर जाते हैं। चूंकि हम चाहते हैं कि यह काम करना जारी रखे, तो हम संक्रमण को कचरा से पहले, शुरुआत में वास्तविक फ़ंक्शन कोड में डालते हैं, और कचरे को बाकी पैच के साथ बदल देते हैं।



हम तो फोपेन कहते हैं।

एईएस फ़ंक्शन के पहले तीन पैरामीटर अंतर प्रकार के हैं। चूंकि हमने शुरुआत में रजिस्टरों को स्टैक पर धकेल दिया था, इसलिए हम स्टैक में उनके पते को फाइटाइट फ़ंक्शन में स्थानांतरित कर सकते हैं।



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



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

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



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

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



यह LEB128 एनकोडेड है। पैच संकुचित लाइब्रेरी के आकार को थोड़ा बदल देता है, इसलिए ब्राउज़र ने तय किया कि संग्रह कई बार डाउनलोड करने के बाद त्रुटि पर टूट गया और एक त्रुटि प्रदर्शित की।
तो हम संग्रह आकार और ... वॉइला को ठीक करते हैं! :) वीडियो में देखें परिणाम।

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

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

हमने यूसी ब्राउज़र डेवलपर्स से संपर्क किया और उन्हें मिली समस्या के बारे में सूचित किया, भेद्यता और उसके खतरे को इंगित करने की कोशिश की, लेकिन उन्होंने इस मामले पर चर्चा करने से इनकार कर दिया। इस बीच, खतरनाक फ़ंक्शन वाला ब्राउज़र सादे दृश्य में रहा। यद्यपि जैसे ही हमने भेद्यता का विवरण प्रकट किया, पहले की तरह इसे अनदेखा करना असंभव था। UC Browser का एक नया संस्करण 10.10.9.1193 27 मार्च को जारी किया गया था, जिसने HTTPS puds.ucweb.com/upgrad/index.xhtml के माध्यम से सर्वर तक पहुँचा।। इसके अलावा, "बग फिक्सिंग" और समय के बीच हमने यह लेख लिखा, ब्राउज़र में एक पीडीएफ खोलने के प्रयास के परिणामस्वरूप पाठ के साथ एक त्रुटि संदेश आया, "उफ़, कुछ गड़बड़ है।" पीडीएफ फाइल को खोलने की कोशिश करने पर सर्वर से कोई अनुरोध नहीं किया गया था। यह स्टार्टअप पर प्रदर्शन किया गया था, हालांकि, यह एक संकेत है कि Google Play नीतियों के उल्लंघन में निष्पादन योग्य कोड डाउनलोड करने की क्षमता अभी भी मौजूद है।