യുസി ബ്രൗസറിലെ കേടുപാടുകൾക്കായി തിരയുന്നു

ആമുഖം

മാർച്ച് അവസാനം ഞങ്ങൾ അറിയിച്ചു, UC ബ്രൗസറിൽ പരിശോധിച്ചുറപ്പിക്കാത്ത കോഡ് ലോഡ് ചെയ്യാനും പ്രവർത്തിപ്പിക്കാനുമുള്ള ഒരു മറഞ്ഞിരിക്കുന്ന കഴിവ് അവർ കണ്ടെത്തി. ഈ ഡൗൺലോഡ് എങ്ങനെ സംഭവിക്കുന്നുവെന്നും ഹാക്കർമാർക്ക് അവരുടെ സ്വന്തം ആവശ്യങ്ങൾക്ക് ഇത് എങ്ങനെ ഉപയോഗിക്കാമെന്നും ഇന്ന് നമ്മൾ വിശദമായി പരിശോധിക്കും.

കുറച്ച് കാലം മുമ്പ്, യുസി ബ്രൗസർ വളരെ ആക്രമണാത്മകമായി പരസ്യം ചെയ്യുകയും വിതരണം ചെയ്യുകയും ചെയ്തു: ഇത് മാൽവെയർ ഉപയോഗിച്ച് ഉപയോക്താക്കളുടെ ഉപകരണങ്ങളിൽ ഇൻസ്റ്റാൾ ചെയ്തു, വീഡിയോ ഫയലുകളുടെ മറവിൽ വിവിധ സൈറ്റുകളിൽ നിന്ന് വിതരണം ചെയ്തു (അതായത്, ഉപയോക്താക്കൾ അവർ ഡൗൺലോഡ് ചെയ്യുന്നതായി കരുതി, ഉദാഹരണത്തിന്, ഒരു അശ്ലീല വീഡിയോ, പക്ഷേ പകരം ഈ ബ്രൗസറിനൊപ്പം ഒരു APK ലഭിച്ചു), ബ്രൗസർ കാലഹരണപ്പെട്ടതാണെന്നും അപകടസാധ്യതയുള്ളതാണെന്നും അതുപോലുള്ള കാര്യങ്ങൾ ഉണ്ടെന്നുമുള്ള സന്ദേശങ്ങളുള്ള ഭയപ്പെടുത്തുന്ന ബാനറുകൾ ഉപയോഗിച്ചു. വികെയിലെ ഔദ്യോഗിക യുസി ബ്രൗസർ ഗ്രൂപ്പിൽ ഉണ്ട് തീം, അന്യായമായ പരസ്യങ്ങളെക്കുറിച്ച് ഉപയോക്താക്കൾക്ക് പരാതിപ്പെടാൻ കഴിയുന്ന നിരവധി ഉദാഹരണങ്ങളുണ്ട്. 2016-ൽ പോലും ഉണ്ടായിരുന്നു വീഡിയോ പരസ്യംചെയ്യൽ റഷ്യൻ ഭാഷയിൽ (അതെ, ഒരു പരസ്യം തടയുന്ന ബ്രൗസറിനായുള്ള പരസ്യം).

എഴുതുന്ന സമയത്ത്, UC ബ്രൗസറിന് Google Play-യിൽ 500-ലധികം ഇൻസ്റ്റാളേഷനുകളുണ്ട്. ഇത് ശ്രദ്ധേയമാണ് - Google Chrome-ന് മാത്രമേ കൂടുതൽ ഉള്ളൂ. അവലോകനങ്ങൾക്കിടയിൽ, Google Play-യിലെ ചില ആപ്ലിക്കേഷനുകളിലേക്കുള്ള പരസ്യത്തെയും റീഡയറക്‌ടിനെയും കുറിച്ച് നിങ്ങൾക്ക് ധാരാളം പരാതികൾ കാണാൻ കഴിയും. ഞങ്ങളുടെ ഗവേഷണത്തിന്റെ കാരണം ഇതായിരുന്നു: UC ബ്രൗസർ എന്തെങ്കിലും മോശം പ്രവൃത്തി ചെയ്യുന്നുണ്ടോ എന്ന് കാണാൻ ഞങ്ങൾ തീരുമാനിച്ചു. അവൻ അങ്ങനെ ചെയ്യുന്നതായി തെളിഞ്ഞു!

ആപ്ലിക്കേഷൻ കോഡിൽ, എക്സിക്യൂട്ടബിൾ കോഡ് ഡൗൺലോഡ് ചെയ്യാനും പ്രവർത്തിപ്പിക്കാനുമുള്ള കഴിവ് കണ്ടെത്തി, ഇത് ആപ്ലിക്കേഷനുകൾ പ്രസിദ്ധീകരിക്കുന്നതിനുള്ള നിയമങ്ങൾക്ക് വിരുദ്ധമാണ് Google Play-യിൽ. എക്സിക്യൂട്ടബിൾ കോഡ് ഡൗൺലോഡ് ചെയ്യുന്നതിനു പുറമേ, UC ബ്രൗസർ സുരക്ഷിതമല്ലാത്ത രീതിയിലാണ് ചെയ്യുന്നത്, ഇത് ഒരു MitM ആക്രമണം നടത്താൻ ഉപയോഗിക്കാം. അങ്ങനെയൊരു ആക്രമണം നടത്താനാകുമോ എന്ന് നോക്കാം.

പഠനസമയത്ത് Google Play-യിൽ ലഭ്യമായിരുന്ന UC ബ്രൗസറിന്റെ പതിപ്പിന് ചുവടെ എഴുതിയിരിക്കുന്നതെല്ലാം പ്രസക്തമാണ്:

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

ആക്രമണ വെക്റ്റർ

യുസി ബ്രൗസർ മാനിഫെസ്റ്റിൽ നിങ്ങൾക്ക് സ്വയം വിശദീകരിക്കുന്ന പേരുള്ള ഒരു സേവനം കണ്ടെത്താനാകും com.uc.deployment.UpgradeDeployService.

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

ഈ സേവനം ആരംഭിക്കുമ്പോൾ, ബ്രൗസർ ഒരു POST അഭ്യർത്ഥന നടത്തുന്നു puds.ucweb.com/upgrade/index.xhtml, ഇത് ആരംഭിച്ച് കുറച്ച് സമയത്തിന് ശേഷം ട്രാഫിക്കിൽ കാണാൻ കഴിയും. പ്രതികരണമായി, ചില അപ്ഡേറ്റ് അല്ലെങ്കിൽ പുതിയ മൊഡ്യൂൾ ഡൗൺലോഡ് ചെയ്യുന്നതിനുള്ള ഒരു കമാൻഡ് അയാൾക്ക് ലഭിച്ചേക്കാം. വിശകലന സമയത്ത്, സെർവർ അത്തരം കമാൻഡുകൾ നൽകിയില്ല, പക്ഷേ ഞങ്ങൾ ബ്രൗസറിൽ ഒരു PDF തുറക്കാൻ ശ്രമിക്കുമ്പോൾ, മുകളിൽ വ്യക്തമാക്കിയ വിലാസത്തിലേക്ക് അത് രണ്ടാമത്തെ അഭ്യർത്ഥന നടത്തുന്നു, അതിനുശേഷം അത് നേറ്റീവ് ലൈബ്രറി ഡൗൺലോഡ് ചെയ്യുന്നു. ആക്രമണം നടത്താൻ, UC ബ്രൗസറിന്റെ ഈ സവിശേഷത ഉപയോഗിക്കാൻ ഞങ്ങൾ തീരുമാനിച്ചു: ഒരു നേറ്റീവ് ലൈബ്രറി ഉപയോഗിച്ച് PDF തുറക്കാനുള്ള കഴിവ്, അത് APK-യിൽ ഇല്ലാത്തതും ആവശ്യമെങ്കിൽ ഇന്റർനെറ്റിൽ നിന്ന് ഡൗൺലോഡ് ചെയ്യുന്നതുമാണ്. സൈദ്ധാന്തികമായി, ഉപയോക്തൃ ഇടപെടലില്ലാതെ എന്തെങ്കിലും ഡൗൺലോഡ് ചെയ്യാൻ യുസി ബ്രൗസർ നിർബന്ധിതനാകുമെന്നത് ശ്രദ്ധിക്കേണ്ടതാണ് - ബ്രൗസർ സമാരംഭിച്ചതിന് ശേഷം നടപ്പിലാക്കുന്ന ഒരു അഭ്യർത്ഥനയ്ക്ക് നിങ്ങൾ നന്നായി രൂപപ്പെടുത്തിയ പ്രതികരണം നൽകിയാൽ. എന്നാൽ ഇത് ചെയ്യുന്നതിന്, സെർവറുമായുള്ള ഇടപെടലിന്റെ പ്രോട്ടോക്കോൾ ഞങ്ങൾ കൂടുതൽ വിശദമായി പഠിക്കേണ്ടതുണ്ട്, അതിനാൽ തടസ്സപ്പെടുത്തിയ പ്രതികരണം എഡിറ്റുചെയ്യുന്നതും PDF-ൽ പ്രവർത്തിക്കുന്നതിന് ലൈബ്രറി മാറ്റിസ്ഥാപിക്കുന്നതും എളുപ്പമാണെന്ന് ഞങ്ങൾ തീരുമാനിച്ചു.

അതിനാൽ, ഒരു ഉപയോക്താവ് നേരിട്ട് ബ്രൗസറിൽ ഒരു PDF തുറക്കാൻ ആഗ്രഹിക്കുമ്പോൾ, ഇനിപ്പറയുന്ന അഭ്യർത്ഥനകൾ ട്രാഫിക്കിൽ കാണാൻ കഴിയും:

ആദ്യം ഒരു POST അഭ്യർത്ഥനയുണ്ട് puds.ucweb.com/upgrade/index.xhtmlഅതിനുശേഷം
PDF, ഓഫീസ് ഫോർമാറ്റുകൾ കാണുന്നതിന് ലൈബ്രറി ഉള്ള ഒരു ആർക്കൈവ് ഡൗൺലോഡ് ചെയ്തു. ആദ്യത്തെ അഭ്യർത്ഥന സിസ്റ്റത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ കൈമാറുന്നു എന്ന് അനുമാനിക്കുന്നത് യുക്തിസഹമാണ് (കുറഞ്ഞത് ആവശ്യമായ ലൈബ്രറി നൽകാനുള്ള ആർക്കിടെക്ചർ), അതിന് മറുപടിയായി ബ്രൗസറിന് ഡൗൺലോഡ് ചെയ്യേണ്ട ലൈബ്രറിയെക്കുറിച്ചുള്ള ചില വിവരങ്ങൾ ലഭിക്കുന്നു: വിലാസവും, ഒരുപക്ഷേ , വേറെ എന്തെങ്കിലും. ഈ അഭ്യർത്ഥന എൻക്രിപ്റ്റ് ചെയ്തതാണ് പ്രശ്നം.

അഭ്യർത്ഥന ശകലം

ഉത്തരം ശകലം

ലൈബ്രറി തന്നെ ZIP-ൽ പാക്കേജുചെയ്തിരിക്കുന്നു, എൻക്രിപ്റ്റ് ചെയ്തിട്ടില്ല.

ട്രാഫിക് ഡീക്രിപ്ഷൻ കോഡിനായി തിരയുക

സെർവർ പ്രതികരണം മനസ്സിലാക്കാൻ ശ്രമിക്കാം. ക്ലാസ് കോഡ് നോക്കാം 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, അത് യഥാർത്ഥത്തിൽ ഒരു .so അല്ല, ഒരു .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);
}
}

ഒപ്പം ക്ലാസും JNIC ലൈബ്രറി, ഇതിൽ നേറ്റീവ് രീതി പ്രഖ്യാപിച്ചു 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 ഫയൽ ശരിയായി ലോഡ് ചെയ്യാനും അത് വിശകലനം ചെയ്യാനും, ഒരു പ്രോഗ്രാം ഹെഡർ ടേബിൾ മതിയാകും. അതിനാൽ, ഞങ്ങൾ സെക്ഷൻ ടേബിൾ ഇല്ലാതാക്കുന്നു, ഹെഡറിലെ അനുബന്ധ ഫീൽഡുകൾ പൂജ്യമാക്കുന്നു.

ഐഡിഎയിൽ ഫയൽ വീണ്ടും തുറക്കുക.

നേറ്റീവ് ലൈബ്രറിയിൽ ജാവ കോഡിൽ നേറ്റീവ് ആയി പ്രഖ്യാപിച്ച ഒരു രീതി നടപ്പിലാക്കുന്നത് എവിടെയാണെന്ന് ജാവ വെർച്വൽ മെഷീനോട് പറയാൻ രണ്ട് വഴികളുണ്ട്. അതിന് ഒരു സ്പീഷീസ് പേര് നൽകുക എന്നതാണ് ആദ്യത്തേത് Java_package_name_ClassName_MethodName.

രണ്ടാമത്തേത് ലൈബ്രറി ലോഡ് ചെയ്യുമ്പോൾ അത് രജിസ്റ്റർ ചെയ്യുക എന്നതാണ് (ഫംഗ്ഷനിൽ JNI_Onload)
ഒരു ഫംഗ്ഷൻ കോൾ ഉപയോഗിക്കുന്നു രജിസ്റ്റർ സ്വദേശികൾ.

ഞങ്ങളുടെ കാര്യത്തിൽ, ഞങ്ങൾ ആദ്യ രീതി ഉപയോഗിക്കുകയാണെങ്കിൽ, പേര് ഇങ്ങനെയായിരിക്കണം: Java_com_taobao_wireless_security_adapter_JNICLibrary_doCommandNative.

എക്‌സ്‌പോർട്ട് ചെയ്‌ത ഫംഗ്‌ഷനുകൾക്കിടയിൽ അത്തരമൊരു ഫംഗ്‌ഷൻ ഇല്ല, അതിനർത്ഥം നിങ്ങൾ ഒരു കോളിനായി നോക്കേണ്ടതുണ്ട് എന്നാണ് രജിസ്റ്റർ സ്വദേശികൾ.
നമുക്ക് ചടങ്ങിലേക്ക് പോകാം JNI_Onload ഞങ്ങൾ ഈ ചിത്രം കാണുന്നു:

എന്താണ് ഇവിടെ നടക്കുന്നത്? ഒറ്റനോട്ടത്തിൽ, പ്രവർത്തനത്തിന്റെ തുടക്കവും അവസാനവും ARM ആർക്കിടെക്ചറിന് സാധാരണമാണ്. സ്റ്റാക്കിലെ ആദ്യ നിർദ്ദേശം ഫംഗ്‌ഷൻ അതിന്റെ പ്രവർത്തനത്തിൽ ഉപയോഗിക്കുന്ന രജിസ്റ്ററുകളുടെ ഉള്ളടക്കങ്ങളും (ഈ സാഹചര്യത്തിൽ, R0, R1, R2) ഫംഗ്‌ഷനിൽ നിന്നുള്ള മടക്ക വിലാസം അടങ്ങുന്ന LR രജിസ്റ്ററിലെ ഉള്ളടക്കങ്ങളും സംഭരിക്കുന്നു. . അവസാന നിർദ്ദേശം സംരക്ഷിച്ച രജിസ്റ്ററുകൾ പുനഃസ്ഥാപിക്കുന്നു, റിട്ടേൺ വിലാസം ഉടൻ പിസി രജിസ്റ്ററിൽ സ്ഥാപിക്കുന്നു - അങ്ങനെ ഫംഗ്ഷനിൽ നിന്ന് മടങ്ങുന്നു. എന്നാൽ നിങ്ങൾ സൂക്ഷ്മമായി നോക്കുകയാണെങ്കിൽ, അവസാന നിർദ്ദേശം സ്റ്റാക്കിൽ സംഭരിച്ചിരിക്കുന്ന റിട്ടേൺ വിലാസം മാറ്റുന്നത് നിങ്ങൾ ശ്രദ്ധിക്കും. അതിനുശേഷം എങ്ങനെയായിരിക്കുമെന്ന് നമുക്ക് കണക്കാക്കാം
കോഡ് എക്സിക്യൂഷൻ. ഒരു നിശ്ചിത വിലാസം 1xB0 R130-ലേക്ക് ലോഡുചെയ്‌തു, അതിൽ നിന്ന് 5 കുറയ്ക്കുന്നു, തുടർന്ന് അത് R0-ലേക്ക് മാറ്റുകയും 0x10 ചേർക്കുകയും ചെയ്യുന്നു. ഇത് 0xB13B ആയി മാറുന്നു. അതിനാൽ, അവസാന നിർദ്ദേശം ഒരു സാധാരണ ഫംഗ്ഷൻ റിട്ടേൺ ആണെന്ന് IDA കരുതുന്നു, എന്നാൽ വാസ്തവത്തിൽ അത് കണക്കാക്കിയ വിലാസം 0xB13B ലേക്ക് പോകുന്നു.

ARM പ്രോസസറുകൾക്ക് രണ്ട് മോഡുകളും രണ്ട് സെറ്റ് നിർദ്ദേശങ്ങളുമുണ്ടെന്ന കാര്യം ഇവിടെ ഓർക്കേണ്ടതാണ്: ARM, Thumb. വിലാസത്തിന്റെ ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റ് ഏത് ഇൻസ്ട്രക്ഷൻ സെറ്റാണ് ഉപയോഗിക്കുന്നതെന്ന് പ്രോസസ്സറിനോട് പറയുന്നു. അതായത്, വിലാസം യഥാർത്ഥത്തിൽ 0xB13A ആണ്, കൂടാതെ ഏറ്റവും കുറഞ്ഞ ബിറ്റുകളിൽ ഒന്ന് തമ്പ് മോഡിനെ സൂചിപ്പിക്കുന്നു.

ഈ ലൈബ്രറിയിലെ ഓരോ ഫംഗ്‌ഷന്റെ തുടക്കത്തിലും സമാനമായ ഒരു "അഡാപ്റ്റർ" ചേർത്തിട്ടുണ്ട്
മാലിന്യ കോഡ്. ഞങ്ങൾ അവയിൽ കൂടുതൽ വിശദമായി വസിക്കില്ല - ഞങ്ങൾ ഓർക്കുന്നു
മിക്കവാറും എല്ലാ ഫംഗ്‌ഷനുകളുടെയും യഥാർത്ഥ തുടക്കം അൽപ്പം അകലെയാണെന്ന്.

കോഡ് വ്യക്തമായി 0xB13A ലേക്ക് പോകാത്തതിനാൽ, ഈ ലൊക്കേഷനിലാണ് കോഡ് സ്ഥിതിചെയ്യുന്നതെന്ന് IDA തന്നെ തിരിച്ചറിഞ്ഞില്ല. അതേ കാരണത്താൽ, ലൈബ്രറിയിലെ മിക്ക കോഡുകളും കോഡായി ഇത് തിരിച്ചറിയുന്നില്ല, ഇത് വിശകലനം കുറച്ച് ബുദ്ധിമുട്ടാക്കുന്നു. ഇതാണ് കോഡ് എന്ന് ഞങ്ങൾ IDA-യോട് പറയുന്നു, ഇതാണ് സംഭവിക്കുന്നത്:

പട്ടിക വ്യക്തമായി 0xB144 ൽ ആരംഭിക്കുന്നു. sub_494C-യിൽ എന്താണ് ഉള്ളത്?

എൽആർ രജിസ്റ്ററിൽ ഈ ഫംഗ്ഷൻ വിളിക്കുമ്പോൾ, മുമ്പ് സൂചിപ്പിച്ച പട്ടികയുടെ (0xB144) വിലാസം നമുക്ക് ലഭിക്കും. R0-ൽ - ഈ പട്ടികയിലെ സൂചിക. അതായത്, മൂല്യം പട്ടികയിൽ നിന്ന് എടുത്ത്, LR-ലേക്ക് ചേർത്തു, ഫലം
പോകേണ്ട വിലാസം. നമുക്ക് ഇത് കണക്കാക്കാൻ ശ്രമിക്കാം: 0xB144 + [0xB144 + 8* 4] = 0xB144 + 0x120 = 0xB264. ഞങ്ങൾ സ്വീകരിച്ച വിലാസത്തിലേക്ക് പോയി അക്ഷരാർത്ഥത്തിൽ കുറച്ച് ഉപയോഗപ്രദമായ നിർദ്ദേശങ്ങൾ കാണുകയും വീണ്ടും 0xB140 ലേക്ക് പോകുകയും ചെയ്യുന്നു:

ഇപ്പോൾ പട്ടികയിൽ നിന്ന് സൂചിക 0x20 ഉപയോഗിച്ച് ഓഫ്സെറ്റിൽ ഒരു പരിവർത്തനം ഉണ്ടാകും.

പട്ടികയുടെ വലിപ്പം അനുസരിച്ച്, കോഡിൽ അത്തരം നിരവധി പരിവർത്തനങ്ങൾ ഉണ്ടാകും. വിലാസങ്ങൾ സ്വമേധയാ കണക്കാക്കാതെ, ഇത് എങ്ങനെയെങ്കിലും സ്വയമേവ കൈകാര്യം ചെയ്യാൻ കഴിയുമോ എന്ന ചോദ്യം ഉയർന്നുവരുന്നു. കൂടാതെ സ്ക്രിപ്റ്റുകളും ഐഡിഎയിൽ കോഡ് പാച്ച് ചെയ്യാനുള്ള കഴിവും ഞങ്ങളുടെ സഹായത്തിന് വരുന്നു:

def put_unconditional_branch(source, destination):
offset = (destination - source - 4) >> 1
if offset > 2097151 or offset < -2097152:
raise RuntimeError("Invalid offset")
if offset > 1023 or offset < -1024:
instruction1 = 0xf000 | ((offset >> 11) & 0x7ff)
instruction2 = 0xb800 | (offset & 0x7ff)
patch_word(source, instruction1)
patch_word(source + 2, instruction2)
else:
instruction = 0xe000 | (offset & 0x7ff)
patch_word(source, instruction)
ea = here()
if get_wide_word(ea) == 0xb503: #PUSH {R0,R1,LR}
ea1 = ea + 2
if get_wide_word(ea1) == 0xbf00: #NOP
ea1 += 2
if get_operand_type(ea1, 0) == 1 and get_operand_value(ea1, 0) == 0 and get_operand_type(ea1, 1) == 2:
index = get_wide_dword(get_operand_value(ea1, 1))
print "index =", hex(index)
ea1 += 2
if get_operand_type(ea1, 0) == 7:
table = get_operand_value(ea1, 0) + 4
elif get_operand_type(ea1, 1) == 2:
table = get_operand_value(ea1, 1) + 4
else:
print "Wrong operand type on", hex(ea1), "-", get_operand_type(ea1, 0), get_operand_type(ea1, 1)
table = None
if table is None:
print "Unable to find table"
else:
print "table =", hex(table)
offset = get_wide_dword(table + (index << 2))
put_unconditional_branch(ea, table + offset)
else:
print "Unknown code", get_operand_type(ea1, 0), get_operand_value(ea1, 0), get_operand_type(ea1, 1) == 2
else:
print "Unable to detect first instruction"

കഴ്‌സർ 0xB26A വരിയിൽ വയ്ക്കുക, സ്‌ക്രിപ്റ്റ് പ്രവർത്തിപ്പിച്ച് 0xB4B0-ലേക്കുള്ള മാറ്റം കാണുക:

IDA വീണ്ടും ഈ പ്രദേശത്തെ ഒരു കോഡായി അംഗീകരിച്ചില്ല. ഞങ്ങൾ അവളെ സഹായിക്കുകയും അവിടെ മറ്റൊരു ഡിസൈൻ കാണുകയും ചെയ്യുന്നു:

BLX-ന് ശേഷമുള്ള നിർദ്ദേശങ്ങൾ വളരെ അർത്ഥമുള്ളതായി തോന്നുന്നില്ല, ഇത് ഒരുതരം സ്ഥാനചലനം പോലെയാണ്. നമുക്ക് sub_4964 നോക്കാം:

തീർച്ചയായും, ഇവിടെ LR-ൽ കിടക്കുന്ന വിലാസത്തിൽ ഒരു dword എടുക്കുന്നു, ഈ വിലാസത്തിലേക്ക് ചേർത്തു, അതിനുശേഷം ലഭിച്ച വിലാസത്തിലെ മൂല്യം എടുത്ത് സ്റ്റാക്കിൽ ഇടുന്നു. കൂടാതെ, 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 നിർദ്ദേശത്തിന് ശേഷം ഒരു ഓഫ്‌സെറ്റ് ഉണ്ട്:

ഞങ്ങൾ LR-ൽ നിന്ന് വിലാസത്തിലേക്ക് ഓഫ്‌സെറ്റ് എടുക്കുകയും അത് LR-ലേക്ക് ചേർക്കുകയും അവിടെ പോകുകയും ചെയ്യുന്നു. 0x72044 + 0xC = 0x72050. ഈ ഡിസൈനിന്റെ സ്ക്രിപ്റ്റ് വളരെ ലളിതമാണ്:

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

സ്ക്രിപ്റ്റ് എക്സിക്യൂഷന്റെ ഫലം:

ഫംഗ്‌ഷനിൽ എല്ലാം പാച്ച് ചെയ്‌തുകഴിഞ്ഞാൽ, നിങ്ങൾക്ക് IDA അതിന്റെ യഥാർത്ഥ തുടക്കത്തിലേക്ക് ചൂണ്ടിക്കാണിക്കാൻ കഴിയും. ഇത് എല്ലാ ഫംഗ്‌ഷൻ കോഡും ഒരുമിച്ച് ചേർക്കും, കൂടാതെ ഇത് HexRays ഉപയോഗിച്ച് ഡീകംപൈൽ ചെയ്യാവുന്നതാണ്.

സ്ട്രിംഗുകൾ ഡീകോഡിംഗ്

ലൈബ്രറിയിലെ മെഷീൻ കോഡിന്റെ അവ്യക്തത കൈകാര്യം ചെയ്യാൻ ഞങ്ങൾ പഠിച്ചു libsgmainso-6.4.36.so യുസി ബ്രൗസറിൽ നിന്ന് ഫംഗ്‌ഷൻ കോഡ് ലഭിച്ചു JNI_Onload.

int __fastcall real_JNI_OnLoad(JavaVM *vm)
{
int result; // r0
jclass clazz; // r0 MAPDST
int v4; // r0
JNIEnv *env; // r4
int v6; // [sp-40h] [bp-5Ch]
int v7; // [sp+Ch] [bp-10h]
v7 = *(_DWORD *)off_8AC00;
if ( !vm )
goto LABEL_39;
sub_7C4F4();
env = (JNIEnv *)sub_7C5B0(0);
if ( !env )
goto LABEL_39;
v4 = sub_72CCC();
sub_73634(v4);
sub_73E24(&unk_83EA6, &v6, 49);
clazz = (jclass)((int (__fastcall *)(JNIEnv *, int *))(*env)->FindClass)(env, &v6);
if ( clazz
&& (sub_9EE4(),
sub_71D68(env),
sub_E7DC(env) >= 0
&& sub_69D68(env) >= 0
&& sub_197B4(env, clazz) >= 0
&& sub_E240(env, clazz) >= 0
&& sub_B8B0(env, clazz) >= 0
&& sub_5F0F4(env, clazz) >= 0
&& sub_70640(env, clazz) >= 0
&& sub_11F3C(env) >= 0
&& sub_21C3C(env, clazz) >= 0
&& sub_2148C(env, clazz) >= 0
&& sub_210E0(env, clazz) >= 0
&& sub_41B58(env, clazz) >= 0
&& sub_27920(env, clazz) >= 0
&& sub_293E8(env, clazz) >= 0
&& sub_208F4(env, clazz) >= 0) )
{
result = (sub_B7B0(env, clazz) >> 31) | 0x10004;
}
else
{
LABEL_39:
result = -1;
}
return result;
}

ഇനിപ്പറയുന്ന വരികൾ നമുക്ക് സൂക്ഷ്മമായി പരിശോധിക്കാം:

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

പ്രവർത്തനത്തിലാണ് sub_73E24 ക്ലാസ്സിന്റെ പേര് വ്യക്തമായി ഡീക്രിപ്റ്റ് ചെയ്യപ്പെടുന്നു. ഈ ഫംഗ്‌ഷന്റെ പാരാമീറ്ററുകൾ എന്ന നിലയിൽ, എൻക്രിപ്റ്റ് ചെയ്‌ത ഡാറ്റയ്‌ക്ക് സമാനമായ ഡാറ്റയിലേക്കുള്ള ഒരു പോയിന്റർ, ഒരു നിശ്ചിത ബഫറും ഒരു നമ്പറും കൈമാറുന്നു. വ്യക്തമായും, ഫംഗ്‌ഷനെ വിളിച്ചതിനുശേഷം, ബഫറിൽ ഒരു ഡീക്രിപ്റ്റ് ചെയ്‌ത ലൈൻ ഉണ്ടാകും, കാരണം അത് ഫംഗ്‌ഷനിലേക്ക് കൈമാറുന്നു. FindClass, ക്ലാസിന്റെ പേര് രണ്ടാമത്തെ പാരാമീറ്ററായി എടുക്കുന്നു. അതിനാൽ, ബഫറിന്റെ വലുപ്പമോ വരിയുടെ നീളമോ ആണ് നമ്പർ. ക്ലാസ്സിന്റെ പേര് മനസ്സിലാക്കാൻ ശ്രമിക്കാം, നമ്മൾ ശരിയായ ദിശയിലാണോ പോകുന്നതെന്ന് അത് നമ്മോട് പറയും. എന്താണ് സംഭവിക്കുന്നതെന്ന് നമുക്ക് സൂക്ഷ്മമായി പരിശോധിക്കാം sub_73E24.

int __fastcall sub_73E56(unsigned __int8 *in, unsigned __int8 *out, size_t size)
{
int v4; // r6
int v7; // r11
int v8; // r9
int v9; // r4
size_t v10; // r5
int v11; // r0
struc_1 v13; // [sp+0h] [bp-30h]
int v14; // [sp+1Ch] [bp-14h]
int v15; // [sp+20h] [bp-10h]
v4 = 0;
v15 = *(_DWORD *)off_8AC00;
v14 = 0;
v7 = sub_7AF78(17);
v8 = sub_7AF78(size);
if ( !v7 )
{
v9 = 0;
goto LABEL_12;
}
(*(void (__fastcall **)(int, const char *, int))(v7 + 12))(v7, "DcO/lcK+h?m3c*q@", 16);
if ( !v8 )
{
LABEL_9:
v4 = 0;
goto LABEL_10;
}
v4 = 0;
if ( !in )
{
LABEL_10:
v9 = 0;
goto LABEL_11;
}
v9 = 0;
if ( out )
{
memset(out, 0, size);
v10 = size - 1;
(*(void (__fastcall **)(int, unsigned __int8 *, size_t))(v8 + 12))(v8, in, v10);
memset(&v13, 0, 0x14u);
v13.field_4 = 3;
v13.field_10 = v7;
v13.field_14 = v8;
v11 = sub_6115C(&v13, &v14);
v9 = v11;
if ( v11 )
{
if ( *(_DWORD *)(v11 + 4) == v10 )
{
qmemcpy(out, *(const void **)v11, v10);
v4 = *(_DWORD *)(v9 + 4);
}
else
{
v4 = 0;
}
goto LABEL_11;
}
goto LABEL_9;
}
LABEL_11:
sub_7B148(v7);
LABEL_12:
if ( v8 )
sub_7B148(v8);
if ( v9 )
sub_7B148(v9);
return v4;
}

ഫംഗ്ഷൻ sub_7AF78 നിർദ്ദിഷ്‌ട വലുപ്പത്തിലുള്ള ബൈറ്റ് അറേകൾക്കായി ഒരു കണ്ടെയ്‌നറിന്റെ ഒരു ഉദാഹരണം സൃഷ്‌ടിക്കുന്നു (ഞങ്ങൾ ഈ കണ്ടെയ്‌നറുകളിൽ വിശദമായി വസിക്കില്ല). ഇവിടെ അത്തരം രണ്ട് കണ്ടെയ്നറുകൾ സൃഷ്ടിക്കപ്പെടുന്നു: ഒന്നിൽ ലൈൻ അടങ്ങിയിരിക്കുന്നു "DcO/lcK+h?m3c*q@" (ഇതൊരു കീയാണെന്ന് ഊഹിക്കാൻ എളുപ്പമാണ്), മറ്റൊന്നിൽ എൻക്രിപ്റ്റ് ചെയ്ത ഡാറ്റ അടങ്ങിയിരിക്കുന്നു. അടുത്തതായി, രണ്ട് വസ്തുക്കളും ഒരു നിശ്ചിത ഘടനയിൽ സ്ഥാപിച്ചിരിക്കുന്നു, അത് ഫംഗ്ഷനിലേക്ക് കൈമാറുന്നു സബ്_6115 സി. ഈ ഘടനയിൽ മൂല്യം 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 നോക്കുക: ഫംഗ്‌ഷനിലേക്ക് സബ്_6364 സി മുൻ ഫംഗ്ഷനിൽ ചേർത്ത ഘടനയിൽ നിന്ന് പാരാമീറ്ററുകൾ കൈമാറുന്നു, അതായത് കീയും എൻക്രിപ്റ്റ് ചെയ്ത ഡാറ്റയും. നിങ്ങൾ സൂക്ഷ്മമായി നോക്കിയാൽ സബ്_6364 സി, നിങ്ങൾക്ക് അതിൽ RC4 അൽഗോരിതം തിരിച്ചറിയാൻ കഴിയും.

ഞങ്ങൾക്ക് ഒരു അൽഗോരിതവും ഒരു കീയും ഉണ്ട്. ക്ലാസ്സിന്റെ പേര് മനസ്സിലാക്കാൻ ശ്രമിക്കാം. സംഭവിച്ചത് ഇതാ: com/taobao/wireless/security/adapter/JNICLibrary. കൊള്ളാം! ഞങ്ങൾ ശരിയായ പാതയിലാണ്.

കമാൻഡ് ട്രീ

ഇനി നമ്മൾ ഒരു വെല്ലുവിളി കണ്ടെത്തണം രജിസ്റ്റർ സ്വദേശികൾ, അത് ഫംഗ്ഷനിലേക്ക് നമ്മെ ചൂണ്ടിക്കാണിക്കും doCommandNative. എന്നതിൽ നിന്ന് വിളിക്കുന്ന ഫംഗ്ഷനുകൾ നോക്കാം JNI_Onload, ഞങ്ങൾ അത് കണ്ടെത്തുകയും ചെയ്യുന്നു ഉപ_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_Onload.
മൂന്ന് അക്കങ്ങൾ മരത്തിലെ പാതയെ എൻകോഡ് ചെയ്യുന്നു. മരത്തിന്റെ ഓരോ ഇലയിലും അനുബന്ധ പ്രവർത്തനത്തിന്റെ പോക്ക് ചെയ്ത വിലാസം അടങ്ങിയിരിക്കുന്നു. കീ പാരന്റ് നോഡിലാണ്. ഉപയോഗിച്ച എല്ലാ ഘടനകളും നിങ്ങൾ മനസ്സിലാക്കിയാൽ, ഞങ്ങൾക്ക് ആവശ്യമായ ഫംഗ്ഷൻ ട്രീയിൽ ചേർത്തിരിക്കുന്ന കോഡിലെ സ്ഥലം കണ്ടെത്തുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല (ഇതിനകം വലിയൊരു ലേഖനം വീർക്കാതിരിക്കാൻ ഞങ്ങൾ അവയെ വിവരിക്കുന്നില്ല).

കൂടുതൽ അവ്യക്തത

ട്രാഫിക് ഡീക്രിപ്റ്റ് ചെയ്യേണ്ട ഫംഗ്‌ഷന്റെ വിലാസം ഞങ്ങൾക്ക് ലഭിച്ചു: 0x5F1AC. എന്നാൽ സന്തോഷിക്കാൻ വളരെ നേരത്തെ തന്നെ: യുസി ബ്രൗസറിന്റെ ഡെവലപ്പർമാർ ഞങ്ങൾക്കായി മറ്റൊരു സർപ്രൈസ് തയ്യാറാക്കിയിട്ടുണ്ട്.

ജാവ കോഡിൽ രൂപീകരിച്ച അറേയിൽ നിന്ന് പാരാമീറ്ററുകൾ ലഭിച്ച ശേഷം, നമുക്ക് ലഭിക്കും
0x4D070 എന്ന വിലാസത്തിലുള്ള ഫംഗ്‌ഷനിലേക്ക്. ഇവിടെ മറ്റൊരു തരത്തിലുള്ള കോഡ് അവ്യക്തത നമ്മെ കാത്തിരിക്കുന്നു.

ഞങ്ങൾ R7, R4 എന്നിവയിൽ രണ്ട് സൂചികകൾ സ്ഥാപിച്ചു:

ഞങ്ങൾ ആദ്യ സൂചിക R11 ലേക്ക് മാറ്റുന്നു:

ഒരു പട്ടികയിൽ നിന്ന് ഒരു വിലാസം ലഭിക്കുന്നതിന്, ഒരു സൂചിക ഉപയോഗിക്കുക:

ആദ്യത്തെ വിലാസത്തിലേക്ക് പോയതിനുശേഷം, രണ്ടാമത്തെ സൂചിക ഉപയോഗിക്കുന്നു, അത് R4-ൽ ആണ്. പട്ടികയിൽ 230 ഘടകങ്ങൾ ഉണ്ട്.

അതിന് എന്ത് ചെയ്യണം? ഇതൊരു സ്വിച്ച് ആണെന്ന് നിങ്ങൾക്ക് IDA-നോട് പറയാം: എഡിറ്റ് -> മറ്റുള്ളവ -> സ്വിച്ച് ഐഡിയം വ്യക്തമാക്കുക.

തത്ഫലമായുണ്ടാകുന്ന കോഡ് ഭയങ്കരമാണ്. പക്ഷേ, അതിന്റെ കാട്ടിലൂടെ കടന്നുപോകുമ്പോൾ, ഞങ്ങൾക്ക് ഇതിനകം പരിചിതമായ ഒരു ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു കോൾ നിങ്ങൾക്ക് കാണാൻ കഴിയും സബ്_6115 സി:

കേസ് 3-ൽ RC4 അൽഗോരിതം ഉപയോഗിച്ച് ഒരു ഡീക്രിപ്ഷൻ ഉള്ള ഒരു സ്വിച്ച് ഉണ്ടായിരുന്നു. ഈ സാഹചര്യത്തിൽ, ഫംഗ്ഷനിലേക്ക് കൈമാറിയ ഘടന പാരാമീറ്ററുകളിൽ നിന്ന് പൂരിപ്പിക്കുന്നു doCommandNative. നമുക്ക് അവിടെ ഉണ്ടായിരുന്നത് ഓർക്കാം magicInt മൂല്യം 16. ഞങ്ങൾ അനുബന്ധ കേസ് നോക്കുന്നു - നിരവധി സംക്രമണങ്ങൾക്ക് ശേഷം അൽഗോരിതം തിരിച്ചറിയാൻ കഴിയുന്ന കോഡ് ഞങ്ങൾ കണ്ടെത്തുന്നു.

ഇതാണ് AES!

അൽഗോരിതം നിലവിലുണ്ട്, അതിന്റെ പാരാമീറ്ററുകൾ നേടുക മാത്രമാണ് അവശേഷിക്കുന്നത്: മോഡ്, കീ, ഒരുപക്ഷേ, ഇനീഷ്യലൈസേഷൻ വെക്റ്റർ (അതിന്റെ സാന്നിധ്യം എഇഎസ് അൽഗോരിതത്തിന്റെ ഓപ്പറേറ്റിംഗ് മോഡിനെ ആശ്രയിച്ചിരിക്കുന്നു). ഫംഗ്ഷൻ കോളിന് മുമ്പ് അവരുമായുള്ള ഘടന എവിടെയെങ്കിലും രൂപീകരിക്കണം സബ്_6115 സി, എന്നാൽ കോഡിന്റെ ഈ ഭാഗം പ്രത്യേകിച്ച് അവ്യക്തമാണ്, അതിനാൽ കോഡ് പാച്ച് ചെയ്യാനുള്ള ആശയം ഉയർന്നുവരുന്നു, അങ്ങനെ ഡീക്രിപ്ഷൻ ഫംഗ്ഷന്റെ എല്ലാ പാരാമീറ്ററുകളും ഒരു ഫയലിലേക്ക് വലിച്ചെറിയപ്പെടും.

പാച്ച്

അസംബ്ലി ഭാഷയിൽ എല്ലാ പാച്ച് കോഡുകളും സ്വമേധയാ എഴുതാതിരിക്കാൻ, നിങ്ങൾക്ക് ആൻഡ്രോയിഡ് സ്റ്റുഡിയോ സമാരംഭിക്കാം, ഞങ്ങളുടെ ഡീക്രിപ്ഷൻ ഫംഗ്‌ഷന്റെ അതേ ഇൻപുട്ട് പാരാമീറ്ററുകൾ സ്വീകരിക്കുന്ന ഒരു ഫംഗ്ഷൻ അവിടെ എഴുതുകയും ഒരു ഫയലിലേക്ക് എഴുതുകയും ചെയ്യാം, തുടർന്ന് കംപൈലർ ചെയ്യുന്ന കോഡ് പകർത്തി ഒട്ടിക്കുക. സൃഷ്ടിക്കുക.

യുസി ബ്രൗസർ ടീമിലെ ഞങ്ങളുടെ സുഹൃത്തുക്കളും കോഡ് ചേർക്കുന്നതിനുള്ള സൗകര്യം ഏറ്റെടുത്തു. ഓരോ ഫംഗ്‌ഷന്റെയും തുടക്കത്തിൽ നമുക്ക് ഗാർബേജ് കോഡ് ഉണ്ടെന്ന് ഓർക്കാം, അത് മറ്റേതെങ്കിലും ഉപയോഗിച്ച് എളുപ്പത്തിൽ മാറ്റിസ്ഥാപിക്കാൻ കഴിയും. വളരെ സൗകര്യപ്രദമാണ് 🙂 എന്നിരുന്നാലും, ടാർഗെറ്റ് ഫംഗ്ഷന്റെ തുടക്കത്തിൽ ഒരു ഫയലിലേക്ക് എല്ലാ പാരാമീറ്ററുകളും സംരക്ഷിക്കുന്ന കോഡിന് മതിയായ ഇടമില്ല. എനിക്ക് അതിനെ ഭാഗങ്ങളായി വിഭജിക്കുകയും അയൽ ഫംഗ്ഷനുകളിൽ നിന്ന് മാലിന്യ ബ്ലോക്കുകൾ ഉപയോഗിക്കുകയും ചെയ്യേണ്ടിവന്നു. ആകെ നാല് ഭാഗങ്ങൾ ഉണ്ടായിരുന്നു.

ആദ്യ ഭാഗം:

ARM ആർക്കിടെക്ചറിൽ, ആദ്യത്തെ നാല് ഫംഗ്ഷൻ പാരാമീറ്ററുകൾ R0-R3 രജിസ്റ്ററുകളിലൂടെ കടന്നുപോകുന്നു, ബാക്കിയുള്ളവ, എന്തെങ്കിലും ഉണ്ടെങ്കിൽ, സ്റ്റാക്കിലൂടെ കടന്നുപോകുന്നു. എൽആർ രജിസ്റ്റർ റിട്ടേൺ വിലാസം ഉൾക്കൊള്ളുന്നു. ഇതെല്ലാം സംരക്ഷിക്കേണ്ടതുണ്ട്, അതുവഴി ഞങ്ങൾ അതിന്റെ പാരാമീറ്ററുകൾ ഉപേക്ഷിച്ചതിനുശേഷം ഫംഗ്ഷൻ പ്രവർത്തിക്കും. പ്രക്രിയയിൽ ഞങ്ങൾ ഉപയോഗിക്കുന്ന എല്ലാ രജിസ്റ്ററുകളും സംരക്ഷിക്കേണ്ടതുണ്ട്, അതിനാൽ ഞങ്ങൾ PUSH.W {R0-R10,LR} ചെയ്യുന്നു. R7-ൽ, സ്റ്റാക്ക് വഴി ഫംഗ്ഷനിലേക്ക് പാസാക്കിയ പാരാമീറ്ററുകളുടെ ലിസ്റ്റിന്റെ വിലാസം നമുക്ക് ലഭിക്കും.

ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു fopen നമുക്ക് ഫയൽ തുറക്കാം /data/local/tmp/aes "ab" മോഡിൽ
അതായത് കൂട്ടിച്ചേർക്കലിന്. R0-ൽ ഞങ്ങൾ ഫയലിന്റെ പേരിന്റെ വിലാസം ലോഡ് ചെയ്യുന്നു, R1-ൽ - മോഡ് സൂചിപ്പിക്കുന്ന വരിയുടെ വിലാസം. ഇവിടെ ഗാർബേജ് കോഡ് അവസാനിക്കുന്നു, അതിനാൽ ഞങ്ങൾ അടുത്ത പ്രവർത്തനത്തിലേക്ക് നീങ്ങുന്നു. ഇത് പ്രവർത്തിക്കുന്നത് തുടരുന്നതിന്, മാലിന്യത്തെ മറികടന്ന് ഫംഗ്ഷന്റെ യഥാർത്ഥ കോഡിലേക്കുള്ള പരിവർത്തനം ഞങ്ങൾ തുടക്കത്തിൽ ഇട്ടു, മാലിന്യത്തിന് പകരം ഞങ്ങൾ പാച്ചിന്റെ തുടർച്ച ചേർക്കുന്നു.

വിളിക്കുന്നു fopen.

ഫംഗ്ഷന്റെ ആദ്യ മൂന്ന് പാരാമീറ്ററുകൾ AES തരം ഉണ്ട് int. ഞങ്ങൾ രജിസ്റ്ററുകൾ തുടക്കത്തിൽ സ്റ്റാക്കിലേക്ക് സംരക്ഷിച്ചതിനാൽ, നമുക്ക് ഫംഗ്ഷൻ പാസാക്കാം fwrite സ്റ്റാക്കിൽ അവരുടെ വിലാസങ്ങൾ.

അടുത്തതായി നമുക്ക് മൂന്ന് ഘടനകൾ ഉണ്ട്, അതിൽ ഡാറ്റ വലുപ്പവും കീ, ഇനീഷ്യലൈസേഷൻ വെക്റ്റർ, എൻക്രിപ്റ്റ് ചെയ്ത ഡാറ്റ എന്നിവയ്ക്കുള്ള ഡാറ്റയിലേക്കുള്ള ഒരു പോയിന്ററും അടങ്ങിയിരിക്കുന്നു.

അവസാനം, ഫയൽ അടയ്ക്കുക, രജിസ്റ്ററുകൾ പുനഃസ്ഥാപിക്കുക, യഥാർത്ഥ പ്രവർത്തനത്തിലേക്ക് നിയന്ത്രണം കൈമാറുക AES.

പാച്ച് ചെയ്‌ത ലൈബ്രറി ഉപയോഗിച്ച് ഞങ്ങൾ ഒരു APK ശേഖരിക്കുകയും ഒപ്പിടുകയും ഉപകരണത്തിലേക്ക്/എമുലേറ്ററിലേക്ക് അപ്‌ലോഡ് ചെയ്യുകയും സമാരംഭിക്കുകയും ചെയ്യുന്നു. ഞങ്ങളുടെ ഡംപ് സൃഷ്‌ടിക്കപ്പെടുന്നതും ധാരാളം ഡാറ്റ അവിടെ എഴുതുന്നതും ഞങ്ങൾ കാണുന്നു. ബ്രൗസർ ട്രാഫിക്കിന് മാത്രമല്ല എൻക്രിപ്ഷൻ ഉപയോഗിക്കുന്നു, കൂടാതെ എല്ലാ എൻക്രിപ്ഷനുകളും പ്രസ്തുത പ്രവർത്തനത്തിലൂടെ കടന്നുപോകുന്നു. എന്നാൽ ചില കാരണങ്ങളാൽ ആവശ്യമായ ഡാറ്റ ഇല്ല, ആവശ്യമായ അഭ്യർത്ഥന ട്രാഫിക്കിൽ ദൃശ്യമാകില്ല. ആവശ്യമായ അഭ്യർത്ഥന നടത്താൻ യുസി ബ്രൗസർ രൂപകൽപ്പന ചെയ്യുന്നത് വരെ കാത്തിരിക്കാതിരിക്കാൻ, നേരത്തെ ലഭിച്ച സെർവറിൽ നിന്ന് എൻക്രിപ്റ്റ് ചെയ്ത പ്രതികരണം എടുത്ത് ആപ്ലിക്കേഷൻ വീണ്ടും പാച്ച് ചെയ്യാം: പ്രധാന പ്രവർത്തനത്തിന്റെ 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/" ലഭിക്കും, APK-യിൽ ആ പേരിൽ ഒരു ഫോൾഡർ സൃഷ്‌ടിച്ച് അവിടെ അണ്ണാൻ ബ്രൗസർ സർട്ടിഫിക്കറ്റ് ചേർക്കുക.

ഞങ്ങൾ കൂട്ടിച്ചേർക്കുന്നു, ഒപ്പിടുന്നു, ഇൻസ്റ്റാൾ ചെയ്യുന്നു, സമാരംഭിക്കുന്നു. ബിങ്കോ! ഞങ്ങൾക്ക് താക്കോലുണ്ട്!

MitM

ഞങ്ങൾക്ക് ഒരു കീയും കീക്ക് തുല്യമായ ഒരു ഇനീഷ്യലൈസേഷൻ വെക്‌ടറും ലഭിച്ചു. CBC മോഡിൽ സെർവർ പ്രതികരണം ഡീക്രിപ്റ്റ് ചെയ്യാൻ ശ്രമിക്കാം.

MD5, “extract_unzipsize”, ഒരു നമ്പർ എന്നിവയ്ക്ക് സമാനമായ ആർക്കൈവ് URL ഞങ്ങൾ കാണുന്നു. ഞങ്ങൾ പരിശോധിക്കുന്നു: ആർക്കൈവിന്റെ MD5 സമാനമാണ്, പായ്ക്ക് ചെയ്യാത്ത ലൈബ്രറിയുടെ വലുപ്പം ഒന്നുതന്നെയാണ്. ഈ ലൈബ്രറി പാച്ച് ചെയ്ത് ബ്രൗസറിന് നൽകാൻ ഞങ്ങൾ ശ്രമിക്കുന്നു. ഞങ്ങളുടെ പാച്ച് ചെയ്‌ത ലൈബ്രറി ലോഡുചെയ്‌തുവെന്ന് കാണിക്കാൻ, “PWNED!” എന്ന വാചകം ഉപയോഗിച്ച് ഒരു SMS സൃഷ്‌ടിക്കാനുള്ള ഒരു ഉദ്ദേശ്യം ഞങ്ങൾ സമാരംഭിക്കും. സെർവറിൽ നിന്നുള്ള രണ്ട് പ്രതികരണങ്ങൾ ഞങ്ങൾ മാറ്റിസ്ഥാപിക്കും: puds.ucweb.com/upgrade/index.xhtml ആർക്കൈവ് ഡൗൺലോഡ് ചെയ്യാനും. ആദ്യത്തേതിൽ ഞങ്ങൾ MD5 മാറ്റിസ്ഥാപിക്കുന്നു (അൺപാക്ക് ചെയ്തതിന് ശേഷം വലുപ്പം മാറില്ല), രണ്ടാമത്തേതിൽ ഞങ്ങൾ പാച്ച് ചെയ്ത ലൈബ്രറി ഉപയോഗിച്ച് ആർക്കൈവ് നൽകുന്നു.

ബ്രൗസർ നിരവധി തവണ ആർക്കൈവ് ഡൗൺലോഡ് ചെയ്യാൻ ശ്രമിക്കുന്നു, അതിനുശേഷം അത് ഒരു പിശക് നൽകുന്നു. പ്രത്യക്ഷത്തിൽ എന്തെങ്കിലും
അവൻ ഇഷ്ടപ്പെടുന്നില്ല. ഈ മങ്ങിയ ഫോർമാറ്റ് വിശകലനം ചെയ്തതിന്റെ ഫലമായി, സെർവർ ആർക്കൈവിന്റെ വലുപ്പവും കൈമാറുന്നുവെന്ന് മനസ്സിലായി:

ഇത് LEB128-ൽ എൻകോഡ് ചെയ്തിരിക്കുന്നു. പാച്ചിന് ശേഷം, ലൈബ്രറിയുമായുള്ള ആർക്കൈവിന്റെ വലുപ്പം അല്പം മാറി, അതിനാൽ ആർക്കൈവ് വളച്ചൊടിച്ച് ഡൗൺലോഡ് ചെയ്തതായി ബ്രൗസർ കണക്കാക്കി, നിരവധി ശ്രമങ്ങൾക്ക് ശേഷം അത് ഒരു പിശക് എറിഞ്ഞു.

ഞങ്ങൾ ആർക്കൈവിന്റെ വലുപ്പം ക്രമീകരിക്കുന്നു ... ഒപ്പം - വിജയം! 🙂 ഫലം വീഡിയോയിൽ ഉണ്ട്.

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

അനന്തരഫലങ്ങളും ഡെവലപ്പർ പ്രതികരണവും

അതുപോലെ തന്നെ, ഹാക്കർമാർക്ക് യുസി ബ്രൗസറിന്റെ സുരക്ഷിതമല്ലാത്ത ഫീച്ചർ ഉപയോഗിച്ച് ക്ഷുദ്രകരമായ ലൈബ്രറികൾ വിതരണം ചെയ്യാനും പ്രവർത്തിപ്പിക്കാനും കഴിയും. ഈ ലൈബ്രറികൾ ബ്രൗസറിന്റെ പശ്ചാത്തലത്തിൽ പ്രവർത്തിക്കും, അതിനാൽ അവർക്ക് അതിന്റെ എല്ലാ സിസ്റ്റം അനുമതികളും ലഭിക്കും. തൽഫലമായി, ഫിഷിംഗ് വിൻഡോകൾ പ്രദർശിപ്പിക്കാനുള്ള കഴിവ്, കൂടാതെ ഡാറ്റാബേസിൽ സംഭരിച്ചിരിക്കുന്ന ലോഗിനുകൾ, പാസ്‌വേഡുകൾ, കുക്കികൾ എന്നിവയുൾപ്പെടെ ഓറഞ്ച് ചൈനീസ് സ്‌ക്വിറലിന്റെ പ്രവർത്തന ഫയലുകളിലേക്കുള്ള ആക്‌സസ്സ്.

ഞങ്ങൾ UC ബ്രൗസറിന്റെ ഡെവലപ്പർമാരെ ബന്ധപ്പെടുകയും ഞങ്ങൾ കണ്ടെത്തിയ പ്രശ്‌നത്തെക്കുറിച്ച് അവരെ അറിയിക്കുകയും അപകടസാധ്യതയും അതിന്റെ അപകടവും ചൂണ്ടിക്കാണിക്കാൻ ശ്രമിക്കുകയും ചെയ്തു, പക്ഷേ അവർ ഞങ്ങളോട് ഒന്നും ചർച്ച ചെയ്തില്ല. അതേസമയം, ബ്രൗസർ അതിന്റെ അപകടകരമായ സവിശേഷത വ്യക്തമായ കാഴ്ചയിൽ പ്രകടമാക്കുന്നത് തുടർന്നു. എന്നാൽ അപകടസാധ്യതയുടെ വിശദാംശങ്ങൾ ഞങ്ങൾ വെളിപ്പെടുത്തിക്കഴിഞ്ഞാൽ, മുമ്പത്തെപ്പോലെ അവഗണിക്കാൻ കഴിയില്ല. മാർച്ച് 27 ആയിരുന്നു
HTTPS വഴി സെർവറിലേക്ക് ആക്‌സസ് ചെയ്ത UC ബ്രൗസറിന്റെ ഒരു പുതിയ പതിപ്പ് 12.10.9.1193 പുറത്തിറങ്ങി: puds.ucweb.com/upgrade/index.xhtml.

കൂടാതെ, "പരിഹരിച്ചതിന്" ശേഷവും ഈ ലേഖനം എഴുതുന്ന സമയം വരെ, ഒരു ബ്രൗസറിൽ ഒരു PDF തുറക്കാൻ ശ്രമിച്ചത് "ശ്ശോ, എന്തോ കുഴപ്പം സംഭവിച്ചു!" എന്ന വാചകത്തിൽ ഒരു പിശക് സന്ദേശത്തിന് കാരണമായി. ഒരു PDF തുറക്കാൻ ശ്രമിക്കുമ്പോൾ സെർവറിലേക്ക് ഒരു അഭ്യർത്ഥന നടത്തിയില്ല, എന്നാൽ ബ്രൗസർ സമാരംഭിച്ചപ്പോൾ ഒരു അഭ്യർത്ഥന നടത്തി, ഇത് Google Play നിയമങ്ങൾ ലംഘിച്ച് എക്സിക്യൂട്ടബിൾ കോഡ് ഡൗൺലോഡ് ചെയ്യാനുള്ള തുടർച്ചയായ കഴിവിനെ സൂചിപ്പിക്കുന്നു.

അവലംബം: www.habr.com