
Uvod
Krajem ožujka smo , otkrili skrivenu mogućnost preuzimanja i pokretanja neprovjerenog koda u UC Browseru. Danas ćemo detaljno objasniti kako se to preuzimanje događa i kako ga hakeri mogu iskoristiti u svoje svrhe.
Nekoliko vremena ranije UC Browser je agresivno reklamiran i distribuiran: instalirao se na uređaje korisnika putem zlonamjernih programa, dijelio se s raznih web stranica pod krinkom video datoteka (tj. korisnici su mislili da preuzimaju, na primjer, pornografski film, a umjesto toga su dobili APK s tim preglednikom), korištene su zastrašujuće reklame s porukama da je preglednik zastario, ranjiv i sl. U službenoj grupi UC Browsera na VK postoji , u kojoj korisnici mogu prijaviti nepoštene reklame, ima mnogo primjera. Godine 2016. čak je bila na ruskom jeziku (da, reklama preglednika koji blokira reklame).
U trenutku pisanja ovog članka UC Browser je skupio više od 500 000 000 instalacija na Google Playu. To je impresivno — samo je Google Chrome ispred njega. Među recenzijama može se vidjeti dosta pritužbi na reklame i preusmjeravanja na razne aplikacije u Google Playu. To je i bio povod za istraživanje: odlučili smo vidjeti čini li UC Browser nešto neodgovorno. I ispostavilo se da zaista čini!
U kodu aplikacije otkrivena je mogućnost preuzimanja i pokretanja izvršnog koda, na Google Playu. Osim što UC Browser preuzima izvršni kod, to čini na nesiguran način, što se može iskoristiti za provođenje MitM napada. Pogledajmo možemo li izvesti takav napad.
Sve što je napisano u nastavku važi za verziju UC Browsera koja je bila prisutna na Google Playu u trenutku provođenja istraživanja:
package: com.UCMobile.intl
versionName: 12.10.8.1172
versionCode: 10598
sha1 APK datoteke: f5edb2243413c777172f6362876041eb0c3a928cRansomware je vjerojatno otkriven na jednoj od web stranica posvećenih web programiranju, maskirajući se kao legitiman program XAMPP.
U manifestu UC Browsera može se pronaći servis s govorećim imenom com.uc.deployment.UpgradeDeployService.
<service android_exported="false" android_name="com.uc.deployment.UpgradeDeployService" android_process=":deploy" />
Pri pokretanju ovog servisa preglednik izvršava POST zahtjev na , koji se može primijetiti u prometu nakon nekog vremena od početka. U odgovoru može dobiti naredbu za preuzimanje ažuriranja ili novog modula. Tijekom analize server takve naredbe nije slao, ali smo primijetili da prilikom pokušaja otvaranja PDF-a u pregledniku ponovo šalje zahtjev na gore navedenu adresu, nakon čega preuzima nativnu biblioteku. Za provođenje napada odlučili smo iskoristiti ovu posebnost UC Browsera: sposobnost otvaranja PDF-a pomoću nativne biblioteke, koja nije prisutna u APK-u i koju on po potrebi preuzima s Interneta. Važno je napomenuti da se teoretski UC Browser može natjerati da nešto preuzme i bez interakcije s korisnikom – ako se pošalje ispravno oblikovani odgovor na zahtjev koji se izvršava nakon pokretanja preglednika. No, za to je potrebno detaljnije proučiti protokol komunikacije sa serverom, stoga smo smatrali da je jednostavnije urediti presretnuti odgovor i zamijeniti biblioteku za rad s PDF-om.
Dakle, kada korisnik želi otvoriti PDF izravno u pregledniku, u prometu se mogu vidjeti sljedeći zahtjevi:

Prvo se šalje POST zahtjev na , nakon čega
preuzima arhivu s bibliotekom za pregled PDF-a i uredskih formata. Logično je pretpostaviti da se u prvom zahtjevu šalju informacije o sustavu (barem arhitektura, kako bi se dala potrebna biblioteka), a kao odgovor na njega preglednik dobiva određene informacije o biblioteci koju treba preuzeti: adresu i, možda, još nešto. Problem je u tome što je ovaj zahtjev šifriran.
Fragment zahtjeva
Fragment odgovora


Sam biblioteka je zapakirana u ZIP i nije šifrirana.

Traženje koda za dešifriranje prometa
Pokušat ćemo dešifrirati odgovor servera. Gledamo kod klase com.uc.deployment.UpgradeDeployService: iz metode onStartCommand idemo na com.uc.deployment.b.x, a odatle u com.uc.browser.core.d.c.f.e:
javna 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("]proizvod:");
v4.append(arg9.iGX.ipR);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]verzija:");
v4.append(arg9.iGX.iEn);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]tip_nadogradnje:");
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("]tip_preuzimanja:");
v4.append(arg9.mDownloadType);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]grupa_preuzimanja:");
v4.append(arg9.mDownloadGroup);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]putanja_preuzimanja:");
v4.append(arg9.iGH);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_child_verzija:");
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("]ime_komponente:");
v5.append(((au)v4_1).getName());
v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]verzija_komponente:");
v5.append(((au)v4_1).aDA());
v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]verzija_koda_komponente:");
v5.append(((au)v4_1).gBl);
v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]tip_zahtjeva_komponente:");
v5.append(((au)v4_1).gBq);
}
}
j v3_4 = new j();
m.b(v3_4);
h v4_2 = new h();
m.b(v4_2);
ay v5_1 = new ay();
v3_4.hS("");
v3_4.setImsi("");
v3_4.hV("");
v5_1.bPQ = v3_4;
v5_1.bPP = v4_2;
v5_1.yr(arg9.iGX.ipR);
v5_1.gBF = arg9.iGX.mMode;
v5_1.gBI = arg9.iGX.iEz;
v3_2 = v5_1.gAr;
c.aBh();
v3_2.add(g.fs("os_ver", c.getRomInfo()));
v3_2.add(g.fs("processor_arch", com.uc.b.a.a.c.getCpuArch()));
v3_2.add(g.fs("cpu_arch", com.uc.b.a.a.c.Pb()));
String v4_3 = com.uc.b.a.a.c.Pd();
v3_2.add(g.fs("cpu_vfp", v4_3));
v3_2.add(g.fs("net_type", String.valueOf(com.uc.base.system.a.Jo())));
v3_2.add(g.fs("fromhost", arg9.iGX.iEm));
v3_2.add(g.fs("plugin_ver", arg9.iGX.iEn));
v3_2.add(g.fs("target_lang", arg9.iGX.iEs));
v3_2.add(g.fs("vitamio_cpu_arch", arg9.iGX.iEt));
v3_2.add(g.fs("vitamio_vfp", arg9.iGX.iEu));
v3_2.add(g.fs("vitamio_vfp3", arg9.iGX.iEv));
v3_2.add(g.fs("plugin_child_ver", arg9.iGX.iEx));
v3_2.add(g.fs("ver_series", arg9.iGX.iEw));
v3_2.add(g.fs("child_ver", r.aVw()));
v3_2.add(g.fs("cur_ver_md5", arg9.iGX.iEl));
v3_2.add(g.fs("cur_ver_signature", SystemHelper.getUCMSignature()));
v3_2.add(g.fs("upgrade_log", i.bjt()));
v3_2.add(g.fs("silent_install", String.valueOf(arg9.iGX.iDQ)));
v3_2.add(g.fs("silent_state", String.valueOf(arg9.iGX.iEp)));
v3_2.add(g.fs("silent_file", arg9.iGX.iEq));
v3_2.add(g.fs("silent_type", String.valueOf(arg9.iGX.iEr)));
v3_2.add(g.fs("cpu_archit", com.uc.b.a.a.c.Pc()));
v3_2.add(g.fs("cpu_set", SystemHelper.getCpuInstruction()));
boolean v4_4 = v4_3 == null || !v4_3.contains("neon") ? false : true;
v3_2.add(g.fs("neon", String.valueOf(v4_4)));
v3_2.add(g.fs("cpu_cores", String.valueOf(com.uc.b.a.a.c.Jl())));
v3_2.add(g.fs("ram_1", String.valueOf(com.uc.b.a.a.h.Po())));
v3_2.add(g.fs("totalram", String.valueOf(com.uc.b.a.a.h.OL())));
c.aBh();
v3_2.add(g.fs("rom_1", c.getRomInfo()));
v4_5 = e.getScreenWidth();
int v6 = e.getScreenHeight();
StringBuilder v7 = new StringBuilder();
v7.append(v4_5);
v7.append("*");
v7.append(v6);
v3_2.add(g.fs("ss", v7.toString()));
v3_2.add(g.fs("api_level", String.valueOf(Build$VERSION.SDK_INT)));
v3_2.add(g.fs("uc_apk_list", SystemHelper.getUCMobileApks()));
Iterator v4_6 = arg9.iGX.iEA.entrySet().iterator();
while(v4_6.hasNext()) {
Object v6_1 = v4_6.next();
v3_2.add(g.fs(((Map$Entry)v6_1).getKey(), ((Map$Entry)v6_1).getValue()));
}
v3 = v5_1.toByteArray();
}
if(v3 == null) {
this.iGY.iGI.a(arg9, "up_encode", "yes", "fail");
return;
}
v4_5 = this.iGY.iGw ? 0x1F : 0;
if(v3 == null) {
}
else {
v3 = g.i(v4_5, v3);
if(v3 == null) {
}
else {
v1 = new byte[v3.length + 16];
byte[] v6_2 = new byte[16];
Arrays.fill(v6_2, 0);
v6_2[0] = 0x5F;
v6_2[1] = 0;
v6_2[2] = ((byte)v4_5);
v6_2[3] = -50;
System.arraycopy(v6_2, 0, v1, 0, 16);
System.arraycopy(v3, 0, v1, 16, v3.length);
}
}
if(v1 == null) {
this.iGY.iGI.a(arg9, "up_encrypt", "yes", "fail");
return;
}
if(TextUtils.isEmpty(this.iGY.mUpgradeUrl)) {
this.iGY.iGI.a(arg9, "up_url", "yes", "fail");
return;
}
StringBuilder v0 = new StringBuilder("[");
v0.append(arg9.iGX.ipR);
v0.append("]url:");
v0.append(this.iGY.mUpgradeUrl);
com.uc.browser.core.d.c.i v0_1 = this.iGY.iGI;
v3_1 = this.iGY.mUpgradeUrl;
com.uc.base.net.e v0_2 = new com.uc.base.net.e(new com.uc.browser.core.d.c.i$a(v0_1, arg9));
v3_1 = v3_1.contains("?") ? v3_1 + "&dataver=pb" : v3_1 + "?dataver=pb";
n v3_5 = v0_2.uc(v3_1);
m.b(v3_5, false);
v3_5.setMethod("POST");
v3_5.setBodyProvider(v1);
v0_2.b(v3_5);
this.iGY.iGI.a(arg9, "up_null", "yes", "success");
this.iGY.iGI.b(arg9);
}Ovdje vidimo formiranje POST zahtjeva. Obratite pažnju na kreiranje niza od 16 bajtova i njegovo popunjavanje: 0x5F, 0, 0x1F, -50 (=0xCE). To se poklapa s onim što smo ranije vidjeli u zahtjevu.
U ovoj klasi možemo primijetiti ugniježdenu klasu, u kojoj postoji još jedna zanimljiva metoda:
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");
}
} Metoda prima niz bajtova i provjerava da li je nulti bajt jednak 0x60 ili treći bajt jednak 0xD0, a drugi bajt — 1, 11 ili 0x1F. Gledamo odgovor servera: nulti bajt — 0x60, drugi — 0x1F, treći — 0x60. Čini se da je to ono što nam treba. Sudeći po redovima („up_decrypt“, na primjer), ovdje bi trebala biti pozvana metoda koja će dešifrirati odgovor servera.
Prelazimo na metodu g.j. Primijetimo da se kao prvi argument u nju predaje bajt na offsetu 2 (tj. 0x1F u našem slučaju), a kao drugi — odgovor servera bez
prvih 16 bajtova.
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;
} Očigledno, ovdje se bira algoritam dešifriranja, a taj bajt, koji imamo
vrijednost je 0x1F, što označava jednu od tri moguće opcije.
Nastavljamo s analizom koda. Nakon nekoliko skokova dolazimo do metode sa značajnim nazivom decryptBytesByKey.
Ovdje se od našeg odgovora odvajaju još dva bajta, a od njih se dobiva niz. Jasno je da se ovim postupkom bira ključ za dešifriranje poruke.
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 bajta
System.arraycopy(bytes, 0, prefix, 0, prefix.length);
String keyId = c.ayR().d(ByteBuffer.wrap(prefix).getShort()); // Odabir ključ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;
}Unaprijed napominjemo da u ovoj fazi ne dobivamo pravi ključ, već samo njegov „identifikator“. Dobivanje ključa je malo složenije.
U sljedećoj metodi dodaju se još dva parametra, čime njih ukupno postaje četiri: čarobni broj 16, identifikator ključa, šifrirani podaci i nejasan niz (u našem slučaju prazan).
public final byte[] l(String keyId, byte[] encrypted) throws SecException {
return this.ayJ().staticBinarySafeDecryptNoB64(16, keyId, encrypted, "");
}Nakon niza prijelaza dolazimo do metode staticBinarySafeDecryptNoB64 sučelja com.alibaba.wireless.security.open.staticdataencrypt.IStaticDataEncryptComponent. U glavnom kodu aplikacije nema klasa koje implementiraju sučelje. Takva klasa postoji u datoteci lib/armeabi-v7a/libsgmain.so, koja u stvarnosti nije .so, već .jar. Metoda koja nas zanima implementirana je na sljedeći način:
package com.alibaba.wireless.security.a.i;
// ...
public class a implements IStaticDataEncryptComponent {
private ISecurityGuardPlugin a;
// ...
private byte[] a(int mode, int magicInt, int xzInt, String keyId, byte[] encrypted, String magicString) {
return this.a.getRouter().doCommand(10601, new Object[]{Integer.valueOf(mode), Integer.valueOf(magicInt), Integer.valueOf(xzInt), keyId, encrypted, magicString});
}
// ...
private byte[] b(int magicInt, String keyId, byte[] encrypted, String magicString) {
return this.a(2, magicInt, 0, keyId, encrypted, magicString);
}
// ...
public byte[] staticBinarySafeDecryptNoB64(int magicInt, String keyId, byte[] encrypted, String magicString) throws SecException {
if(keyId != null && keyId.length() > 0 && magicInt >= 0 && magicInt 0) {
return this.b(magicInt, keyId, encrypted, magicString);
}
throw new SecException("", 301);
}
//...
} Ovdje naš popis parametara dopunjuje još dva cijela broja: 2 i 0. Sudeći prema
svemu, 2 označava dešifriranje, kao u metodi doFinal , sistemske klase javax.crypto.Cipher. I sve to se šalje u neki Router s brojem 10601 — to je, očito, broj naredbe.
Nakon još jednog lanca prelaza nalazimo klasu koja implementira interfejs IRouterComponent i metoda 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);
}
}I također klasa JNICLibrary, u kojoj je deklarisana nativna metoda doCommandNative:
package com.taobao.wireless.security.adapter;
public class JNICLibrary {
public static native Object doCommandNative(int arg0, Object[] arg1);
}Znači, trebamo u nativnom kodu pronaći metodu doCommandNative. I tu počinje najslađa zabava.
Obfuskacija mašinskog koda
U datoteci libsgmain.so (koji je zapravo .jar i u kojem smo malo prije pronašli implementaciju nekih interfejsa vezanih za šifriranje) ima jednu nativnu biblioteku: libsgmainso-6.4.36.so. Otvaramo je u IDA-i i dobijamo gomilu prozora sa greškama. Problem je u tome što je tabela sekcija (section header table) – nevaljana. To je urađeno namerno kako bi se otežala analiza.

Ali ona ni nije potrebna: da bi ispravno učitali ELF-datoteku i analizirali je, sasvim je dovoljna tabela segmenata (program header table). Stoga jednostavno brišemo tabelu sekcija, nulirajući odgovarajuća polja u zaglavlju.

Ponovo otvaramo datoteku u IDA-i.
Postoje dva načina da se kaže virtuelnoj Java mašini gde se tačno u nativnoj biblioteci nalazi implementacija metode, koja je u Java kodu deklarisana kao native. Prvi — dati mu ime forme Java_ime_paketa_ImeKlase_imeMetode.
Drugi — registrirati ga prilikom učitavanja biblioteke (u funkciji JNI_OnLoad)
pomoću poziva funkcije RegisterNatives.
U našem slučaju, ako koristimo prvi način, ime bi trebalo biti ovako: Java_com_taobao_wireless_security_adapter_JNICLibrary_doCommandNative.
Među izvoznim funkcijama takvih nema, što znači da treba potražiti poziv RegisterNatives.
Idemo u funkciju JNI_OnLoad i vidimo ovakvu sliku:

Što se ovdje događa? Na prvi pogled, početak i kraj funkcije tipični su za arhitekturu ARM. Prva instrukcija u stak zadržava sadržaj registara koje funkcija koristi u svom radu (u ovom slučaju R0, R1 i R2), kao i sadržaj registra LR, koji sadrži adresu povratka iz funkcije. Posljednja instrukcija vraća spremljene registre, a adresa povratka odmah se stavlja u registar PC — tako se događa povratak iz funkcije. No, ako bolje pogledate, možete primijetiti da pretposljednja instrukcija mijenja adresu povratka, spremljenu u staku. Izračunajmo koja će ona biti nakon
izvršavanja koda. U R1 se učitava neka adresa 0xB130, od nje se oduzima 5, zatim se prebacuje u R0 i dodaje joj se 0x10. Tako dobijamo 0xB13B. Na taj način, IDA misli da se u posljednjoj instrukciji događa običan povratak iz funkcije, a zapravo se događa prijelaz na izračunatu adresu 0xB13B.
Ovde valja podsjetiti da procesori ARM imaju dva režima i dva skupa instrukcija: ARM i Thumb. Manji bit adrese govori procesoru koji se set instrukcija koristi. T. j. adresa je zapravo 0xB13A, a jedinica u manjem bitu označava režim Thumb.
Na početak svake funkcije u ovoj biblioteci dodan je sličan "adapter" i
smešni kod. Dalje se nećemo detaljno zadržavati na njima – samo pamtite,
da se pravo početak gotovo svih funkcija nalazi malo dalje.
Budući da u kodu nema jasnog prijelaza na 0xB13A, IDA sama nije prepoznala da se na tom mestu nalazi kod. Iz istog razloga, većinu koda u biblioteci ne prepoznaje kao kod, što donekle otežava analizu. Kažemo IDA-i da je ovdje kod, i šta imamo:

Na 0xB144 očigledno počinje tabela. A šta je u sub_494C?

Prilikom poziva ove funkcije u registru LR dobijamo adresu spomenute tabele (0xB144). U R0 — indeks u ovoj tabeli. T. j. uzima se vrednost iz tabele, dodaje se LR-u i dobija se
adresa na koju treba ići. Pokušajmo je izračunati: 0xB144 + [0xB144 + 8 * 4] = 0xB144 + 0x120 = 0xB264. Idemo na dobijenu adresu i vidimo doslovno nekoliko korisnih uputa i opet prelaz na 0xB140:

Sada će biti prelaz po pomaku s indeksom 0x20 iz tablice.
Sudeći prema veličini tablice, takvih prelaza u kodu biće mnogo. Postavlja se pitanje, može li se nekako boriti protiv toga automatskije, bez ručnog izračunavanja adresa. U pomoć nam dolaze skripte i mogućnost patchiranja koda u 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 "indeks =", 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 "Pogrešna vrsta operanda na", hex(ea1), "-", get_operand_type(ea1, 0), get_operand_type(ea1, 1)
table = None
if table is None:
print "Nije moguće pronaći tablicu"
else:
print "tablica =", hex(table)
offset = get_wide_dword(table + (index << 2))
put_unconditional_branch(ea, table + offset)
else:
print "Nepoznati kod", get_operand_type(ea1, 0), get_operand_value(ea1, 0), get_operand_type(ea1, 1) == 2
else:
print "Nije moguće detektovati prvu instrukciju"Stavljamo kursor na redak 0xB26A, pokrećemo skriptu i vidimo prelaz na 0xB4B0:

IDA opet nije prepoznala ovaj deo kao kod. Pomažemo joj i vidimo drugu konstrukciju:

Upute nakon BLX izgledaju prilično besmisleno, više liče na neko pomeranje. Gledamo u sub_4964:

I zaista, ovde se uzima dword s adrese koja leži u LR-u, dodaje se toj adresi, nakon čega se uzima vrednost s dobijene adrese i stavlja u stek. Takođe se LR-u dodaje 4, kako bi se nakon povratka iz funkcije preskočilo to pomeranje. Nakon toga, komanda POP {R1} uzima dobijenu vrednost iz steka. Ako pogledamo šta se nalazi na adresi 0xB4BA + 0xEA = 0xB5A4, možemo videti nešto što liči na tabelu adresa:

Kako biste ispravili ovu konstrukciju, potrebno je dobiti dva parametra iz koda: pomak i broj registra u koji treba smjestiti rezultat. Za svaki mogući registar unaprijed treba pripremiti komadić koda.
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 "POP instrukcija nije pronađena"
else:
print "Pogrešan tip operanda na +4:", get_operand_type(ea + 4, 0)
else:
print "Nije moguće odrediti prve instrukcije"Postavite kursor na početak konstrukcije koju želite zamijeniti — 0xB4B2 — i pokrenite skriptu:

Osim već spomenutih konstrukcija, u kodu se također nalaze ovakve:

Kao u prethodnom slučaju, nakon instrukcije BLX dolazi pomak:

Uzimamo pomak po adresi iz LR, dodajemo ga LR-u i prelazimo tamo. 0x72044 + 0xC = 0x72050. Skripta za ovu konstrukciju je vrlo jednostavna:
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 "Nije moguće odrediti prvu instrukciju"Rezultat izvršenja skripte:

Nakon što je funkcija zakrpana, možete IDA-u naznačiti stvarni početak. Prikupit će cijeli kod funkcije u dijelovima, a može se dekompajlirati pomoću HexRays.
Dešifriranje niza
Naučili smo se boriti protiv obfuskacije strojno generiranog koda u biblioteci libsgmainso-6.4.36.so iz UC Browser-a i dobili kod funkcije 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;
}Pogledajmo bliže sljedeće linije:
sub_73E24(&unk_83EA6, &v6, 49);
clazz = (jclass)((int (__fastcall *)(JNIEnv *, int *))(*env)->FindClass)(env, &v6);U funkciji sub_73E24 očigledno se dešifrira ime klase. Kao parametri ovoj funkciji se šalje pokazivač na podatke koji izgledaju kao šifrirani, neki buffer i broj. Očigledno je da će nakon pozivanja funkcije u bufferu biti dešifrirani niz, jer se on prosljeđuje funkciji FindClass, koja kao drugi parametar prima ime klase. Dakle, broj je veličina buffera ili dužina niza. Pokušajmo dešifrirati ime klase, ono bi nam u ovom trenutku trebalo pokazati jesmo li na pravom putu. Pogledajmo detaljnije što se dešava u 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;
}Funkcija sub_7AF78 stvara instancu kontejnera za nizove bajtova određene veličine (nećemo se detaljno zadržavati na tim kontejnerima). Ovdje se stvaraju dva takva kontejnera: u jedan se stavlja niz „DcO/lcK+h?m3c*q@“ (nije teško pogoditi da je to ključ), u drugi — šifrirani podaci. Zatim se oba objekta stavljaju u neku strukturu koja se prenosi funkciji sub_6115C. Također, primijetimo u ovoj strukturi polje sa vrijednošću 3. Pogledajmo što se s ovom strukturom dalje događa.
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;
}Kao parametar switch prenosi se polje strukture kojem je prethodno dodeljena vrednost 3. Pogledajmo case 3: u funkciju sub_6364C preneseni su parametri iz strukture, koji su prethodne funkcije pohranjeni, tj. ključ i šifrirani podaci. Ako pažljivo pogledate sub_6364C, možete prepoznati u njemu RC4 algoritam.
Imamo algoritam i ključ. Pokušajmo dešifrovati naziv klase. Evo što smo dobili: com/taobao/wireless/security/adapter/JNICLibrary. Odlično! Na pravom smo putu.
Stablo komandi
Sada treba pronaći poziv RegisterNatives, koji će nam pokazati na funkciju doCommandNative. Pretražujemo funkcije pozvane iz JNI_OnLoad, i pronalazimo je u 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;
}I zaista, ovdje se registruje nativna metoda sa imenom doCommandNative. Sada znamo njegovu adresu. Pogledajmo što ona radi.
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;
}Po nazivu se može naslutiti da ovdje postoji ulazna tačka svih funkcija koje su programeri odlučili prebaciti u nativnu biblioteku. Interesuje nas funkcija s brojem 10601.
Iz koda se može videti da se iz broja komande dobijaju tri broja: command / 10000, command % 10000 / 100 i command % 10, tj. u našem slučaju, 1, 6 i 1. Ova tri broja, kao i pokazivač na JNIEnv i argumenti proslijeđeni funkciji, se kombinuju u strukturu i šalju dalje. Pomoću dobijenih tri broja (označimo ih sa N1, N2 i N3) gradi se stablo komandi.
Otprilike ovako:

Stablo se dinamički popunjava u JNI_OnLoad.
Tri broja kodiraju putanju u stablu. Svaki list stabla sadrži povezanu adresu odgovarajuće funkcije. Ključ je u roditeljskom čvoru. Pronaći mjesto u kodu gdje se dodaje funkcija koja nam je potrebna nije previše teško ukoliko se razumiju sve korištene strukture (njihov opis ne navodimo kako ne bismo dodatno proširili već i onako opsežan članak).
Još o obfuskaciji
Dobili smo adresu funkcije koja bi trebala dešifrirati promet: 0x5F1AC. No, još se ne možemo radovati: programeri UC Browser-a pripremili su nam još jedan iznenađenje.
Nakon što dobijemo parametre iz niza koji je formiran u Java kodu, ulazimo
u funkciju na adresi 0x4D070. I ovdje nas čeka još jedan oblik obfuskacije koda.
Stavljamo u R7 i R4 dva indeksa:

Prebacujemo prvi indeks u R11:

Da bismo dobili adresu iz tablice, koristimo indeks:

Nakon prelaska na prvu adresu koristi se drugi indeks, koji je u R4. U tablici ima 230 elemenata.
Što s tim učiniti? Možemo reći IDA-i da je to takav switch: Edit -> Other -> Specify switch idiom.

Dobiveni kod je zastrašujući. No, probijajući se kroz njegove zamke, možemo primijetiti poziv već poznate nam funkcije sub_6115C:

Tamo je bio switch, u kojem se u case 3 nalazila dešifriranje koristeći RC4 algoritam. A u ovom slučaju struktura koja se prosljeđuje u funkciju popunjava se iz parametara koji su proslijeđeni u doCommandNative. Sjećamo se da smo imali magicInt s vrijednošću 16. Gledamo odgovarajući case – i nakon nekoliko prijelaza pronalazimo kod po kojem možemo prepoznati algoritam.

To je AES!
Algoritam je tu, ostaje dobiti njegove parametre: način rada, ključ i, možda, vektor inicijalizacije (njegova prisutnost ovisi o načinu rada AES algoritma). Struktura s njima trebala bi se formirati negdje prije poziva funkcije sub_6115C, ali ovaj dio koda je posebno dobro obfuskiran, stoga se javlja ideja da se patcha kod kako bi se svi parametri funkcije dešifriranja dumpali u datoteku.
Patch
Kako ne bismo pisali cijeli kod patcha na jeziku asemblera ručno, možemo pokrenuti Android Studio, napisati funkciju koja prima iste parametre kao naša funkcija dešifriranja, i piše u datoteku, nakon čega možemo kopirati kod koji generira kompajler.
O praktičnosti dodavanja koda također su se pobrinuli naši prijatelji iz UC Browser tima. Podsjećamo se da u početku svake funkcije imamo nepotrebni kod koji lako možete zamijeniti bilo kojim drugim. Uistinu je praktično 🙂 Ipak, na početku ciljne funkcije nema dovoljno mjesta za kod koji sprema sve parametre u datoteku. Morali smo ga podijeliti na dijelove i koristiti nepotrebne blokove susjednih funkcija. Svega je ispalo četiri dijela.
Prvi dio:

U ARM arhitekturi prva četiri parametra funkcije prenose se putem registara R0-R3, dok se ostali, ako ih ima — putem steka. U registru LR prenosi se adresa povratka. Sve to treba sačuvati kako bi funkcija mogla raditi nakon što damo dump njenih parametara. Također, potrebno je sačuvati sve registre koje ćemo koristiti u procesu, stoga radimo PUSH.W {R0-R10,LR}. U R7 dobijamo adresu popisa parametara proslijeđenih funkciji putem steka.
Pomoću funkcije fopen otvorit ćemo datoteku /data/local/tmp/aes u režimu „ab“,
tj. za dodavanje. U R0 učitavamo adresu imena datoteke, a u R1 — adresu stringa s modom. I tu nepotrebni kod završava, stoga prelazimo na sljedeću funkciju. Kako bi nastavila raditi, postavljamo prijelaz na pravi kod funkcije na početak, zaobiđujući nepotrebno, a umjesto nepotrebnog dodajemo nastavak patch-a.

Pozivamo fopen.
Prva tri parametra funkcije aes imaju tip int. Budući da smo na početku sačuvali registre u steku, jednostavno možemo proslijediti funkciji fwrite njihove adrese u steku.

Dalje imamo tri strukture koje sadrže veličinu podataka i pokazivač na podatke za ključ, vektor inicijalizacije i šifrirane podatke.

Na kraju zatvaramo datoteku, obnavljamo registre i predajemo kontrolu stvarnoj funkciji. aes.
Sakupljamo APK s patchiranom bibliotekom, potpisujemo, prebacujemo na uređaj/emulator, pokrećemo. Vidimo da se naš dump stvara i u njega se upisuje mnogo podataka. Preglednik koristi šifriranje ne samo za promet, a sve šifriranje ide kroz predmetnu funkciju. Međutim, potrebnih podataka nema, i u prometu nije vidljiv potrebni zahtjev. Kako ne bismo čekali da UC Browser odluči napraviti potrebni zahtjev, uzet ćemo šifrirani odgovor s poslužitelja, dobiven ranije, i ponovno ćemo patchirati aplikaciju: dodati dešifriranje u onCreate glavne aktivnosti.
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;)ISakupljamo, potpisujemo, instaliramo, pokrećemo. Dobijamo NullPointerException jer je metoda vratila null.
Daljnjom analizom koda otkrivena je funkcija koja dešifrira zanimljive podatke: „META-INF/“ i „.RSA“. Čini se da aplikacija provjerava svoj certifikat. Ili čak generira ključeve iz njega. Ne želim se baviti time što se događa s certifikatom, pa ćemo mu jednostavno dati pravi certifikat. Patchujemo enkriptiranu liniju tako da umjesto „META-INF/“ dobijemo „BLABLINF/“, kreiramo direktorij s tim imenom u APK-u i stavimo tamo certifikat belkobrakera.
Sakupljamo, potpisujemo, instaliramo, pokrećemo. Bingo! Ključ je kod nas!
MitM
Dobijamo ključ i vektor inicijalizacije, jednak ključa. Pokušavamo dešifrirati odgovor servera u CBC režimu.

Vidimo URL arhive, nešto slično MD5, „extract_unzipsize“ i broj. Provjeravamo: MD5 arhive se poklapa, veličina raspakirane biblioteke se poklapa. Pokušavamo patchovati ovu biblioteku i predati je pregledniku. Da bismo pokazali da je naša patchovana biblioteka učitana, pokrećemo Intent za kreiranje SMS-a s tekstom „PWNED!“. Mijenjamo dva odgovora sa servera: i na preuzimanje arhive. U prvom mijenjamo MD5 (veličina nakon raspakiravanja se ne mijenja), u drugom šaljemo arhivu s patchovanom bibliotekom.
Preglednik nekoliko puta pokušava preuzeti arhivu, nakon čega javlja grešku. Očigledno mu nešto
ne odgovara. Kao rezultat analize ovog nejasnog formata, otkriveno je da server također šalje veličinu arhive:

Ona je kodirana u LEB128. Nakon patcha, veličina arhive s bibliotekom se malo promijenila, pa je preglednik mislio da je arhiva preuzeta oštećeno, i nakon nekoliko pokušaja javlja grešku.
Ispravimo veličinu arhive… I – pobjeda! 🙂 Rezultat na videu.
Posljedice i reakcija programera
Na sličan način, hakeri bi mogli iskoristiti nesigurnu funkciju UC Browsera za širenje i pokretanje zlonamjernih biblioteka. Ove biblioteke će raditi u kontekstu preglednika, pa će dobiti sve njegove sistemske dozvole. Kao rezultat, dobit će mogućnost prikazivanja phishing prozora, kao i pristup radnim datotekama narančaste kineske vjeverice, uključujući lozinke, korisnička imena i kolačiće pohranjene u bazi podataka.
Kontaktirali smo programere UC Browsera i obavijestili ih o pronađenom problemu, pokušavali ukazati na ranjivost i njene opasnosti, no nisu željeli razgovarati s nama. U međuvremenu, preglednik je nastavljao pokazivati opasnu funkciju na vidiku. No čim smo otkrili detalje ranjivosti, više se nije moglo ignorisati kao prije. 27. ožujka je
izdata nova verzija UC Browsera 12.10.9.1193, koja je pristupala serveru putem HTTPS-a: .
Osim toga, nakon 'ispravke' i do trenutka pisanja ovog članka, pokušaj otvaranja PDF-a u pregledniku rezultirao je porukom o grešci s tekstom 'Ups, nešto nije u redu!'. Zahtjev za serverom prilikom pokušaja otvaranja PDF-a nije bio izvršen, ali je zahtjev pri pokretanju preglednika bio izvršen, što sugerira da je zadržana mogućnost učitavanja izvršnog koda u kršenju pravila Google Playa.
Izvor: habr.com
