UC બ્રાઉઝરમાં નબળાઈઓ શોધી રહ્યાં છીએ

પરિચય

માર્ચના અંતમાં અમે જાણ કરી, કે તેઓએ UC બ્રાઉઝરમાં વણચકાસાયેલ કોડ લોડ કરવાની અને ચલાવવાની છુપી ક્ષમતા શોધી કાઢી. આજે આપણે આ ડાઉનલોડ કેવી રીતે થાય છે અને હેકર્સ તેમના પોતાના હેતુઓ માટે તેનો ઉપયોગ કેવી રીતે કરી શકે છે તે વિશે વિગતવાર જોઈશું.

થોડા સમય પહેલા, યુસી બ્રાઉઝરની જાહેરાત કરવામાં આવી હતી અને ખૂબ જ આક્રમક રીતે વિતરિત કરવામાં આવી હતી: તે મૉલવેરનો ઉપયોગ કરીને વપરાશકર્તાઓના ઉપકરણો પર ઇન્સ્ટોલ કરવામાં આવ્યું હતું, વિડિયો ફાઇલોની આડમાં વિવિધ સાઇટ્સથી વિતરિત કરવામાં આવ્યું હતું (એટલે ​​​​કે, વપરાશકર્તાઓને લાગ્યું કે તેઓ ડાઉનલોડ કરી રહ્યાં છે, ઉદાહરણ તરીકે, એક પોર્ન વિડિઓ, પરંતુ તેના બદલે આ બ્રાઉઝર સાથે એક APK પ્રાપ્ત કર્યું), સંદેશાઓ સાથે ડરામણી બેનરોનો ઉપયોગ કર્યો કે બ્રાઉઝર જૂનું, સંવેદનશીલ અને તેના જેવી સામગ્રી છે. VK પર સત્તાવાર UC બ્રાઉઝર જૂથમાં છે વિષય, જેમાં વપરાશકર્તાઓ અયોગ્ય જાહેરાતો વિશે ફરિયાદ કરી શકે છે, ત્યાં ઘણા ઉદાહરણો છે. 2016 માં ત્યાં સમાન હતું વિડિઓ જાહેરાત રશિયનમાં (હા, જાહેરાત-અવરોધિત બ્રાઉઝર માટે જાહેરાત).

લખવાના સમયે, UC બ્રાઉઝર પાસે Google Play પર 500 થી વધુ ઇન્સ્ટોલેશન છે. આ પ્રભાવશાળી છે - ફક્ત Google Chrome માં વધુ છે. સમીક્ષાઓમાં તમે જાહેરાતો અને Google Play પર કેટલીક એપ્લિકેશનો પર રીડાયરેક્ટ કરવા વિશે ઘણી બધી ફરિયાદો જોઈ શકો છો. અમારા સંશોધનનું આ કારણ હતું: અમે એ જોવાનું નક્કી કર્યું કે શું UC બ્રાઉઝર કંઈક ખરાબ કરી રહ્યું છે. અને તે બહાર આવ્યું છે કે તે કરે છે!

એપ્લિકેશન કોડમાં, એક્ઝેક્યુટેબલ કોડને ડાઉનલોડ અને ચલાવવાની ક્ષમતા મળી આવી હતી, જે એપ્લિકેશન પ્રકાશિત કરવાના નિયમોની વિરુદ્ધ છે Google Play પર. એક્ઝેક્યુટેબલ કોડ ડાઉનલોડ કરવા ઉપરાંત, UC બ્રાઉઝર અસુરક્ષિત રીતે કરે છે, જેનો ઉપયોગ MitM હુમલો શરૂ કરવા માટે થઈ શકે છે. ચાલો જોઈએ કે શું આપણે આવો હુમલો કરી શકીએ છીએ.

નીચે લખેલ બધું UC બ્રાઉઝરના વર્ઝન માટે સુસંગત છે જે અભ્યાસ સમયે Google Play પર ઉપલબ્ધ હતું:

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

હુમલો વેક્ટર

UC બ્રાઉઝર મેનિફેસ્ટમાં તમે સ્વ-સ્પષ્ટિજનક નામ સાથે સેવા શોધી શકો છો com.uc.deployment.UpgradeDeployService.

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

જ્યારે આ સેવા શરૂ થાય છે, ત્યારે બ્રાઉઝર POST વિનંતી કરે છે puds.ucweb.com/upgrade/index.xhtml, જે શરૂઆતના થોડા સમય પછી ટ્રાફિકમાં જોવા મળે છે. જવાબમાં, તેને કેટલાક અપડેટ અથવા નવા મોડ્યુલ ડાઉનલોડ કરવા માટે આદેશ પ્રાપ્ત થઈ શકે છે. વિશ્લેષણ દરમિયાન, સર્વરે આવા આદેશો આપ્યા ન હતા, પરંતુ અમે નોંધ્યું છે કે જ્યારે અમે બ્રાઉઝરમાં પીડીએફ ખોલવાનો પ્રયાસ કરીએ છીએ, ત્યારે તે ઉપર ઉલ્લેખિત સરનામાં પર બીજી વિનંતી કરે છે, જે પછી તે મૂળ લાઇબ્રેરી ડાઉનલોડ કરે છે. હુમલો કરવા માટે, અમે UC બ્રાઉઝરની આ સુવિધાનો ઉપયોગ કરવાનું નક્કી કર્યું: નેટીવ લાઇબ્રેરીનો ઉપયોગ કરીને PDF ખોલવાની ક્ષમતા, જે APKમાં નથી અને જો જરૂરી હોય તો તે ઇન્ટરનેટ પરથી ડાઉનલોડ કરે છે. તે નોંધવું યોગ્ય છે કે, સૈદ્ધાંતિક રીતે, યુસી બ્રાઉઝરને વપરાશકર્તાની ક્રિયાપ્રતિક્રિયા વિના કંઈક ડાઉનલોડ કરવા માટે દબાણ કરી શકાય છે - જો તમે બ્રાઉઝર લોંચ થયા પછી એક્ઝિક્યુટ કરવામાં આવેલી વિનંતીને યોગ્ય રીતે બનાવેલ પ્રતિસાદ પ્રદાન કરો છો. પરંતુ આ કરવા માટે, અમારે સર્વર સાથેની ક્રિયાપ્રતિક્રિયાના પ્રોટોકોલનો વધુ વિગતવાર અભ્યાસ કરવાની જરૂર છે, તેથી અમે નક્કી કર્યું છે કે ઇન્ટરસેપ્ટેડ પ્રતિસાદને સંપાદિત કરવું અને PDF સાથે કામ કરવા માટે લાઇબ્રેરીને બદલવું વધુ સરળ રહેશે.

તેથી, જ્યારે વપરાશકર્તા સીધા બ્રાઉઝરમાં પીડીએફ ખોલવા માંગે છે, ત્યારે નીચેની વિનંતીઓ ટ્રાફિકમાં જોઈ શકાય છે:

પ્રથમ એક પોસ્ટ વિનંતી છે puds.ucweb.com/upgrade/index.xhtml, પછી
પીડીએફ અને ઓફિસ ફોર્મેટ જોવા માટે લાઇબ્રેરી સાથેનું આર્કાઇવ ડાઉનલોડ કરવામાં આવે છે. એવું માનવું તાર્કિક છે કે પ્રથમ વિનંતી સિસ્ટમ વિશે માહિતી પ્રસારિત કરે છે (ઓછામાં ઓછું જરૂરી લાઇબ્રેરી પ્રદાન કરવા માટેનું આર્કિટેક્ચર), અને તેના જવાબમાં બ્રાઉઝર લાઇબ્રેરી વિશે કેટલીક માહિતી મેળવે છે જેને ડાઉનલોડ કરવાની જરૂર છે: સરનામું અને, સંભવતઃ , કંઈક બીજું. સમસ્યા એ છે કે આ વિનંતી એન્ક્રિપ્ટેડ છે.

ભાગની વિનંતી કરો

જવાબ ટુકડો

લાઇબ્રેરી પોતે જ ઝીપમાં પેક કરેલી છે અને એન્ક્રિપ્ટેડ નથી.

ટ્રાફિક ડિક્રિપ્શન કોડ માટે શોધો

ચાલો સર્વર પ્રતિસાદને સમજવાનો પ્રયાસ કરીએ. ચાલો વર્ગ કોડ જોઈએ com.uc.deployment.UpgradeDeployService: પદ્ધતિથી onStartCommand પર જાઓ com.uc.deployment.bx, અને તેમાંથી com.uc.browser.core.dcfe:

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

અમે અહીં POST વિનંતીની રચના જોઈ છે. અમે 16 બાઇટ્સની એરેની રચના અને તેના ભરવા પર ધ્યાન આપીએ છીએ: 0x5F, 0, 0x1F, -50 (=0xCE). અમે ઉપરની વિનંતીમાં જે જોયું તેની સાથે સુસંગત છે.

સમાન વર્ગમાં તમે એક નેસ્ટેડ વર્ગ જોઈ શકો છો જેમાં બીજી રસપ્રદ પદ્ધતિ છે:

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

પદ્ધતિ ઇનપુટ તરીકે બાઇટ્સની શ્રેણી લે છે અને તપાસે છે કે શૂન્ય બાઇટ 0x60 છે અથવા ત્રીજો બાઇટ 0xD0 છે, અને બીજી બાઇટ 1, 11 અથવા 0x1F છે. અમે સર્વર તરફથી પ્રતિસાદ જોઈએ છીએ: શૂન્ય બાઈટ 0x60 છે, બીજો 0x1F છે, ત્રીજો 0x60 છે. અમને જે જોઈએ છે તે લાગે છે. લીટીઓ દ્વારા અભિપ્રાય આપતા ("up_decrypt", ઉદાહરણ તરીકે), એક પદ્ધતિને અહીં બોલાવવી જોઈએ જે સર્વરના પ્રતિભાવને ડિક્રિપ્ટ કરશે.
ચાલો પદ્ધતિ તરફ આગળ વધીએ gj. નોંધ કરો કે પ્રથમ દલીલ એ ઑફસેટ 2 પર બાઈટ છે (એટલે ​​​​કે અમારા કિસ્સામાં 0x1F), અને બીજી દલીલ વિના સર્વર પ્રતિસાદ છે
પ્રથમ 16 બાઇટ્સ.

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

દેખીતી રીતે, અહીં આપણે ડિક્રિપ્શન અલ્ગોરિધમ પસંદ કરીએ છીએ, અને તે જ બાઈટ જે આપણા
કેસ 0x1F ની બરાબર છે, ત્રણ સંભવિત વિકલ્પોમાંથી એક સૂચવે છે.

અમે કોડનું વિશ્લેષણ કરવાનું ચાલુ રાખીએ છીએ. એક-બે કૂદકા માર્યા પછી આપણે આપણી જાતને એક સ્વ-સ્પષ્ટીકરણ નામવાળી પદ્ધતિમાં શોધીએ છીએ decryptBytesByKey.

અહીં અમારા પ્રતિભાવથી વધુ બે બાઈટ અલગ કરવામાં આવી છે, અને તેમાંથી એક સ્ટ્રિંગ મેળવવામાં આવે છે. તે સ્પષ્ટ છે કે આ રીતે સંદેશને ડિક્રિપ્ટ કરવા માટેની કી પસંદ કરવામાં આવી છે.

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

આગળ જોતાં, અમે નોંધીએ છીએ કે આ તબક્કે આપણે હજી સુધી ચાવી મેળવી નથી, પરંતુ ફક્ત તેનું "ઓડેન્ટિફાયર". ચાવી મેળવવી થોડી વધુ જટિલ છે.

આગળની પદ્ધતિમાં, બે વધુ પરિમાણો વર્તમાનમાં ઉમેરવામાં આવે છે, જેમાંથી ચાર બનાવે છે: જાદુઈ નંબર 16, કી ઓળખકર્તા, એન્ક્રિપ્ટેડ ડેટા અને એક અગમ્ય સ્ટ્રિંગ (અમારા કિસ્સામાં, ખાલી).

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

સંક્રમણોની શ્રેણી પછી અમે પદ્ધતિ પર આવીએ છીએ staticBinarySafeDecryptNoB64 ઇન્ટરફેસ com.alibaba.wireless.security.open.staticdataencrypt.IStaticDataEncryptComponent. મુખ્ય એપ્લિકેશન કોડમાં કોઈ વર્ગો નથી જે આ ઇન્ટરફેસને અમલમાં મૂકે છે. ફાઇલમાં આવો વર્ગ છે lib/armeabi-v7a/libsgmain.so, જે વાસ્તવમાં a .so નથી, પરંતુ a .jar છે. અમને રુચિ છે તે પદ્ધતિ નીચે પ્રમાણે અમલમાં મૂકવામાં આવે છે:

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

અહીં અમારા પરિમાણોની સૂચિ બે વધુ પૂર્ણાંકો સાથે પૂરક છે: 2 અને 0. દ્વારા નિર્ધારિત
બધું, 2 નો અર્થ છે ડિક્રિપ્શન, પદ્ધતિની જેમ અંતિમ સિસ્ટમ વર્ગ javax.crypto.Cipher. અને આ બધું 10601 નંબર સાથે ચોક્કસ રાઉટર પર સ્થાનાંતરિત થાય છે - આ દેખીતી રીતે આદેશ નંબર છે.

સંક્રમણોની આગલી સાંકળ પછી આપણને એક વર્ગ મળે છે જે ઇન્ટરફેસને અમલમાં મૂકે છે IRouterComponent અને પદ્ધતિ doCommand:

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

અને વર્ગ પણ JNICL લાઇબ્રેરી, જેમાં મૂળ પદ્ધતિ જાહેર કરવામાં આવી છે doCommandNative:

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

આનો અર્થ એ છે કે આપણે મૂળ કોડમાં પદ્ધતિ શોધવાની જરૂર છે doCommandNative. અને આ તે છે જ્યાં મજા શરૂ થાય છે.

મશીન કોડની અસ્પષ્ટતા

ફાઈલમાં libsgmain.so (જે વાસ્તવમાં એક .jar છે અને જેમાં અમને કેટલાક એન્ક્રિપ્શન-સંબંધિત ઈન્ટરફેસનું અમલીકરણ ઉપર જ મળ્યું છે) ત્યાં એક મૂળ પુસ્તકાલય છે: libsgmainso-6.4.36.so. અમે તેને IDA માં ખોલીએ છીએ અને ભૂલો સાથે સંવાદ બોક્સનો સમૂહ મેળવીએ છીએ. સમસ્યા એ છે કે વિભાગ હેડર ટેબલ અમાન્ય છે. આ વિશ્લેષણને જટિલ બનાવવા હેતુસર કરવામાં આવે છે.

પરંતુ તેની જરૂર નથી: ELF ફાઇલને યોગ્ય રીતે લોડ કરવા અને તેનું વિશ્લેષણ કરવા માટે, પ્રોગ્રામ હેડર ટેબલ પર્યાપ્ત છે. તેથી, અમે હેડરમાં અનુરૂપ ક્ષેત્રોને શૂન્ય કરીને, વિભાગ કોષ્ટકને ખાલી કાઢી નાખીએ છીએ.

IDA માં ફાઇલ ફરીથી ખોલો.

જાવા વર્ચ્યુઅલ મશીનને કહેવાની બે રીતો છે કે જ્યાં મૂળ લાઇબ્રેરીમાં જાવા કોડમાં નેટિવ તરીકે જાહેર કરાયેલ પદ્ધતિનો અમલ બરાબર સ્થિત છે. પ્રથમ તેને એક પ્રજાતિનું નામ આપવાનું છે Java_package_name_ClassName_MethodName.

બીજું લાઇબ્રેરી લોડ કરતી વખતે તેને રજીસ્ટર કરવાનું છે (ફંક્શનમાં JNI_ઓનલોડ)
ફંક્શન કૉલનો ઉપયોગ કરીને રજીસ્ટર નેટિવ્સ.

અમારા કિસ્સામાં, જો આપણે પ્રથમ પદ્ધતિનો ઉપયોગ કરીએ, તો નામ આના જેવું હોવું જોઈએ: Java_com_taobao_wireless_security_adapter_JNICLlibrary_doCommandNative.

નિકાસ કરેલા કાર્યોમાં આવા કોઈ કાર્ય નથી, જેનો અર્થ છે કે તમારે કૉલ શોધવાની જરૂર છે રજીસ્ટર નેટિવ્સ.
ચાલો ફંક્શન પર જઈએ JNI_ઓનલોડ અને આપણે આ ચિત્ર જોઈએ છીએ:

અહિયાં શું થઇ રહ્યું છે? પ્રથમ નજરમાં, કાર્યની શરૂઆત અને અંત એઆરએમ આર્કિટેક્ચર માટે લાક્ષણિક છે. સ્ટેક પરની પ્રથમ સૂચના રજિસ્ટરની સામગ્રીને સંગ્રહિત કરે છે જેનો ફંક્શન તેની કામગીરીમાં ઉપયોગ કરશે (આ કિસ્સામાં, R0, R1 અને R2), તેમજ LR રજિસ્ટરની સામગ્રીઓ, જેમાં ફંક્શનમાંથી વળતરનું સરનામું છે. . છેલ્લી સૂચના સાચવેલા રજિસ્ટરને પુનઃસ્થાપિત કરે છે, અને વળતરનું સરનામું તરત જ પીસી રજિસ્ટરમાં મૂકવામાં આવે છે - આમ ફંક્શનમાંથી પરત આવે છે. પરંતુ જો તમે નજીકથી જોશો, તો તમે જોશો કે અંતિમ સૂચના સ્ટેક પર સંગ્રહિત રીટર્ન એડ્રેસને બદલે છે. ચાલો ગણતરી કરીએ કે તે પછી કેવું હશે
કોડ એક્ઝેક્યુશન. ચોક્કસ સરનામું 1xB0 R130 માં લોડ થાય છે, તેમાંથી 5 બાદ કરવામાં આવે છે, પછી તે R0 માં સ્થાનાંતરિત થાય છે અને તેમાં 0x10 ઉમેરવામાં આવે છે. તે 0xB13B બહાર વળે છે. આમ, IDA વિચારે છે કે છેલ્લી સૂચના એ સામાન્ય ફંક્શન રીટર્ન છે, પરંતુ હકીકતમાં તે ગણતરી કરેલ સરનામાં 0xB13B પર જઈ રહ્યું છે.

અહીં યાદ રાખવું યોગ્ય છે કે એઆરએમ પ્રોસેસર્સ પાસે બે મોડ્સ અને સૂચનાઓના બે સેટ છે: એઆરએમ અને થમ્બ. સરનામાનો સૌથી ઓછો નોંધપાત્ર ભાગ પ્રોસેસરને જણાવે છે કે કયા સૂચના સેટનો ઉપયોગ કરવામાં આવી રહ્યો છે. એટલે કે, સરનામું વાસ્તવમાં 0xB13A છે, અને ઓછામાં ઓછા નોંધપાત્ર બિટમાંથી એક થમ્બ મોડ સૂચવે છે.

આ લાઇબ્રેરીમાં દરેક ફંક્શનની શરૂઆતમાં સમાન “એડેપ્ટર” ઉમેરવામાં આવ્યું છે અને
કચરો કોડ. અમે તેમના પર વધુ વિગતવાર ધ્યાન આપીશું નહીં - અમને ફક્ત યાદ છે
કે લગભગ તમામ કાર્યોની વાસ્તવિક શરૂઆત થોડી દૂર છે.

કોડ સ્પષ્ટપણે 0xB13A પર જમ્પ કરતો ન હોવાથી, IDA પોતે ઓળખી શક્યું નથી કે કોડ આ સ્થાન પર સ્થિત છે. આ જ કારણોસર, તે લાઇબ્રેરીમાંના મોટાભાગના કોડને કોડ તરીકે ઓળખતું નથી, જે વિશ્લેષણને કંઈક અંશે મુશ્કેલ બનાવે છે. અમે IDA ને કહીએ છીએ કે આ કોડ છે, અને આવું થાય છે:

કોષ્ટક સ્પષ્ટપણે 0xB144 થી શરૂ થાય છે. સબ_494C માં શું છે?

LR રજિસ્ટરમાં આ ફંક્શનને કૉલ કરતી વખતે, અમને અગાઉ ઉલ્લેખિત કોષ્ટક (0xB144) નું સરનામું મળે છે. R0 માં - આ કોષ્ટકમાં અનુક્રમણિકા. એટલે કે, મૂલ્ય કોષ્ટકમાંથી લેવામાં આવે છે, LR માં ઉમેરવામાં આવે છે અને પરિણામ આવે છે
જવાનું સરનામું. ચાલો તેની ગણતરી કરવાનો પ્રયાસ કરીએ: 0xB144 + [0xB144 + 8* 4] = 0xB144 + 0x120 = 0xB264. અમે પ્રાપ્ત સરનામા પર જઈએ છીએ અને શાબ્દિક રીતે કેટલીક ઉપયોગી સૂચનાઓ જોઈએ છીએ અને ફરીથી 0xB140 પર જઈએ છીએ:

હવે ટેબલમાંથી ઇન્ડેક્સ 0x20 સાથે ઑફસેટ પર સંક્રમણ થશે.

કોષ્ટકના કદ દ્વારા અભિપ્રાય આપતા, કોડમાં આવા ઘણા સંક્રમણો હશે. પ્રશ્ન એ ઊભો થાય છે કે શું મેન્યુઅલી સરનામાંની ગણતરી કર્યા વિના, આની સાથે વધુ આપમેળે વ્યવહાર કરવો શક્ય છે કે કેમ. અને સ્ક્રિપ્ટો અને IDA માં કોડ પેચ કરવાની ક્ષમતા અમારી મદદ માટે આવે છે:

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 માં સંક્રમણ જુઓ:

IDA એ ફરીથી આ વિસ્તારને કોડ તરીકે ઓળખ્યો નથી. અમે તેને મદદ કરીએ છીએ અને ત્યાં બીજી ડિઝાઇન જોઈએ છીએ:

BLX પછીની સૂચનાઓ વધુ અર્થપૂર્ણ લાગતી નથી, તે અમુક પ્રકારના વિસ્થાપન જેવું છે. ચાલો સબ_4964 જોઈએ:

અને ખરેખર, અહીં LR માં પડેલા સરનામા પર એક શબ્દ લેવામાં આવે છે, આ સરનામામાં ઉમેરવામાં આવે છે, ત્યારબાદ પરિણામી સરનામા પરની કિંમત લેવામાં આવે છે અને સ્ટેક પર મૂકવામાં આવે છે. ઉપરાંત, LR માં 4 ઉમેરવામાં આવે છે જેથી ફંક્શનમાંથી પાછા ફર્યા પછી, આ જ ઑફસેટ છોડવામાં આવે છે. જે પછી POP {R1} આદેશ સ્ટેકમાંથી પરિણામી મૂલ્ય લે છે. જો તમે 0xB4BA + 0xEA = 0xB5A4 સરનામાં પર શું સ્થિત છે તે જુઓ, તો તમે સરનામાં કોષ્ટક જેવું કંઈક જોશો:

આ ડિઝાઇનને પેચ કરવા માટે, તમારે કોડમાંથી બે પરિમાણો મેળવવાની જરૂર પડશે: ઑફસેટ અને રજિસ્ટર નંબર જેમાં તમે પરિણામ મૂકવા માંગો છો. દરેક સંભવિત રજિસ્ટર માટે, તમારે કોડનો એક ભાગ અગાઉથી તૈયાર કરવો પડશે.

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

અમે કર્સરને સ્ટ્રક્ચરની શરૂઆતમાં મૂકીએ છીએ જેને આપણે બદલવા માંગીએ છીએ - 0xB4B2 - અને સ્ક્રિપ્ટ ચલાવો:

પહેલેથી જ ઉલ્લેખિત માળખાં ઉપરાંત, કોડમાં નીચેનાનો પણ સમાવેશ થાય છે:

અગાઉના કેસની જેમ, BLX સૂચના પછી એક ઑફસેટ છે:

અમે ઑફસેટને એલઆરમાંથી સરનામાં પર લઈએ છીએ, તેને એલઆરમાં ઉમેરીએ છીએ અને ત્યાં જઈએ છીએ. 0x72044 + 0xC = 0x72050. આ ડિઝાઇન માટેની સ્ક્રિપ્ટ એકદમ સરળ છે:

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

સ્ક્રિપ્ટ એક્ઝેક્યુશનનું પરિણામ:

એકવાર ફંક્શનમાં બધું પેચ થઈ જાય, પછી તમે IDA ને તેની વાસ્તવિક શરૂઆત તરફ નિર્દેશ કરી શકો છો. તે બધા ફંક્શન કોડને એકસાથે બનાવશે, અને તેને હેક્સરેનો ઉપયોગ કરીને ડિકમ્પાઇલ કરી શકાય છે.

ડીકોડિંગ શબ્દમાળાઓ

અમે પુસ્તકાલયમાં મશીન કોડની અસ્પષ્ટતા સાથે વ્યવહાર કરવાનું શીખ્યા છીએ libsgmainso-6.4.36.so UC બ્રાઉઝરમાંથી અને ફંક્શન કોડ મેળવ્યો JNI_ઓનલોડ.

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

કાર્યમાં sub_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;
}

કાર્ય sub_7AF78 ઉલ્લેખિત કદના બાઈટ એરે માટે કન્ટેનરનો દાખલો બનાવે છે (અમે આ કન્ટેનર પર વિગતવાર ધ્યાન આપીશું નહીં). અહીં આવા બે કન્ટેનર બનાવવામાં આવ્યા છે: એકમાં લીટી છે "DcO/lcK+h?m3c*q@" (તે અનુમાન લગાવવું સરળ છે કે આ એક કી છે), અન્યમાં એન્ક્રિપ્ટેડ ડેટા છે. આગળ, બંને ઑબ્જેક્ટ્સ ચોક્કસ માળખામાં મૂકવામાં આવે છે, જે ફંક્શનમાં પસાર થાય છે sub_6115C. ચાલો આ સ્ટ્રક્ચરમાં વેલ્યુ 3 સાથે ફીલ્ડ પણ માર્ક કરીએ. ચાલો જોઈએ કે આ સ્ટ્રક્ચરનું આગળ શું થાય છે.

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

સ્વિચ પેરામીટર એ એક સ્ટ્રક્ચર ફીલ્ડ છે જેને અગાઉ મૂલ્ય 3 સોંપવામાં આવ્યું હતું. કેસ 3 જુઓ: કાર્ય માટે sub_6364C પેરામીટર્સ સ્ટ્રક્ચરમાંથી પસાર થાય છે જે ત્યાં પહેલાના ફંક્શનમાં ઉમેરવામાં આવ્યા હતા, એટલે કે કી અને એન્ક્રિપ્ટેડ ડેટા. જો તમે નજીકથી જુઓ sub_6364C, તમે તેમાં RC4 અલ્ગોરિધમને ઓળખી શકો છો.

અમારી પાસે એક અલ્ગોરિધમ અને કી છે. ચાલો વર્ગના નામને સમજવાનો પ્રયાસ કરીએ. શું થયું તે અહીં છે: com/taobao/wireless/security/adapter/JNICLlibrary. મહાન! અમે સાચા માર્ગ પર છીએ.

આદેશ વૃક્ષ

હવે આપણે પડકાર શોધવાની જરૂર છે રજીસ્ટર નેટિવ્સ, જે આપણને ફંક્શન તરફ નિર્દેશ કરશે doCommandNative. ચાલો ફૉરથી મંગાવેલા ફંક્શન્સ જોઈએ JNI_ઓનલોડ, અને અમે તેને શોધીએ છીએ sub_B7B0:

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

અને ખરેખર, નામ સાથેની મૂળ પદ્ધતિ અહીં નોંધાયેલ છે doCommandNative. હવે આપણે તેનું સરનામું જાણીએ છીએ. ચાલો જોઈએ કે તે શું કરે છે.

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

નામ દ્વારા તમે અનુમાન કરી શકો છો કે વિકાસકર્તાઓએ મૂળ લાઇબ્રેરીમાં સ્થાનાંતરિત કરવાનું નક્કી કર્યું છે તે તમામ કાર્યોનો પ્રવેશ બિંદુ અહીં છે. અમને ફંક્શન નંબર 10601 માં રસ છે.

તમે કોડમાંથી જોઈ શકો છો કે આદેશ નંબર ત્રણ નંબરો ઉત્પન્ન કરે છે: આદેશ/10000, આદેશ % 10000 / 100 и આદેશ % 10, એટલે કે, અમારા કિસ્સામાં, 1, 6 અને 1. આ ત્રણ સંખ્યાઓ, તેમજ એક નિર્દેશક JNIEnv અને ફંક્શનમાં પસાર થયેલી દલીલો સ્ટ્રક્ચરમાં ઉમેરવામાં આવે છે અને આગળ વધે છે. મેળવેલ ત્રણ નંબરોનો ઉપયોગ કરીને (ચાલો તેમને N1, N2 અને N3 દર્શાવીએ), એક કમાન્ડ ટ્રી બનાવવામાં આવે છે.

થોડું આના જેવું:

વૃક્ષ ગતિશીલ રીતે ભરવામાં આવે છે JNI_ઓનલોડ.
ત્રણ નંબરો વૃક્ષમાં પાથને એન્કોડ કરે છે. વૃક્ષના દરેક પાંદડામાં અનુરૂપ કાર્યનું પોક કરેલ સરનામું હોય છે. કી પેરેંટ નોડમાં છે. કોડમાં તે સ્થાન શોધવું જ્યાં આપણને જરૂરી ફંક્શન વૃક્ષમાં ઉમેરવામાં આવે છે, જો તમે ઉપયોગમાં લેવાતા તમામ બંધારણોને સમજો છો તો મુશ્કેલ નથી (અમે તેનું વર્ણન કરતા નથી જેથી પહેલેથી જ મોટા લેખને ફૂલે નહીં).

વધુ અસ્પષ્ટતા

અમને ફંક્શનનું સરનામું પ્રાપ્ત થયું છે જે ટ્રાફિકને ડિક્રિપ્ટ કરે છે: 0x5F1AC. પરંતુ આનંદ કરવો ખૂબ જ વહેલો છે: UC બ્રાઉઝરના વિકાસકર્તાઓએ અમારા માટે બીજું આશ્ચર્ય તૈયાર કર્યું છે.

જાવા કોડમાં બનેલા એરેમાંથી પરિમાણો પ્રાપ્ત કર્યા પછી, અમને મળે છે
એડ્રેસ 0x4D070 પર ફંક્શન માટે. અને અહીં અન્ય પ્રકારનો કોડ અસ્પષ્ટતા આપણી રાહ જોઈ રહી છે.

અમે R7 અને R4 માં બે સૂચકાંકો મૂકીએ છીએ:

અમે પ્રથમ ઇન્ડેક્સને R11 પર શિફ્ટ કરીએ છીએ:

કોષ્ટકમાંથી સરનામું મેળવવા માટે, અનુક્રમણિકાનો ઉપયોગ કરો:

પ્રથમ સરનામાં પર ગયા પછી, બીજા ઇન્ડેક્સનો ઉપયોગ થાય છે, જે R4 માં છે. કોષ્ટકમાં 230 તત્વો છે.

તેના વિશે શું કરવું? તમે IDA ને કહી શકો છો કે આ એક સ્વીચ છે: સંપાદિત કરો -> અન્ય -> સ્વીચ રૂઢિપ્રયોગ સ્પષ્ટ કરો.

પરિણામી કોડ ભયંકર છે. પરંતુ, તેના જંગલમાંથી તમારો માર્ગ બનાવતા, તમે અમને પહેલેથી જ પરિચિત ફંક્શન માટે કૉલ નોટિસ કરી શકો છો sub_6115C:

ત્યાં એક સ્વીચ હતી જેમાં કેસ 3 માં RC4 અલ્ગોરિધમનો ઉપયોગ કરીને ડિક્રિપ્શન હતું. અને આ કિસ્સામાં, ફંક્શનમાં પસાર કરાયેલ માળખું પાસ કરેલા પરિમાણોમાંથી ભરવામાં આવે છે doCommandNative. ચાલો યાદ કરીએ કે આપણે ત્યાં શું હતું magicInt મૂલ્ય સાથે 16. અમે અનુરૂપ કેસ જોઈએ છીએ - અને ઘણા સંક્રમણો પછી અમને કોડ મળે છે જેના દ્વારા અલ્ગોરિધમને ઓળખી શકાય છે.

આ AES છે!

અલ્ગોરિધમ અસ્તિત્વમાં છે, જે બાકી છે તે તેના પરિમાણો મેળવવાનું છે: મોડ, કી અને, સંભવતઃ, પ્રારંભિક વેક્ટર (તેની હાજરી AES અલ્ગોરિધમના ઓપરેટિંગ મોડ પર આધારિત છે). તેમની સાથેનું માળખું ફંક્શન કૉલ પહેલાં ક્યાંક રચાયેલ હોવું જોઈએ sub_6115C, પરંતુ કોડનો આ ભાગ ખાસ કરીને સારી રીતે અસ્પષ્ટ છે, તેથી કોડને પેચ કરવાનો વિચાર આવે છે જેથી ડિક્રિપ્શન કાર્યના તમામ પરિમાણો ફાઇલમાં ડમ્પ કરવામાં આવે.

પેચ

બધા પેચ કોડને એસેમ્બલી ભાષામાં મેન્યુઅલી ન લખવા માટે, તમે એન્ડ્રોઇડ સ્ટુડિયો શરૂ કરી શકો છો, ત્યાં એક ફંક્શન લખી શકો છો જે અમારા ડિક્રિપ્શન ફંક્શન જેવા જ ઇનપુટ પરિમાણો મેળવે છે અને ફાઇલમાં લખે છે, પછી કમ્પાઇલર જે કોડ કરશે તેને કોપી-પેસ્ટ કરી શકે છે. પેદા.

UC બ્રાઉઝર ટીમના અમારા મિત્રોએ પણ કોડ ઉમેરવાની સુવિધાનું ધ્યાન રાખ્યું. ચાલો આપણે યાદ રાખીએ કે દરેક કાર્યની શરૂઆતમાં આપણી પાસે ગાર્બેજ કોડ હોય છે જે સરળતાથી અન્ય કોઈપણ સાથે બદલી શકાય છે. ખૂબ અનુકૂળ 🙂 જો કે, લક્ષ્ય કાર્યની શરૂઆતમાં કોડ માટે પૂરતી જગ્યા નથી કે જે ફાઇલમાં તમામ પરિમાણોને સાચવે છે. મારે તેને ભાગોમાં વિભાજિત કરવું પડ્યું અને પડોશી કાર્યોમાંથી કચરાના બ્લોક્સનો ઉપયોગ કરવો પડ્યો. કુલ ચાર ભાગો હતા.

પ્રથમ ભાગ:

એઆરએમ આર્કિટેક્ચરમાં, પ્રથમ ચાર ફંક્શન પરિમાણો રજિસ્ટર R0-R3 દ્વારા પસાર થાય છે, બાકીના, જો કોઈ હોય તો, સ્ટેકમાંથી પસાર થાય છે. LR રજિસ્ટરમાં વળતરનું સરનામું હોય છે. આ બધાને સાચવવાની જરૂર છે જેથી આપણે તેના પરિમાણો ડમ્પ કર્યા પછી ફંક્શન કામ કરી શકે. અમારે તે બધા રજિસ્ટર સાચવવાની પણ જરૂર છે જેનો અમે પ્રક્રિયામાં ઉપયોગ કરીશું, તેથી અમે PUSH.W {R0-R10,LR} કરીએ છીએ. R7 માં અમને સ્ટેક દ્વારા ફંક્શનમાં પસાર કરાયેલા પરિમાણોની સૂચિનું સરનામું મળે છે.

ફંક્શનનો ઉપયોગ કરીને ફોપેન ચાલો ફાઈલ ખોલીએ /data/local/tmp/aes "ab" મોડમાં
એટલે કે ઉમેરા માટે. R0 માં આપણે ફાઇલના નામનું સરનામું લોડ કરીએ છીએ, R1 માં - મોડ સૂચવતી લાઇનનું સરનામું. અને અહીં ગાર્બેજ કોડ સમાપ્ત થાય છે, તેથી આપણે આગળના કાર્ય પર આગળ વધીએ છીએ. તે કામ કરવાનું ચાલુ રાખવા માટે, અમે શરૂઆતમાં કચરાને બાયપાસ કરીને, ફંક્શનના વાસ્તવિક કોડમાં સંક્રમણ મૂકીએ છીએ, અને કચરાને બદલે અમે પેચનું સાતત્ય ઉમેરીએ છીએ.

કૉલિંગ ફોપેન.

ફંક્શનના પ્રથમ ત્રણ પરિમાણો એઇએસ પ્રકાર ધરાવે છે પૂર્ણાંક. અમે શરૂઆતમાં રજિસ્ટરને સ્ટેકમાં સાચવ્યા હોવાથી, અમે ફંક્શનને સરળ રીતે પાસ કરી શકીએ છીએ લખવું સ્ટેક પર તેમના સરનામાં.

આગળ આપણી પાસે ત્રણ સ્ટ્રક્ચર્સ છે જેમાં ડેટાનું કદ અને કી, ઇનિશિયલાઇઝેશન વેક્ટર અને એનક્રિપ્ટેડ ડેટા માટેના ડેટા માટે પોઇન્ટર છે.

અંતે, ફાઇલ બંધ કરો, રજિસ્ટર પુનઃસ્થાપિત કરો અને વાસ્તવિક કાર્ય પર નિયંત્રણ સ્થાનાંતરિત કરો એઇએસ.

અમે પેચ કરેલી લાઇબ્રેરી સાથે એક APK એકત્રિત કરીએ છીએ, તેના પર સહી કરીએ છીએ, તેને ઉપકરણ/ઇમ્યુલેટર પર અપલોડ કરીએ છીએ અને તેને લૉન્ચ કરીએ છીએ. આપણે જોઈએ છીએ કે અમારો ડમ્પ બનાવવામાં આવી રહ્યો છે, અને ત્યાં ઘણો ડેટા લખવામાં આવી રહ્યો છે. બ્રાઉઝર માત્ર ટ્રાફિક માટે જ એન્ક્રિપ્શનનો ઉપયોગ કરે છે, અને તમામ એન્ક્રિપ્શન પ્રશ્નમાં રહેલા કાર્યમાંથી પસાર થાય છે. પરંતુ કેટલાક કારણોસર જરૂરી ડેટા ત્યાં નથી, અને જરૂરી વિનંતી ટ્રાફિકમાં દેખાતી નથી. UC બ્રાઉઝર જરૂરી વિનંતી કરવા માટે તૈયાર ન થાય ત્યાં સુધી રાહ ન જોવા માટે, ચાલો અગાઉ મળેલા સર્વરમાંથી એન્ક્રિપ્ટેડ પ્રતિસાદ લઈએ અને એપ્લિકેશનને ફરીથી પેચ કરીએ: મુખ્ય પ્રવૃત્તિના 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” અને સંખ્યા જોઈએ છીએ. અમે તપાસીએ છીએ: આર્કાઇવનું MD5 સમાન છે, અનપેક્ડ લાઇબ્રેરીનું કદ સમાન છે. અમે આ લાઇબ્રેરીને પેચ કરીને બ્રાઉઝરને આપવાનો પ્રયાસ કરી રહ્યા છીએ. અમારી પેચ કરેલી લાઇબ્રેરી લોડ થઈ ગઈ છે તે બતાવવા માટે, અમે "PWNED!" લખાણ સાથે SMS બનાવવાનો ઉદ્દેશ લૉન્ચ કરીશું. અમે સર્વરમાંથી બે પ્રતિસાદોને બદલીશું: puds.ucweb.com/upgrade/index.xhtml અને આર્કાઇવ ડાઉનલોડ કરવા માટે. પ્રથમ અમે MD5 ને બદલીએ છીએ (અનપૅક કર્યા પછી કદ બદલાતું નથી), બીજામાં અમે પેચ કરેલી લાઇબ્રેરી સાથે આર્કાઇવ આપીએ છીએ.

બ્રાઉઝર આર્કાઇવને ઘણી વખત ડાઉનલોડ કરવાનો પ્રયાસ કરે છે, તે પછી તે ભૂલ આપે છે. દેખીતી રીતે કંઈક
તેને પસંદ નથી. આ અસ્પષ્ટ ફોર્મેટનું વિશ્લેષણ કરવાના પરિણામે, તે બહાર આવ્યું છે કે સર્વર આર્કાઇવના કદને પણ પ્રસારિત કરે છે:

તે LEB128 માં એન્કોડેડ છે. પેચ પછી, લાઇબ્રેરી સાથેના આર્કાઇવનું કદ થોડું બદલાઈ ગયું, તેથી બ્રાઉઝર માન્યું કે આર્કાઇવ કુટિલ રીતે ડાઉનલોડ કરવામાં આવ્યું હતું, અને ઘણા પ્રયત્નો પછી તેમાં ભૂલ થઈ.

અમે આર્કાઇવના કદને સમાયોજિત કરીએ છીએ... અને - વિજય! 🙂 પરિણામ વિડિઓમાં છે.

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

પરિણામો અને વિકાસકર્તા પ્રતિક્રિયા

એ જ રીતે, હેકર્સ દૂષિત પુસ્તકાલયોને વિતરિત કરવા અને ચલાવવા માટે UC બ્રાઉઝરની અસુરક્ષિત સુવિધાનો ઉપયોગ કરી શકે છે. આ લાઇબ્રેરીઓ બ્રાઉઝરના સંદર્ભમાં કામ કરશે, જેથી તેઓ તેની તમામ સિસ્ટમ પરવાનગીઓ પ્રાપ્ત કરશે. પરિણામે, ફિશીંગ વિન્ડો દર્શાવવાની ક્ષમતા, તેમજ નારંગી ચાઈનીઝ ખિસકોલીની કાર્યકારી ફાઈલોની ઍક્સેસ, જેમાં ડેટાબેઝમાં સંગ્રહિત લોગિન, પાસવર્ડ્સ અને કૂકીઝનો સમાવેશ થાય છે.

અમે UC બ્રાઉઝરના વિકાસકર્તાઓનો સંપર્ક કર્યો અને અમને મળેલી સમસ્યા વિશે તેમને જાણ કરી, નબળાઈ અને તેના જોખમને દર્શાવવાનો પ્રયાસ કર્યો, પરંતુ તેઓએ અમારી સાથે કોઈ ચર્ચા કરી નહીં. દરમિયાન, બ્રાઉઝર તેની ખતરનાક સુવિધાને સાદી દૃષ્ટિએ દર્શાવવાનું ચાલુ રાખ્યું. પરંતુ એકવાર અમે નબળાઈની વિગતો જાહેર કરી દીધી, હવે પહેલાની જેમ તેને અવગણવું શક્ય નહોતું. 27 માર્ચ હતી
UC બ્રાઉઝર 12.10.9.1193 નું નવું સંસ્કરણ બહાર પાડવામાં આવ્યું હતું, જેણે HTTPS દ્વારા સર્વરને ઍક્સેસ કર્યું હતું: puds.ucweb.com/upgrade/index.xhtml.

વધુમાં, "ફિક્સ" પછી અને આ લેખ લખવાના સમય સુધી, બ્રાઉઝરમાં પીડીએફ ખોલવાનો પ્રયાસ કરવાથી "અરેરે, કંઈક ખોટું થયું!" લખાણ સાથેનો એક ભૂલ સંદેશ આવ્યો. પીડીએફ ખોલવાનો પ્રયાસ કરતી વખતે સર્વરને વિનંતી કરવામાં આવી ન હતી, પરંતુ જ્યારે બ્રાઉઝર લોંચ કરવામાં આવ્યું ત્યારે વિનંતી કરવામાં આવી હતી, જે Google Play નિયમોના ઉલ્લંઘનમાં એક્ઝિક્યુટેબલ કોડ ડાઉનલોડ કરવાની સતત ક્ષમતાનો સંકેત આપે છે.

સોર્સ: www.habr.com