Hľadáme zraniteľnosti v UC Browser

Hľadáme zraniteľnosti v UC Browser

Úvod

Na konci marca sme hlásili, že sme objavili skrytú možnosť načítania a spustenia neovereného kódu v UC Browser. Dnes sa podrobne pozrieme na to, ako k tomuto načítaniu dochádza a ako ho môžu hackeri využiť vo svojich cieľoch.

Pred niekoľkými mesiacmi UC Browser agresívne propagovali a distribuovali: inštalovali ho na zariadenia používateľov prostredníctvom škodlivého softvéru, šírili ho z rôznych stránok pod zámienkou video súborov (t. j. používatelia si mysleli, že sťahujú napríklad porno video, ale namiesto toho dostali APK s týmto prehliadačom) a využívali strašidelné bannery s hláseniami o tom, že prehliadač je zastaraný, zraniteľný a podobne. V oficiálnej skupine UC Browser na VK existuje tématická, kde môžu používatelia nahlásiť nekalú reklamu, je tam mnoho príkladov. V roku 2016 bola dokonca videoreklama v ruštine (áno, reklama prehliadača, ktorý blokuje reklamu).

V čase písania tohto článku UC Browser dosiahol viac ako 500 000 000 inštalácií v Google Play. To je pôsobivé — viac ich má len Google Chrome. Medzi hodnoteniami je vidieť množstvo sťažností na reklamu a presmerovania na rôzne aplikácie v Google Play. To nás priviedlo k výskumu: rozhodli sme sa zistiť, či UC Browser nerobí niečo nekalé. A ukázalo sa, že áno!

V kóde aplikácie sme objavili možnosť načítať a spustiť vykonávací kód, čo je v rozpore s pravidlami publikovania aplikácií v Google Play. Okrem toho, že UC Browser načítava vykonávací kód, robí to aj nezabezpečene, čo sa dá využiť na vykonanie útoku MitM. Pozrime sa, či sa nám takýto útok podarí realizovať.

Všetko, čo je napísané ďalej, platí pre verziu UC Browser, ktorá bola prítomná v Google Play v čase vykonávania výskumu:

package: com.UCMobile.intl
versionName: 12.10.8.1172
versionCode: 10598
sha1 APK súboru: f5edb2243413c777172f6362876041eb0c3a928c

Vektor útoku

V manifeste UC Browser môžeme objaviť službu s výstižným názvom com.uc.deployment.UpgradeDeployService.

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

Pri spustení tejto služby prehliadač vykonáva POST požiadavku na puds.ucweb.com/upgrade/index.xhtml, ktorý je možné zaznamenať v prenosoch po určitom čase po spustení. V odpovedi môže dostať príkaz na načítanie nejakého aktualizovania alebo nového modulu. Počas analýzy server takýchto príkazov nedával, ale všimli sme si, že pri pokuse o otvorenie PDF v prehliadači vykonáva opakovaný dotaz na uvedenú adresu, po ktorom stiahne natívnu knižnicu. Na vykonanie útoku sme sa rozhodli využiť túto vlastnosť UC Browser: schopnosť otvárať PDF pomocou natívnej knižnice, ktorá nie je v APK a ktorú v prípade potreby načíta z internetu. Je potrebné poznamenať, že teoreticky je možné do UC Browseru donútiť na niečo stiahnuť aj bez interakcie s používateľom – ak sa doručí správne formovaná odpoveď na požiadavok, ktorý sa vykonáva po spustení prehliadača. Ale na to je potrebné podrobnejšie študovať protokol interakcie so serverom, preto sme sa rozhodli, že bude jednoduchšie upraviť zachytenú odpoveď a nahradiť knižnicu na prácu s PDF.

Takže, keď si používateľ chce otvoriť PDF priamo v prehliadači, v prenosoch je možné vidieť nasledujúce požiadavky:

Hľadáme zraniteľnosti v UC Browser

Najskôr ide POST-žiadosti na puds.ucweb.com/upgrade/index.xhtml, po čom
sa stiahne archív s knižnicou na zobrazenie PDF a kancelárskych formátov. Je logické predpokladať, že v prvej žiadosti sa odosiela informácia o systéme (minimálne architektúra, aby sa odovzdala správna knižnica), a v odpovedi na ňu prehliadač dostáva nejaké informácie o knižnici, ktorú je potrebné stiahnuť: adresu a možno aj niečo ďalšie. Problém je v tom, že táto požiadavka je zašifrovaná.

Fragment požiadavky

Fragment odpovede

Hľadáme zraniteľnosti v UC Browser

Hľadáme zraniteľnosti v UC Browser

Samotná knižnica je zabalená v ZIP a nie je zašifrovaná.

Hľadáme zraniteľnosti v UC Browser

Vyhľadávanie dešifrovacieho kódu prenosu

Pokúsme sa dešifrovať odpoveď servera. Pozrime sa na kód triedy com.uc.deployment.UpgradeDeployService: z metódy onStartCommand prechádzame do com.uc.deployment.b.x, a z neho do com.uc.browser.core.d.c.f.e:

    verejná posledná 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("]produkt:");
            v4.append(arg9.iGX.ipR);
            v4 = new StringBuilder("[");
            v4.append(v3_1);
            v4.append("]verzia:");
            v4.append(arg9.iGX.iEn);
            v4 = new StringBuilder("[");
            v4.append(v3_1);
            v4.append("]typ_upgradu:");
            v4.append(arg9.iGX.mMode);
            v4 = new StringBuilder("[");
            v4.append(v3_1);
            v4.append("]významná_zmena:");
            v4.append(arg9.iGX.iEo);
            v4 = new StringBuilder("[");
            v4.append(v3_1);
            v4.append("]tichý_režim:");
            v4.append(arg9.iGX.iDQ);
            v4 = new StringBuilder("[");
            v4.append(v3_1);
            v4.append("]typ_tichého_režimu:");
            v4.append(arg9.iGX.iEr);
            v4 = new StringBuilder("[");
            v4.append(v3_1);
            v4.append("]stav_tichého_režimu:");
            v4.append(arg9.iGX.iEp);
            v4 = new StringBuilder("[");
            v4.append(v3_1);
            v4.append("]tichý_súbor:");
            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("]typ_stiahnutia:");
            v4.append(arg9.mDownloadType);
            v4 = new StringBuilder("[");
            v4.append(v3_1);
            v4.append("]skupina_stiahnutia:");
            v4.append(arg9.mDownloadGroup);
            v4 = new StringBuilder("[");
            v4.append(v3_1);
            v4.append("]cesta_stiahnutia:");
            v4.append(arg9.iGH);
            v4 = new StringBuilder("[");
            v4.append(v3_1);
            v4.append("]apollo_detská_verzia:");
            v4.append(arg9.iGX.iEx);
            v4 = new StringBuilder("[");
            v4.append(v3_1);
            v4.append("]apollo_séria:");
            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("]názov_zložky:");
                    v5.append(((au)v4_1).getName());
                    v5 = new StringBuilder("[");
                    v5.append(((au)v4_1).getName());
                    v5.append("]verzia_názvu_zložky:");
                    v5.append(((au)v4_1).aDA());
                    v5 = new StringBuilder("[");
                    v5.append(((au)v4_1).getName());
                    v5.append("]verzia_kódu_zložky:");
                    v5.append(((au)v4_1).gBl);
                    v5 = new StringBuilder("[");
                    v5.append(((au)v4_1).getName());
                    v5.append("]typ_požiadavky_zložky:");
                    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("verz_os", c.getRomInfo()));
            v3_2.add(g.fs("arch_procesora", 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("typ_nets", String.valueOf(com.uc.base.system.a.Jo())));
            v3_2.add(g.fs("z_hosta", arg9.iGX.iEm));
            v3_2.add(g.fs("verzia_pluginu", arg9.iGX.iEn));
            v3_2.add(g.fs("cílový_jazyk", 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_detská_verzia", arg9.iGX.iEx));
            v3_2.add(g.fs("verzia_série", arg9.iGX.iEw));
            v3_2.add(g.fs("detská_verzia", r.aVw()));
            v3_2.add(g.fs("aktuálna_verzia_md5", arg9.iGX.iEl));
            v3_2.add(g.fs("aktuálny_podpis_verzie", SystemHelper.getUCMSignature()));
            v3_2.add(g.fs("denník_upgradu", i.bjt()));
            v3_2.add(g.fs("tichá_inštalácia", String.valueOf(arg9.iGX.iDQ)));
            v3_2.add(g.fs("stav_tichého_režimu", String.valueOf(arg9.iGX.iEp)));
            v3_2.add(g.fs("tichý_súbor", arg9.iGX.iEq));
            v3_2.add(g.fs("typ_tichého_režimu", String.valueOf(arg9.iGX.iEr)));
            v3_2.add(g.fs("arch_cpu", com.uc.b.a.a.c.Pc()));
            v3_2.add(g.fs("nastavenie_cpu", 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("jadra_cpu", 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("celková_ram", 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("level_api", 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", "áno", "neúspech");
            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", "áno", "neúspech");
            return;
        }
 
        if(TextUtils.isEmpty(this.iGY.mUpgradeUrl)) {
            this.iGY.iGI.a(arg9, "up_url", "áno", "neúspech");
            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", "áno", "úspech");
        this.iGY.iGI.b(arg9);
    }

Vidíme tu formovanie POST-žiadosti. Zameriavame sa na vytvorenie poľa o veľkosti 16 bajtov a jeho vyplnenie: 0x5F, 0, 0x1F, -50 (=0xCE). Zodpovedá tomu, čo sme videli v predchádzajúcej žiadosti.

V tejto istej triede si môžeme všimnúť vnorenú triedu, v ktorej je iná zaujímavá metóda:

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

Metóda prijíma na vstupe pole bajtov a overuje, že nulový bajt je rovný 0x60 alebo tretí bajt je rovný 0xD0, a druhý bajt je 1, 11 alebo 0x1F. Pozrime sa na odpoveď servera: nulový bajt — 0x60, druhý — 0x1F, tretí — 0x60. Zdá sa, že to, čo potrebujeme. Súd podľa riadkov (napríklad „up_decrypt“) by tam mala byť volaná metóda, ktorá dešifruje odpoveď servera.
Prejdime k metóde g.j. Všimnime si, že ako prvý argument sa do nej posiela bajt na offsete 2 (t. j. 0x1F v našom prípade), a ako druhý — odpoveď servera bez
prvých 16 bajtov.

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

Jasne, tu prebieha výber algoritmu dešifrovania a ten bajt, ktorý v našom
v prípade je 0x1F, označuje jeden z troch možných variantov.

Pokračujeme v analýze kódu. Po niekoľkých skokoch sa dostávame do metódy s názvom decryptBytesByKey.

Tým sa od našej odpovede oddeľujú ešte dva bajty a z nich sa vytvára reťazec. Je jasné, že týmto spôsobom sa vyberá kľúč na dešifrovanie správy.

    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 bajty
                    System.arraycopy(bytes, 0, prefix, 0, prefix.length);
                    String keyId = c.ayR().d(ByteBuffer.wrap(prefix).getShort()); // Výber kľúča
                    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;
    }

Navyše, zdôraznime, že v tomto štádiu sa nezískava ešte kľúč, ale len jeho "identifikátor". S získaním kľúča je to už trochu zložitejšie.

V nasledujúcej metóde sa k existujúcim parametrom pridávajú ešte dva, takže ich je štyri: magické číslo 16, identifikátor kľúča, zašifrované údaje a nejasný reťazec (v našom prípade prázdny).

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

Po sérii prechodov prichádzame k metóde staticBinarySafeDecryptNoB64 rozhranie com.alibaba.wireless.security.open.staticdataencrypt.IStaticDataEncryptComponent. V hlavnom kóde aplikácie nie sú triedy implementujúce tento rozhranie. Takáto trieda sa nachádza vo súbore lib/armeabi-v7a/libsgmain.so, ktorý je v skutočnosti .jar, nie .so. Nám zaujímavá metóda je implementovaná nasledovne:

balík com.alibaba.wireless.security.a.i;
 
// ...
 
verejná trieda a implementuje IStaticDataEncryptComponent {
    súkromné ISecurityGuardPlugin a;
// ...
    súkromné byte[] a(int mód, int magickýInt, int xzInt, String keyId, byte[] šifrované, String magickáString) {
        return this.a.getRouter().doCommand(10601, new Object[]{Integer.valueOf(mód), Integer.valueOf(magickýInt), Integer.valueOf(xzInt), keyId, šifrované, magickáString});
    }
// ...
    súkromné byte[] b(int magickýInt, String keyId, byte[] šifrované, String magickáString) {
        return this.a(2, magickýInt, 0, keyId, šifrované, magickáString);
    }
// ...
    verejná byte[] staticBinarySafeDecryptNoB64(int magickýInt, String keyId, byte[] šifrované, String magickáString) hádže SecException {
        if(keyId != null && keyId.length() > 0 && magickýInt >= 0 && magickýInt  0) {
            return this.b(magickýInt, keyId, šifrované, magickáString);
        }
 
        throw new SecException("", 301);
    }
//...
}

Tu sa náš zoznam parametrov dopĺňa ešte dvoma celými číslami: 2 a 0. Podľa všetkého
2 znamená dešifrovanie, ako v metóde doFinal systémovej triedy javax.crypto.Cipher. A všetko toto sa prenáša do akéhosi Router s číslom 10601 — to je pravdepodobne číslo príkazu.

Po ďalšej reťazci prechodov nachádzame triedu, ktorá implementuje rozhranie IRouterComponent a metóda doCommand:

balík com.alibaba.wireless.security.mainplugin;

import com.alibaba.wireless.security.framework.IRouterComponent;
import com.taobao.wireless.security.adapter.JNICLibrary;
 
verejná trieda a implementuje IRouterComponent {
    verejná a() {
        super();
    }
    verejná Objekt doCommand(int arg2, Objekt[] arg3) {
        return JNICLibrary.doCommandNative(arg2, arg3);
    }
}

A tiež trieda JNICLibrary, v ktorej je vyhlásená natívna metóda doCommandNative:

balík com.taobao.wireless.security.adapter;
 
verejná trieda JNICLibrary {
    verejná statická natívna Objekt doCommandNative(int arg0, Objekt[] arg1);
}

To znamená, že v natívnom kóde musíme nájsť metódu doCommandNative. A tu sa začína to najzábavnejšie.

Obfuskácia strojového kódu

V súbore libsgmain.so (ktorý je v skutočnosti .jar a v ktorom sme trochu vyššie našli implementáciu niektorých rozhraní spojených s šifrovaním) existuje jedna natívna knižnica: libsgmainso-6.4.36.so. Otvárame ju v IDA a dostávame množstvo dialógových okien s chybami. Problém je v tom, že tabuľka sekcií (section header table) – nie je platná. To je urobené schválne, aby sa analýza sťažovala.

Hľadáme zraniteľnosti v UC Browser

Ale ani nie je potrebná: na to, aby sme správne načítali ELF súbor a analyzovali ho, stačí tabuľka segmentov (program header table). Preto jednoducho vymažeme tabuľku sekcií, nulovaním príslušných polí v hlavičke.

Hľadáme zraniteľnosti v UC Browser

Znovu otvárame súbor v IDA.

Existujú dva spôsoby, ako informovať virtuálnu Java mašinu, kde presne sa v natívnej knižnici nachádza implementácia metódy, vyhlásenej v Java kóde ako natívna. Prvý — dať mu názov ako Java_názov_paketu_NázovTriedy_názovMetódy.

Druhý — zaregistrovať ho pri načítaní knižnice (v funkcii JNI_OnLoad)
pomocou volania funkcie RegisterNatives.

V našom prípade, ak použijeme prvý spôsob, názov by mal byť takýto: Java_com_taobao_wireless_security_adapter_JNICLibrary_doCommandNative.

Medzi exportovanými funkciami taká nie je, takže treba hľadať volanie RegisterNatives.
Ideme do funkcie JNI_OnLoad a vidíme takýto obrazec:

Hľadáme zraniteľnosti v UC Browser

Čo sa tu deje? Na prvý pohľad, začiatok a koniec funkcie sú typické pre architektúru ARM. Prvou inštrukciou sa do zásobníka ukladá obsah registrov, ktoré funkcia použije vo svojej práci (v tomto prípade R0, R1 a R2), ako aj obsah registra LR, v ktorom je adresa návratu z funkcie. Poslednou inštrukciou sa uložené registry obnovia, pričom adresa návratu sa okamžite umiestni do registra PC — takto prebieha návrat z funkcie. Ale ak sa pozorne pozrieme, môžeme si všimnúť, že predposledná inštrukcia mení adresu návratu uloženú v zásobníku. Vypočítajme, aká bude po
vykonaní kódu. Do R1 sa načíta určitá adresa 0xB130, od ktorej sa odčíta 5, potom sa presunie do R0 a pripočíta sa 0x10. Dostaneme 0xB13B. Takto IDA myslí, že v poslednej inštrukcii dochádza k bežnému návratu z funkcie, ale v skutočnosti prebieha prechod na vypočítanú adresu 0xB13B.

Tu stojí za pripomenutie, že procesory ARM majú režim a dva súbory inštrukcií: ARM a Thumb. Mínusový bit adresy hovorí procesoru, ktorý súbor inštrukcií sa používa. To znamená, že adresa je v skutočnosti 0xB13A, pričom jednotka v mínusovom bitem označuje režim Thumb.

Na začiatku každej funkcie v tejto knižnici je pridaný podobný "prevodník" a
neužitočný kód. Ďalej sa na nich nebudeme podrobne zastavovať – jednoducho si pamätáme,
že skutočný začiatok takmer všetkých funkcií je o niečo ďalej.

Keďže v kóde nie je jasný prechod na 0xB13A, IDA sama neidentifikovala, že sa na tomto mieste nachádza kód. Z rovnakého dôvodu veľkú časť kódu v knižnici neidentifikuje ako kód, čo mierne sťažuje analýzu. Povieme IDA, že tu je kód, a tu je, čo sa stane:

Hľadáme zraniteľnosti v UC Browser

Na 0xB144 jasne začína tabuľka. A čo je v sub_494C?

Hľadáme zraniteľnosti v UC Browser

Pri volaní tejto funkcie dostaneme v registri LR adresu spomínanej tabuľky (0xB144). V R0 — index v tejto tabuľke. To znamená, že sa vezme hodnota z tabuľky, pripočíta k LR a dostaned.
adresa, na ktorú sa má prejsť. Pokúsime sa ju vypočítať: 0xB144 + [0xB144 + 8* 4] = 0xB144 + 0x120 = 0xB264. Prejdeme na získanú adresu a vidíme doslova pár užitočných pokynov a opäť prechod na 0xB140:

Hľadáme zraniteľnosti v UC Browser

Teraz sa bude prechádzať s posunom s indexom 0x20 z tabuľky.

Súdiac podľa veľkosti tabuľky, takých prechodov v kóde narazíme mnoho. Vzniká otázka, či sa s tým dá nejako efektívnejšie zaobchádzať, bez ručného výpočtu adries. A na pomoc nám prichádzajú skripty a možnosť patchovať kód v IDA:

def put_unconditional_branch(source, destination):
    offset = (destination - source - 4) >> 1
    if offset > 2097151 or offset  1023 or 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 "Nesprávny typ operandu na", hex(ea1), "-", get_operand_type(ea1, 0), get_operand_type(ea1, 1)
            table = None
        if table is None:
            print "Nemožno nájsť tabuľku"
        else:
            print "table =", hex(table)
            offset = get_wide_dword(table + (index << 2))
            put_unconditional_branch(ea, table + offset)
    else:
        print "Neznámy kód", get_operand_type(ea1, 0), get_operand_value(ea1, 0), get_operand_type(ea1, 1) == 2
else:
    print "Nemožno detekovať prvý inštrukciu"

Umiesťujeme kurzor na riadok 0xB26A, spúšťame skript a vidíme prechod na 0xB4B0:

Hľadáme zraniteľnosti v UC Browser

IDA opäť nepoznala tento úsek ako kód. Pomáhame jej a vidíme tam inú konštrukciu:

Hľadáme zraniteľnosti v UC Browser

Inštrukcie po BLX nevyzerajú veľmi zmysluplne, skôr pripomínajú nejaké posunutie. Pozrieme sa na sub_4964:

Hľadáme zraniteľnosti v UC Browser

A skutočne, tu sa berie dword z adresy, ktorá leží v LR, k tomu sa pripočítava táto adresa, po čom sa berie hodnota z získanej adresy a ukladá sa na zásobník. K LR sa zasa pripočíta 4, aby po návrate z funkcie preskočil toto posunutie. Následne príkaz POP {R1} vyťahuje získanú hodnotu zo zásobníka. Ak sa pozrieme, čo sa nachádza na adrese 0xB4BA + 0xEA = 0xB5A4, môžeme vidieť niečo podobné tabuľke adries:

Hľadáme zraniteľnosti v UC Browser

Na to, aby ste upravili túto konštrukciu, budete potrebovať získať dva parametre z kódu: offset a číslo registra, do ktorého treba uložiť výsledok. Pre každý možný register bude potrebné vopred pripraviť kúsok kódu.

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 <> 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 "Inštrukcia POP nebola nájdená"
    else:
        print "Nesprávny typ operandu na +4:", get_operand_type(ea + 4, 0)
else:
    print "Nemožno detekovať prvé inštrukcie"

Umiesťte kurzor na začiatok konštrukcie, ktorú chcete nahradiť — 0xB4B2 — a spustite skript:

Hľadáme zraniteľnosti v UC Browser

Okrem už uvedených konštrukcií sa v kóde nachádzajú aj takéto:

Hľadáme zraniteľnosti v UC Browser

Ako v predchádzajúcom prípade, aj po inštrukcii BLX nasleduje offset:

Hľadáme zraniteľnosti v UC Browser

Vezmeme offset podľa adresy z LR, pripočítame ho k LR a prejdeme tam. 0x72044 + 0xC = 0x72050. Skript pre túto konštrukciu je veľmi jednoduchý:

def put_unconditional_branch(source, destination):
    offset = (destination - source - 4) >> 1
    if offset > 2097151 or offset  1023 or 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 "Nemožno detekovať prvú inštrukciu"

Výsledok vykonania skriptu:

Hľadáme zraniteľnosti v UC Browser

Po tom, ako je funkcia kompletne upravená, môžete IDA nasmerovať na jej skutočný začiatok. Zbiera celý kód funkcie po častiach, ktoré môžete dekompilovať pomocou HexRays.

Dekódovanie reťazcov

Naučili sme sa bojovať s obfuskovaním strojového kódu v knižnici libsgmainso-6.4.36.so z UC Browser a získali sme kód funkcie 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;
}

Pozrime sa bližšie na nasledujúce riadky:

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

Vo funkcii sub_73E24 sa zjavne vykonáva dešifrovanie názvu triedy. Ako parametre tejto funkcie sa predáva ukazovateľ na údaje, ktoré vyzerajú ako zašifrované, nejaký buffer a číslo. Je zrejmé, že po zavolaní funkcie bude v buffere dešifrovaný reťazec, keďže sa predáva funkcii FindClass, ktorá ako druhý parameter prijíma názov triedy. Odtiaľto je jasné, že číslo je veľkosť bufferu alebo dĺžka reťazca. Skúsme dešifrovať názov triedy, malo by nám ukázať, či ideme správnym smerom. Poďme sa podrobnejšie pozrieť, čo sa deje v 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;
}

Funkcia sub_7AF78 vytvára inštanciu kontajnera pre bajtové polia požadovanej veľkosti (nebudeme podrobne rozoberať tieto kontajnery). Tieto dva kontajnery sa vytvárajú: jeden z nich obsahuje reťazec „DcO/lcK+h?m3c*q@” (nie je ťažké uhádnuť, že ide o kľúč), druhý – šifrované dáta. Obe objekty sú následne umiestnené do určitej štruktúry, ktorá je odovzdaná funkcii sub_6115C. Takisto zaznamenajme v tejto štruktúre pole so hodnotou 3. Pozrime sa, čo sa s touto štruktúrou deje ďalej.

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

Ako parameter switch sa prenáša pole štruktúry, ktorému bolo predtým priradené hodnoty 3. Pozrime sa na case 3: do funkcie sub_6364C sú prenášané parametre zo štruktúry, ktoré boli uložené v predchádzajúcej funkcii, t.j. kľúč a zašifrované údaje. Ak sa pozrieme na sub_6364C, môžeme v ňom spoznať algoritmus RC4.

Máme algoritmus a kľúč. Skúsime dešifrovať názov triedy. Toto je výsledok: com/taobao/wireless/security/adapter/JNICLibrary. Výborne! Sme na správnej ceste.

Strom príkazov

Teraz musíme nájsť volanie RegisterNatives, ktoré nás nasmeruje na funkciu doCommandNative. Prezeráme sa funkciám, ktoré sa volajú z JNI_OnLoad, a nachádzame ho v 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;
}

A naozaj, tu sa registruje natívna metóda s názvom doCommandNative. Teraz poznáme jej adresu. Pozrime sa, čo robí.

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

Podľa názvu sa dá predpokladať, že tu je vstupný bod všetkých funkcií, ktoré sa vývojári rozhodli presunúť do natívnej knižnice. Zaujíma nás funkcia s číslom 10601.

Z kódu môžeme vidieť, že z čísla príkazu sa získajú tri čísla: command / 10000, command % 10000 / 100 a command % 10, t.j., v našom prípade, 1, 6 a 1. Tieto tri čísla, ako aj ukazovateľ na JNIEnv a argumenty odovzdané funkcii, sa uložia do štruktúry a posunú sa ďalej. Pomocou týchto získaných troch čísel (označíme ich N1, N2 a N3) sa vytvára strom príkazov.

Približne takto:

Hľadáme zraniteľnosti v UC Browser

Strom sa dynamicky zapĺňa v JNI_OnLoad.
Tri čísla kódujú cestu v strome. Každý list stromu obsahuje adresu príslušnej funkcie. Kľúč je v rodičovskom uzle. Nájsť miesto v kóde, kde sa do stromu pridáva požadovaná funkcia, nie je ťažké, ak sa vyznáte vo všetkých používaných štruktúrach (ich opis nezverejňujeme, aby sme neprerástli už aj tak rozsiahly článok).

Ešte obfuskovanie

Dostali sme adresu funkcie, ktorá má dešifrovať prenos: 0x5F1AC. Ale netešme sa predčasne: vývojári UC Browser nám pripravili ďalšie prekvapenie.

Po získaní parametrov z poľa, ktoré bolo vytvorené v Java kóde, sa dostávame
do funkcie na adrese 0x4D070. A tu nás čaká ďalší typ obfuskovania kódu.

Vkladáme do R7 a R4 dva indexy:

Hľadáme zraniteľnosti v UC Browser

Prenášame prvý index do R11:

Hľadáme zraniteľnosti v UC Browser

Aby sme získali adresu z tabuľky, používame index:

Hľadáme zraniteľnosti v UC Browser

Po prechode na prvú adresu sa používa druhý index, ktorý je v R4. V tabuľke je 230 prvkov.

Čo s tým robiť? Môžeme povedať IDA, že toto je taký switch: Edit -> Other -> Specify switch idiom.

Hľadáme zraniteľnosti v UC Browser

Získaný kód je hrozný. Ale prechádzajúc jeho zložitosťami, môžeme si všimnúť volanie už známej funkcie sub_6115C:

Hľadáme zraniteľnosti v UC Browser

Tam bol switch, v ktorom v case 3 bola dešifrovanie s použitím algoritmu RC4. A v tomto prípade sa štruktúra posielaná do funkcie vyplňuje z parametrov, ktoré boli odoslané v doCommandNative. Pripomíname si, že sme tam mali magicInt s hodnotou 16. Sledujeme príslušný case – a po niekoľkých prechodoch nachádzame kód, podľa ktorého môžeme identifikovať algoritmus.

Hľadáme zraniteľnosti v UC Browser

To je AES!

Algoritmus máme, zostáva získať jeho parametre: režim, kľúč a, možno, inicializačný vektor (jeho existencia závisí od režimu práce algoritmu AES). Štruktúra s nimi by sa mala vytvárať niekde pred volaním funkcie sub_6115C, ale táto časť kódu je obfuskovaná obzvlášť dobre, takže prichádza na myseľ nápad patchovať kód, aby sa všetky parametre funkcie dešifrovania dumpovali do súboru.

Patch

Aby sme nemuseli písať celý kód patchu v assembleri ručne, môžeme spustiť Android Studio, napísať tam funkciu, ktorá dostáva rovnaké parametre ako naša funkcia dešifrovania a zapisuje do súboru, po čom skopírujeme kód, ktorý vygeneruje kompilátor.

O komforte pridávania kódu sa postarali aj naši priatelia z tímu UC Browser. Spomíname, že na začiatku každej funkcie máme odpadový kód, ktorý sa dá ľahko nahradiť akýmkoľvek iným. Je to veľmi praktické 🙂 Pravda, na začiatku cieľovej funkcie nie je veľa miesta na kód, ktorý ukladá všetky parametre do súboru, preto sme ho museli rozdeliť na časti a použiť odpadové bloky susedných funkcií. Nakoniec sme dostali štyri časti.

Prvá časť:

Hľadáme zraniteľnosti v UC Browser

V architektúre ARM sa prvé štyri parametre funkcie prenášajú cez registre R0-R3, ostatné, ak existujú, cez zásobník. V registri LR sa prenáša adresa návratu. To všetko je potrebné uchovať, aby mohla funkcia fungovať po tom, čo vy dumpneme jej parametre. Tiež je potrebné uložiť všetky registre, ktoré budeme používať počas procesu, preto robíme PUSH.W {R0-R10,LR}. V R7 získavame adresu zoznamu parametrov poslaných funkcii cez zásobník.

S pomocou funkcie fopen otvoríme súbor /data/local/tmp/aes v režime „ab“,
t. j. na pridanie. Do R0 načítame adresu názvu súboru, do R1 — adresu reťazca s určením režimu. A tu odpadový kód končí, preto prechádzame do ďalšej funkcie. Aby mohla pokračovať v práci, vložíme na začiatok prechod na skutečný kód funkcie obchádzajúc odpad, a namiesto odpadového kódu pridáme pokračovanie záplaty.

Hľadáme zraniteľnosti v UC Browser

Voláme fopen.

Prvé tri parametre funkcie aes majú typ int. Keďže sme na začiatku uložili registre do zásobníka, môžeme jednoducho preniesť funkcii fwrite ich adresy v zásobníku.

Hľadáme zraniteľnosti v UC Browser

Ďalej máme tri štruktúry, ktoré obsahujú veľkosť údajov a ukazovateľ na údaje pre kľúč, inicializačný vektor a zašifrované údaje.

Hľadáme zraniteľnosti v UC Browser

Na konci zatvoríme súbor, obnovíme registre a odovzdáme riadenie skutočnej funkcii aes.

Zostavíme APK s opravenou knižnicou, podpíšeme ju, nahodíme na zariadenie/emulátor a spustíme ju. Vidíme, že náš dump sa vytvára a zapisuje sa tam veľa údajov. Prehliadač používa šifrovanie nie len pre prenos, a všetko šifrovanie prebieha skrze zvažovanú funkciu. A potrebné údaje akosi chýbajú, a v prenosoch nie je vidno potrebný dopyt. Aby sme nečakali, kým UC Browser zláskavo vykoná potrebný dopyt, vezmeme zašifrovanú odpoveď zo servera, ktorú sme dostali skôr, a aplikáciu ešte raz opravíme: pridáme dešifrovanie do onCreate hlavnej aktivity.

    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

Zhromažďujeme, podpisujeme, inštalujeme a spúšťame. Dostávame NullPointerException, pretože metóda vrátila null.

V priebehu ďalšej analýzy kódu bola objavená funkcia, v ktorej sa dešifrujú zaujímavé riadky: „META-INF/“ a „.RSA“. Vyzerá to, že aplikácia kontroluje svoj certifikát. Alebo dokonca generuje kľúče z neho. Nechceme sa rozoberať tým, čo sa deje s certifikátom, takže mu jednoducho posunieme správny certifikát. Opatríme šifrovaný riadok tak, že namiesto „META-INF/“ dostaneme „BLABLINF/“, vytvoríme priečinok s týmto menom v APK a posunieme tam certifikát belkobrauzera.

Zhromažďujeme, podpisujeme, inštalujeme a spúšťame. Bingo! Kľúč máme!

MitM

Získali sme kľúč a vektor inicializácie, ktorý je rovný kľúču. Pokúsime sa dešifrovať odpoveď servera v režime CBC.

Hľadáme zraniteľnosti v UC Browser

Vidíme URL archívu, niečo, čo vyzerá ako MD5, „extract_unzipsize“ a číslo. Kontrolujeme: MD5 archívu sa zhoduje, veľkosť rozbalenej knižnice sa zhoduje. Pokúsime sa opraviť túto knižnicu a posunúť ju prehliadaču. Aby sme ukázali, že naša opravená knižnica sa načítala, spustíme Intent na vytvorenie SMS s textom „PWNED!“. Budeme podvádzať dve odpovede od servera: puds.ucweb.com/upgrade/index.xhtml a na stiahnutie archívu. V prvom podvádzame MD5 (veľkosť po rozbalení sa nemení), v druhom vraciame archív s opravenou knižnicou.

Prehliadač sa niekoľkokrát pokúša stiahnuť archív, po čom zobrazí chybu. Zdá sa, že mu niečo
nevyhovuje. V dôsledku analýzy tohto podivného formátu sa zistilo, že server posiela aj veľkosť archívu:

Hľadáme zraniteľnosti v UC Browser

Je zakódovaná v LEB128. Po oprave sa veľkosť archívu s knižnicou trochu zmenila, preto prehliadač usúdil, že archív sa stiahol chybne, a po niekoľkých pokusoch zobrazil chybu.

Opravená veľkosť archívu... A – víťazstvo! 🙂 Výsledok na videu.

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

Dôsledky a reakcia vývojára

Podobným spôsobom by hackeri mohli využiť nezabezpečenú funkciu UC Browser na šírenie a spúšťanie škodlivých knižníc. Tieto knižnice budú fungovať v kontexte prehliadača, a preto získajú všetky jeho systémové povolenia. V dôsledku toho budú mať možnosť zobrazovať phishingové okná a získať prístup k pracovným súborom oranžovej čínskej veveričky, vrátane prihlásení, hesiel a cookies uložených v databáze.

Spojili sme sa s vývojármi UC Browser a informovali ich o zistených problémoch, snažili sme sa poukázať na zraniteľnosť a jej nebezpečenstvo, ale niečo s nami diskutovať nechceli. A zatiaľ prehliadač naďalej predvádzal nebezpečnú funkciu pred očami všetkých. Ale keď sme odhalili detaily zraniteľnosti, ignorovať to, ako predtým, už nebolo možné. 27. marca bola
uvedená nová verzia UC Browser 12.10.9.1193, ktorá komunikovala so serverom cez HTTPS: puds.ucweb.com/upgrade/index.xhtml.

Okrem toho, po "oprave" a do chvíle napísania článku pokus o otvorenie PDF v prehliadači vyvolal zobrazenie chybového hlásenia s textom „Ups, niečo sa pokazilo!“. Požiadavka na server pri pokuse o otvorenie PDF nebola vykonaná, ale požiadavka pri spustení prehliadača bola vykonaná, čo naznačuje, že možnosť načítať vykonateľný kód v rozpore s pravidlami Google Play zostala.

Zdroj: habr.com

Kúpte si spoľahlivý hosting pre webové stránky s ochranou proti DDoS, VPS VDS servery 🔥 Kúpte si spoľahlivý hosting pre webové stránky s ochranou proti DDoS, VPS VDS servery | ProHoster