UC ব্রাউজারে দুর্বলতা খুঁজছেন

ভূমিকা

মার্চের শেষে আমরা রিপোর্ট, যে তারা UC ব্রাউজারে অসমাপ্ত কোড লোড এবং চালানোর একটি লুকানো ক্ষমতা আবিষ্কার করেছে। আজ আমরা বিস্তারিতভাবে দেখব কিভাবে এই ডাউনলোড হয় এবং কিভাবে হ্যাকাররা তাদের নিজেদের উদ্দেশ্যে ব্যবহার করতে পারে।

কিছু সময় আগে, UC ব্রাউজারটির বিজ্ঞাপন দেওয়া হয়েছিল এবং খুব আক্রমনাত্মকভাবে বিতরণ করা হয়েছিল: এটি ম্যালওয়্যার ব্যবহার করে ব্যবহারকারীদের ডিভাইসে ইনস্টল করা হয়েছিল, ভিডিও ফাইলের আড়ালে বিভিন্ন সাইট থেকে বিতরণ করা হয়েছিল (অর্থাৎ, ব্যবহারকারীরা ভেবেছিল যে তারা ডাউনলোড করছে, উদাহরণস্বরূপ, একটি পর্ণ ভিডিও, কিন্তু পরিবর্তে এই ব্রাউজারটির সাথে একটি APK পেয়েছি), বার্তা সহ ভীতিকর ব্যানার ব্যবহার করেছে যে ব্রাউজারটি পুরানো, দুর্বল এবং এই জাতীয় জিনিস। ভিকেতে অফিসিয়াল ইউসি ব্রাউজার গ্রুপে রয়েছে বিষয়, যেখানে ব্যবহারকারীরা অন্যায় বিজ্ঞাপন সম্পর্কে অভিযোগ করতে পারেন, সেখানে অনেক উদাহরণ রয়েছে। 2016 সালে এমনকি ছিল ভিডিও বিজ্ঞাপন রাশিয়ান ভাষায় (হ্যাঁ, একটি বিজ্ঞাপন-ব্লকিং ব্রাউজারের জন্য বিজ্ঞাপন)।

লেখার সময়, ইউসি ব্রাউজারে গুগল প্লেতে 500 এর বেশি ইনস্টলেশন রয়েছে। এটি চিত্তাকর্ষক - শুধুমাত্র Google Chrome এর আরও আছে৷ পর্যালোচনাগুলির মধ্যে আপনি বিজ্ঞাপন এবং Google Play-তে কিছু অ্যাপ্লিকেশনে পুনঃনির্দেশ সম্পর্কে প্রচুর অভিযোগ দেখতে পারেন। এটি আমাদের গবেষণার কারণ ছিল: আমরা UC ব্রাউজার খারাপ কিছু করছে কিনা তা দেখার সিদ্ধান্ত নিয়েছি। আর দেখা গেল সে কি করে!

অ্যাপ্লিকেশন কোডে, এক্সিকিউটেবল কোড ডাউনলোড এবং চালানোর ক্ষমতা আবিষ্কৃত হয়েছিল, যা অ্যাপ্লিকেশন প্রকাশের নিয়মের পরিপন্থী Google Play-তে। এক্সিকিউটেবল কোড ডাউনলোড করার পাশাপাশি, ইউসি ব্রাউজার এটি একটি অনিরাপদ পদ্ধতিতে করে, যা একটি 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 ব্রাউজারের এই বৈশিষ্ট্যটি ব্যবহার করার সিদ্ধান্ত নিয়েছি: একটি নেটিভ লাইব্রেরি ব্যবহার করে পিডিএফ খোলার ক্ষমতা, যা APK-এ নেই এবং প্রয়োজনে এটি ইন্টারনেট থেকে ডাউনলোড করে। এটি লক্ষণীয় যে, তাত্ত্বিকভাবে, ইউসি ব্রাউজারকে ব্যবহারকারীর মিথস্ক্রিয়া ছাড়াই কিছু ডাউনলোড করতে বাধ্য করা যেতে পারে - যদি আপনি ব্রাউজার চালু হওয়ার পরে কার্যকর করা একটি অনুরোধের জন্য একটি সুগঠিত প্রতিক্রিয়া প্রদান করেন। কিন্তু এটি করার জন্য, আমাদের সার্ভারের সাথে ইন্টারঅ্যাকশনের প্রোটোকলটি আরও বিস্তারিতভাবে অধ্যয়ন করতে হবে, তাই আমরা সিদ্ধান্ত নিয়েছি যে বাধাপ্রাপ্ত প্রতিক্রিয়া সম্পাদনা করা এবং PDF এর সাথে কাজ করার জন্য লাইব্রেরি প্রতিস্থাপন করা সহজ হবে।

সুতরাং, যখন একজন ব্যবহারকারী সরাসরি ব্রাউজারে একটি পিডিএফ খুলতে চায়, তখন নিম্নলিখিত অনুরোধগুলি ট্র্যাফিকের মধ্যে দেখা যেতে পারে:

প্রথমে একটি POST অনুরোধ আছে 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, যা আসলে একটি .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 নম্বর সহ একটি নির্দিষ্ট রাউটারে স্থানান্তরিত হয় - এটি দৃশ্যত কমান্ড নম্বর।

ট্রানজিশনের পরবর্তী চেইনের পরে আমরা একটি ক্লাস খুঁজে পাই যা ইন্টারফেস প্রয়োগ করে আইআরউটার কম্পোনেন্ট এবং পদ্ধতি 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 ফাইল সঠিকভাবে লোড করতে এবং এটি বিশ্লেষণ করতে, একটি প্রোগ্রাম হেডার টেবিল যথেষ্ট। অতএব, হেডারে সংশ্লিষ্ট ক্ষেত্রগুলিকে শূন্য করে আমরা কেবল বিভাগ টেবিলটি মুছে ফেলি।

আইডিএ ফাইলটি আবার খুলুন।

জাভা ভার্চুয়াল মেশিনকে বলার দুটি উপায় রয়েছে যেটি নেটিভ লাইব্রেরিতে জাভা কোডে নেটিভ হিসাবে ঘোষিত একটি পদ্ধতির বাস্তবায়ন ঠিক কোথায় অবস্থিত। প্রথমে এটি একটি প্রজাতির নাম দিতে হয় Java_package_name_ClassName_MethodName.

দ্বিতীয়টি হল লাইব্রেরি লোড করার সময় এটি নিবন্ধন করা (ফাংশনে JNI_অনলোড)
একটি ফাংশন কল ব্যবহার করে রেজিস্টার নেটিভস.

আমাদের ক্ষেত্রে, যদি আমরা প্রথম পদ্ধতি ব্যবহার করি, নামটি এইরকম হওয়া উচিত: Java_com_taobao_wireless_security_adapter_JNICLibrary_doCommandNative.

রপ্তানিকৃত ফাংশনগুলির মধ্যে এমন কোনও ফাংশন নেই, যার মানে আপনাকে একটি কলের জন্য সন্ধান করতে হবে রেজিস্টার নেটিভস.
চলুন ফাংশনে যাই JNI_অনলোড এবং আমরা এই ছবিটি দেখি:

এখানে কি হচ্ছে? প্রথম নজরে, ফাংশনের শুরু এবং শেষ এআরএম আর্কিটেকচারের জন্য সাধারণ। স্ট্যাকের প্রথম নির্দেশনা রেজিস্টারের বিষয়বস্তু সঞ্চয় করে যা ফাংশন তার ক্রিয়াকলাপে ব্যবহার করবে (এই ক্ষেত্রে, R0, R1 এবং R2), সেইসাথে LR রেজিস্টারের বিষয়বস্তু, যাতে ফাংশন থেকে ফেরত ঠিকানা রয়েছে . শেষ নির্দেশনা সংরক্ষিত রেজিস্টারগুলিকে পুনরুদ্ধার করে, এবং ফেরত ঠিকানা অবিলম্বে পিসি রেজিস্টারে স্থাপন করা হয় - এইভাবে ফাংশন থেকে ফিরে আসে। কিন্তু আপনি যদি ঘনিষ্ঠভাবে তাকান, তাহলে আপনি লক্ষ্য করবেন যে শেষের নির্দেশটি স্ট্যাকে সংরক্ষিত রিটার্ন ঠিকানা পরিবর্তন করে। এর পর কেমন হবে তা হিসাব করা যাক
কোড এক্সিকিউশন। একটি নির্দিষ্ট ঠিকানা 1xB0 R130 এ লোড করা হয়, এটি থেকে 5 বিয়োগ করা হয়, তারপর এটি R0 এ স্থানান্তরিত হয় এবং এতে 0x10 যোগ করা হয়। এটা 0xB13B সক্রিয় আউট. এইভাবে, IDA মনে করে যে শেষ নির্দেশটি একটি স্বাভাবিক ফাংশন রিটার্ন, কিন্তু প্রকৃতপক্ষে এটি গণনা করা ঠিকানা 0xB13B এ যাচ্ছে।

এখানে স্মরণ করা উচিত যে ARM প্রসেসরের দুটি মোড এবং দুটি সেট নির্দেশাবলী রয়েছে: ARM এবং থাম্ব। ঠিকানার সর্বনিম্ন উল্লেখযোগ্য বিট প্রসেসরকে বলে যে কোন নির্দেশ সেটটি ব্যবহার করা হচ্ছে। অর্থাৎ, ঠিকানাটি আসলে 0xB13A, এবং অন্তত উল্লেখযোগ্য বিটের মধ্যে একটি থাম্ব মোড নির্দেশ করে।

এই লাইব্রেরিতে প্রতিটি ফাংশনের শুরুতে একটি অনুরূপ "অ্যাডাপ্টার" যোগ করা হয়েছে এবং
আবর্জনা কোড। আমরা বিস্তারিতভাবে তাদের উপর বাস করব না - আমরা শুধু মনে রাখি
যে প্রায় সব ফাংশনের আসল শুরুটা একটু দূরে।

যেহেতু কোডটি স্পষ্টভাবে 0xB13A-এ যায় না, তাই IDA নিজেই চিনতে পারেনি যে কোডটি এই অবস্থানে অবস্থিত। একই কারণে, এটি লাইব্রেরির বেশিরভাগ কোডকে কোড হিসাবে স্বীকৃতি দেয় না, যা বিশ্লেষণকে কিছুটা কঠিন করে তোলে। আমরা IDA কে বলি যে এটি কোড, এবং এটিই ঘটে:

টেবিলটি স্পষ্টভাবে 0xB144 এ শুরু হয়। sub_494C-তে কী আছে?

এলআর রেজিস্টারে এই ফাংশনটি কল করার সময়, আমরা পূর্বে উল্লেখিত টেবিলের ঠিকানা (0xB144) পাই। R0 এ - এই টেবিলে সূচক। অর্থাৎ, মানটি টেবিল থেকে নেওয়া হয়, এলআর-এ যোগ করা হয় এবং ফলাফল হয়
যে ঠিকানায় যেতে হবে। আসুন এটি গণনা করার চেষ্টা করি: 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 তে রূপান্তর দেখুন:

আইডিএ আবার এই এলাকাটিকে কোড হিসেবে স্বীকৃতি দেয়নি। আমরা তাকে সাহায্য করি এবং সেখানে আরেকটি নকশা দেখি:

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 নির্দেশের পরে একটি অফসেট আছে:

আমরা অফসেটটি এলআর থেকে ঠিকানায় নিয়ে যাই, এটি এলআর-এ যোগ করি এবং সেখানে যাই। 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, কিন্তু কোডের এই অংশটি বিশেষভাবে অস্পষ্ট, তাই ধারণাটি কোড প্যাচ করার জন্য উদ্ভূত হয় যাতে ডিক্রিপশন ফাংশনের সমস্ত প্যারামিটার একটি ফাইলে ডাম্প করা হয়।

তালি

অ্যাসেম্বলি ল্যাঙ্গুয়েজে ম্যানুয়ালি সমস্ত প্যাচ কোড না লেখার জন্য, আপনি অ্যান্ড্রয়েড স্টুডিও চালু করতে পারেন, সেখানে একটি ফাংশন লিখতে পারেন যা আমাদের ডিক্রিপশন ফাংশনের মতো একই ইনপুট প্যারামিটার গ্রহণ করে এবং একটি ফাইলে লিখে, তারপর কম্পাইলার যে কোডটি কপি-পেস্ট করবে উৎপন্ন

ইউসি ব্রাউজার টিমের আমাদের বন্ধুরাও কোড যোগ করার সুবিধার যত্ন নিয়েছে। আসুন আমরা মনে রাখি যে প্রতিটি ফাংশনের শুরুতে আমাদের আবর্জনা কোড থাকে যা সহজেই অন্য যেকোন দিয়ে প্রতিস্থাপন করা যায়। খুব সুবিধাজনক 🙂 যাইহোক, টার্গেট ফাংশনের শুরুতে কোডের জন্য পর্যাপ্ত জায়গা নেই যা একটি ফাইলে সমস্ত প্যারামিটার সংরক্ষণ করে। আমাকে এটিকে অংশে বিভক্ত করতে হয়েছিল এবং প্রতিবেশী ফাংশনগুলি থেকে আবর্জনা ব্লকগুলি ব্যবহার করতে হয়েছিল। মোট চারটি অংশ ছিল।

প্রথম অংশ:

এআরএম আর্কিটেকচারে, প্রথম চারটি ফাংশন প্যারামিটার রেজিস্টার R0-R3 এর মাধ্যমে পাস করা হয়, বাকিগুলি, যদি থাকে, স্ট্যাকের মাধ্যমে পাস করা হয়। এলআর রেজিস্টারে ফিরতি ঠিকানা থাকে। এই সমস্তগুলি সংরক্ষণ করা দরকার যাতে ফাংশনটি কাজ করতে পারে যখন আমরা এর পরামিতিগুলি ডাম্প করি। আমাদের সেই সমস্ত রেজিস্টার সংরক্ষণ করতে হবে যা আমরা প্রক্রিয়াটিতে ব্যবহার করব, তাই আমরা PUSH.W {R0-R10,LR} করি। R7 এ আমরা স্ট্যাকের মাধ্যমে ফাংশনে পাস করা প্যারামিটারের তালিকার ঠিকানা পাই।

ফাংশন ব্যবহার করে fopen ফাইলটি ওপেন করা যাক /data/local/tmp/aes "ab" মোডে
অর্থাৎ যোগ করার জন্য। R0 এ আমরা ফাইলের নামের ঠিকানাটি লোড করি, R1-এ - মোড নির্দেশ করে লাইনের ঠিকানা। এবং এখানে গারবেজ কোড শেষ হয়, তাই আমরা পরবর্তী ফাংশনে চলে যাই। এটি কাজ চালিয়ে যাওয়ার জন্য, আমরা শুরুতে আবর্জনাকে বাইপাস করে ফাংশনের আসল কোডে রূপান্তর করি এবং আবর্জনার পরিবর্তে আমরা প্যাচের ধারাবাহিকতা যুক্ত করি।

কলিং fopen.

ফাংশনের প্রথম তিনটি প্যারামিটার AES টাইপ আছে কোন int. যেহেতু আমরা শুরুতে রেজিস্টারগুলিকে স্ট্যাকে সংরক্ষণ করেছি, আমরা সহজভাবে ফাংশনটি পাস করতে পারি fwrite স্ট্যাকের উপর তাদের ঠিকানা.

এরপরে আমাদের কাছে তিনটি স্ট্রাকচার রয়েছে যেগুলিতে ডেটা সাইজ এবং কী, ইনিশিয়ালাইজেশন ভেক্টর এবং এনক্রিপ্ট করা ডেটার জন্য ডেটার একটি পয়েন্টার রয়েছে।

শেষে, ফাইলটি বন্ধ করুন, রেজিস্টারগুলি পুনরুদ্ধার করুন এবং বাস্তব ফাংশনে নিয়ন্ত্রণ স্থানান্তর করুন AES.

আমরা একটি প্যাচ করা লাইব্রেরি সহ একটি 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/” পাই, APK-এ সেই নামের একটি ফোল্ডার তৈরি করুন এবং সেখানে কাঠবিড়ালি ব্রাউজার সার্টিফিকেট যোগ করুন।

আমরা একত্রিত করি, স্বাক্ষর করি, ইনস্টল করি, লঞ্চ করি। বিঙ্গো ! আমাদের কাছে চাবি আছে!

MitM

আমরা কী এর সমান একটি কী এবং একটি ইনিশিয়ালাইজেশন ভেক্টর পেয়েছি। আসুন CBC মোডে সার্ভার প্রতিক্রিয়া ডিক্রিপ্ট করার চেষ্টা করি।

আমরা আর্কাইভ ইউআরএল দেখতে পাই, MD5 এর মতো কিছু, "extract_unzipsize" এবং একটি সংখ্যা। আমরা পরীক্ষা করি: সংরক্ষণাগারের MD5 একই, আনপ্যাক করা লাইব্রেরির আকার একই। আমরা এই লাইব্রেরিটি প্যাচ করে ব্রাউজারে দেওয়ার চেষ্টা করছি। আমাদের প্যাচ করা লাইব্রেরি লোড হয়েছে তা দেখানোর জন্য, আমরা "PWNED!" পাঠ্য সহ একটি এসএমএস তৈরি করার জন্য একটি অভিপ্রায় চালু করব। আমরা সার্ভার থেকে দুটি প্রতিক্রিয়া প্রতিস্থাপন করব: puds.ucweb.com/upgrade/index.xhtml এবং সংরক্ষণাগার ডাউনলোড করতে. প্রথমটিতে আমরা MD5 প্রতিস্থাপন করি (আনপ্যাক করার পরে আকার পরিবর্তন হয় না), দ্বিতীয়টিতে আমরা প্যাচ করা লাইব্রেরির সাথে সংরক্ষণাগারটি দিই।

ব্রাউজারটি বেশ কয়েকবার সংরক্ষণাগারটি ডাউনলোড করার চেষ্টা করে, তারপরে এটি একটি ত্রুটি দেয়। দৃশ্যত কিছু
সে পছন্দ করে না. এই অস্পষ্ট বিন্যাস বিশ্লেষণের ফলস্বরূপ, এটি প্রমাণিত হয়েছে যে সার্ভারটি সংরক্ষণাগারের আকারও প্রেরণ করে:

এটি LEB128 এ এনকোড করা হয়েছে। প্যাচের পরে, লাইব্রেরির সাথে সংরক্ষণাগারটির আকার কিছুটা পরিবর্তিত হয়েছে, তাই ব্রাউজারটি বিবেচনা করেছে যে সংরক্ষণাগারটি বাঁকাভাবে ডাউনলোড করা হয়েছে এবং বেশ কয়েকটি প্রচেষ্টার পরে এটি একটি ত্রুটি ছুড়ে দিয়েছে।

আমরা সংরক্ষণাগারের আকার সামঞ্জস্য করি... এবং - বিজয়! 🙂 ফলাফল ভিডিওতে আছে।

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

ফলাফল এবং বিকাশকারী প্রতিক্রিয়া

একইভাবে, হ্যাকাররা ক্ষতিকারক লাইব্রেরিগুলি বিতরণ এবং চালানোর জন্য UC ব্রাউজারের অনিরাপদ বৈশিষ্ট্য ব্যবহার করতে পারে। এই লাইব্রেরিগুলি ব্রাউজারের প্রসঙ্গে কাজ করবে, তাই তারা এর সমস্ত সিস্টেম অনুমতি পাবে৷ ফলস্বরূপ, ফিশিং উইন্ডো প্রদর্শন করার ক্ষমতা, সেইসাথে কমলা চাইনিজ কাঠবিড়ালির কাজের ফাইলগুলিতে অ্যাক্সেস, লগইন, পাসওয়ার্ড এবং ডাটাবেসে সংরক্ষিত কুকি সহ।

আমরা UC Browser এর ডেভেলপারদের সাথে যোগাযোগ করেছিলাম এবং আমরা যে সমস্যাটি পেয়েছি সে সম্পর্কে তাদের অবহিত করেছি, দুর্বলতা এবং এর বিপদ নির্দেশ করার চেষ্টা করেছি, কিন্তু তারা আমাদের সাথে কিছু আলোচনা করেনি। ইতিমধ্যে, ব্রাউজারটি তার বিপজ্জনক বৈশিষ্ট্যটি সরল দৃষ্টিতে প্রকাশ করতে থাকে। কিন্তু একবার আমরা দুর্বলতার বিবরণ প্রকাশ করলে, এটি আর আগের মতো উপেক্ষা করা সম্ভব ছিল না। ২৭ মার্চ ছিল
UC ব্রাউজার 12.10.9.1193 এর একটি নতুন সংস্করণ প্রকাশিত হয়েছে, যা HTTPS এর মাধ্যমে সার্ভারে প্রবেশ করেছে: puds.ucweb.com/upgrade/index.xhtml.

এছাড়াও, "ফিক্স" করার পরে এবং এই নিবন্ধটি লেখার সময় পর্যন্ত, একটি ব্রাউজারে একটি পিডিএফ খোলার চেষ্টা করার ফলে "ওহো, কিছু ভুল হয়েছে!" পাঠ্য সহ একটি ত্রুটি বার্তা এসেছে। একটি পিডিএফ খোলার চেষ্টা করার সময় সার্ভারের কাছে একটি অনুরোধ করা হয়নি, তবে ব্রাউজারটি চালু করার সময় একটি অনুরোধ করা হয়েছিল, যা Google Play নিয়ম লঙ্ঘন করে এক্সিকিউটেবল কোড ডাউনলোড করার অব্যাহত ক্ষমতার ইঙ্গিত দেয়।

উত্স: www.habr.com