网易大神2022最新版本分析（1）

最新推荐文章于 2024-09-30 15:37:45 发布
最新推荐文章于 2024-09-30 15:37:45 发布
阅读量1.7k 收藏 4
点赞数 1
文章标签： android java android studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38145863/article/details/126862314
版权

文章目录

前言

学习网易大神dex 加固方式，更好容易掌握最新技术，攻防对抗，只是为了更好得学习成长，了解自己得不足！一切学习都是为了进步！

一、网易大神得源码在哪里？

使用jadx-gui反编译apk
在这里插入图片描述
发现没有办法完全反编译出Java代码，压根反编译不全，挺ok得，我们不放弃继续换方法，于是我们用jeb 进行反编译。
在这里插入图片描述

我们查找ProxyApplication这个类
在这里插入图片描述

二、分析java层源码

1.java层ProxyApplication类全部代码

代码如下（示例）：

​
package com.netease.dexshell;

import android.app.Application;
import android.content.Context;
import android.content.SharedPreferences$Editor;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager$NameNotFoundException;
import android.os.Build$VERSION;
import android.text.TextUtils;
import android.util.Log;
import dalvik.system.BaseDexClassLoader;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Locale;
import java.util.concurrent.TimeUnit;

public class ProxyApplication extends Application {
    public static String I00I067;
    public static String II0OO0II0O;
    public boolean IOO00OOI0;
    public static Application delegate;
    public static Application proxy;

    public ProxyApplication() {
        super();
        this.IOO00OOI0 = false;
    }

    private void I0O00OIIoO(Context arg6, String arg7) {
        try {
            if(Build$VERSION.SDK_INT < 29) {
                if(Build$VERSION.SDK_INT <= 19) {
                }
                else {
                    if(this.getSharedPreferences("shell-config", 4).getBoolean("opt-finish", false)) {
                    }
                    else if(Utils.IOII0OO0I(arg6)) {
                        new Thread(new Runnable(arg6, arg7) {
                            public void run() {
                                try {
                                    if(Build$VERSION.SDK_INT >= 26) {
                                        TimeUnit.SECONDS.sleep(50);
                                        goto label_15;
                                    }

                                    TimeUnit.SECONDS.sleep(55);
                                }
                                catch(InterruptedException v0) {
                                    Log.e("InterruptedException %s", v0.getMessage());
                                }

                            label_15:
                                String v0_1 = Utils.II0OO0I0(this.val$context);
                                if(ProxyApplication.IOO0OO0IIo(this.val$context, new ArrayList(Arrays.asList(Utils.II0O0IIO(this.val$dir, "enc_opt"))), String.format(Locale.CHINA, "%s/oat/%s", new Object[]{this.val$dir.replace("/user/0", "/data"), v0_1}), v0_1) == 0) {
                                    SharedPreferences$Editor v0_2 = ProxyApplication.this.getSharedPreferences("shell-config", 4).edit();
                                    v0_2.putBoolean("opt-finish", true);
                                    v0_2.apply();
                                }
                            }
                        }).start();
                    }
                    else {
                    }

                    return;
                }
            }

            return;
        }
        catch(Exception ) {
            double v6 = ((double)6);
            double v0 = ((double)25);
            if(v6 >= Math.sqrt(v0)) {
                return;
            }

            while(true) {
                if(v6 >= Math.sqrt(v0)) {
                    return;
                }

                try {
                    new Throwable().getCause();
                    continue;
                }
                catch(Throwable v6_1) {
                    break;
                }
                catch(NullPointerException ) {
                    continue;
                }
            }

            throw v6_1;
        }
    }

    private void I0O0I0OOo0(String arg8, Context arg9) {
        try {
            int v3 = 2;
            if(arg8.contains("x86")) {
                Utils.II0OIIO0(arg9, "netease_hook_x86", String.format("%s/.jiagu/%s/netease_hook_x86.so", arg9.getFilesDir().getAbsolutePath(), ProxyApplication.I00I067));
                StringBuilder v0 = new StringBuilder("netease_ssl");
                if(arg8.contains("64")) {
                    v0.append("_x64");
                }

                arg8 = v0.toString();
                System.load(Utils.II0OIIO0(arg9, arg8, String.format("%s/.jiagu/%s/netease_ssl.so", arg9.getFilesDir().getAbsolutePath(), ProxyApplication.I00I067)));
                return;
            }

            Utils.II0OIIO0(arg9, "netease_hook_arm", String.format("%s/.jiagu/%s/netease_hook_arm.so", arg9.getFilesDir().getAbsolutePath(), ProxyApplication.I00I067));
            System.loadLibrary("netease_ssl");
        }
        catch(Exception ) {
            double v8 = ((double)6);
            double v0_1 = ((double)25);
            if(v8 >= Math.sqrt(v0_1)) {
                return;
            }

            while(true) {
                if(v8 >= Math.sqrt(v0_1)) {
                    return;
                }

                try {
                    new Throwable().getCause();
                    continue;
                }
                catch(NullPointerException ) {
                    continue;
                }
                catch(Throwable v8_1) {
                    break;
                }
            }

            throw v8_1;
        }
    }

    public static native void IO00OI0o0(Context arg0, String arg1) {
    }

    public static native int IOO0OO0IIo(Context arg0, ArrayList arg1, String arg2, String arg3) {
    }

    protected void attachBaseContext(Context arg7) {
        super.attachBaseContext(arg7);
        try {
            ApplicationInfo v0_1 = this.getPackageManager().getApplicationInfo(this.getPackageName(), 128);
            ProxyApplication.II0OO0II0O = v0_1.metaData.getString("II0OI00IO");
            ProxyApplication.I00I067 = v0_1.metaData.getString("IOO0IIO0");
        }
        catch(PackageManager$NameNotFoundException v0) {
            v0.printStackTrace();
            ProxyApplication.I00I067 = "default";
        }

        try {
            this.I0O0I0OOo0(Utils.II0OO0I0(arg7), arg7);
            String v0_2 = String.format(Locale.CHINA, "%s/net_opt/%s/enc", this.getFilesDir(), ProxyApplication.I00I067);
            ProxyApplication.IO00OI0o0(arg7, v0_2);
            this.I0O00OIIoO(arg7, v0_2);
        }
        catch(Exception v7) {
            v7.printStackTrace();
            double v0_3 = ((double)6);
            double v2 = ((double)25);
            if(v0_3 >= Math.sqrt(v2)) {
                return;
            }

            while(true) {
                if(v0_3 >= Math.sqrt(v2)) {
                    return;
                }

                try {
                    new Throwable().getCause();
                    continue;
                }
                catch(Throwable v7_1) {
                    break;
                }
                catch(NullPointerException ) {
                    continue;
                }
            }

            throw v7_1;
        }
    }

    public native Context createPackageContext(String arg1, int arg2) throws PackageManager$NameNotFoundException {
    }

    public String getPackageName() {
        try {
            if(this.IOO00OOI0) {
                goto label_29;
            }

            try {
                Field v0_3 = Class.forName("android.app.ContextImpl").getDeclaredField("mMainThread");
                boolean v1 = true;
                v0_3.setAccessible(true);
                Object v0_4 = v0_3.get(this.getBaseContext());
                Field v2 = Class.forName("android.app.ActivityThread").getDeclaredField("mInitialApplication");
                v2.setAccessible(true);
                if(v2.get(v0_4) != null) {
                }
                else {
                    v1 = false;
                }

                this.IOO00OOI0 = v1;
                goto label_29;
            }
            catch(NoSuchFieldException v0) {
                try {
                    v0.printStackTrace();
                label_29:
                    if(!this.IOO00OOI0) {
                        goto label_52;
                    }

                    if(ProxyApplication.delegate != null) {
                        goto label_52;
                    }

                    if(TextUtils.isEmpty(ProxyApplication.II0OO0II0O)) {
                        goto label_52;
                    }

                    return "";
                }
                catch(Exception ) {
                label_38:
                    double v0_5 = ((double)6);
                    double v2_1 = ((double)25);
                    if(v0_5 >= Math.sqrt(v2_1)) {
                        goto label_52;
                    }

                    while(true) {
                        if(v0_5 >= Math.sqrt(v2_1)) {
                            goto label_52;
                        }

                        try {
                            new Throwable().getCause();
                            continue;
                        }
                        catch(Throwable v0_6) {
                            break;
                        }
                        catch(NullPointerException ) {
                            continue;
                        }
                    }

                    throw v0_6;
                }
            }
            catch(ClassNotFoundException v0_1) {
            }
            catch(IllegalAccessException v0_2) {
                try {
                    v0_2.printStackTrace();
                    goto label_29;
                    v0_1.printStackTrace();
                    goto label_29;
                }
                catch(Exception ) {
                    goto label_38;
                }
            }
        }
        catch(Exception ) {
            goto label_38;
        }

    label_52:
        return super.getPackageName();
    }

    public static Enumeration n11() {
        Enumeration v0 = null;
        try {
            Field v1_1 = BaseDexClassLoader.class.getDeclaredField("pathList");
            v1_1.setAccessible(true);
            Object v1_2 = v1_1.get(ProxyApplication.delegate.getClassLoader());
            Field v3 = v1_2.getClass().getDeclaredField("dexElements");
            v3.setAccessible(true);
            v1_2 = v3.get(v1_2);
            int v3_1 = v1_2.length;
            Object v6 = v0;
            Object v7 = v6;
            int v5;
            for(v5 = 0; v5 < v3_1; ++v5) {
                Object v8 = v1_2[v5];
                Field v9 = v8.getClass().getDeclaredField("dexFile");
                v9.setAccessible(true);
                v8 = v9.get(v8);
                if(v8 == null) {
                }
                else {
                    Method v9_1 = v8.getClass().getDeclaredMethod("entries");
                    v9_1.setAccessible(true);
                    if(v6 != null) {
                        v8 = v9_1.invoke(v8);
                        v9 = v8.getClass().getDeclaredField("mNameList");
                        v9.setAccessible(true);
                        v8 = v9.get(v8);
                        Object v9_2 = Array.newInstance(v8.getClass().getComponentType(), v8.length + v7.length);
                        System.arraycopy(v7, 0, v9_2, 0, v7.length);
                        System.arraycopy(v8, 0, v9_2, v7.length, v8.length);
                        v7 = v9_2;
                    }
                    else {
                        v6 = v9_1.invoke(v8);
                        Field v7_1 = v6.getClass().getDeclaredField("mNameList");
                        v7_1.setAccessible(true);
                        v7 = v7_1.get(v6);
                    }
                }
            }

            if(v6 != null && v7 != null) {
                v1_1 = v6.getClass().getDeclaredField("mNameList");
                v1_1.setAccessible(true);
                v1_1.set(v6, v7);
            }

            return ((Enumeration)v6);
        }
        catch(Exception v1) {
            v1.printStackTrace();
            double v1_3 = ((double)6);
            double v3_2 = ((double)25);
            if(v1_3 < Math.sqrt(v3_2)) {
                while(true) {
                    if(v1_3 < Math.sqrt(v3_2)) {
                        try {
                            new Throwable().getCause();
                            continue;
                        }
                        catch(Throwable v0_1) {
                            break;
                        }
                        catch(NullPointerException ) {
                            continue;
                        }
                    }

                    return v0;
                }

                throw v0_1;
            }

            return v0;
        }
    }

    public native void onCreate() {
    }
}


​

2.第一部分代码分析

dex 有做过加固处理。我们仔细分析下面代码

代码如下（示例）：

 private void I0O0I0OOo0(String arg8, Context arg9) {
        try {
            int v3 = 2;
            if(arg8.contains("x86")) {
                Utils.II0OIIO0(arg9, "netease_hook_x86", String.format("%s/.jiagu/%s/netease_hook_x86.so", arg9.getFilesDir().getAbsolutePath(), ProxyApplication.I00I067));
                StringBuilder v0 = new StringBuilder("netease_ssl");
                if(arg8.contains("64")) {
                    v0.append("_x64");
                }

                arg8 = v0.toString();
                System.load(Utils.II0OIIO0(arg9, arg8, String.format("%s/.jiagu/%s/netease_ssl.so", arg9.getFilesDir().getAbsolutePath(), ProxyApplication.I00I067)));
                return;
            }

            Utils.II0OIIO0(arg9, "netease_hook_arm", String.format("%s/.jiagu/%s/netease_hook_arm.so", arg9.getFilesDir().getAbsolutePath(), ProxyApplication.I00I067));
            System.loadLibrary("netease_ssl");
        }
        catch(Exception ) {
            double v8 = ((double)6);
            double v0_1 = ((double)25);
            if(v8 >= Math.sqrt(v0_1)) {
                return;
            }

            while(true) {
                if(v8 >= Math.sqrt(v0_1)) {
                    return;
                }

                try {
                    new Throwable().getCause();
                    continue;
                }
                catch(NullPointerException ) {
                    continue;
                }
                catch(Throwable v8_1) {
                    break;
                }
            }

            throw v8_1;
        }
    }

该代码 System.loadLibrary进行加载了so 文件，我们得dex就在so里面处理过了，需要解密。要想了解如何解析出dex，关注催更

总结

dex不能正确解析出代码，我们使用jeb 反编译得到了正确得代码

埋谷与麦谷
关注
ProxyApplication:ProxyDelegate 应用程序
06-19
代理应用程序 代理/委托申请
网易滑块协议分析(二)
风中的承诺
01-11 1797
这篇文章主要分析网易的滑块轨迹算法。也就是data是怎么生成的 我们全局搜索data，出现的地方很太多。我这里是直接搜m:"" 其中只涉及到3个js文件.这里我们优先选择带版本号的js文件，可以看到这个版本号跟验证滑块接口中的版本号是一致的。 点进去直接继续搜索 整个js中就只有这一处。我们直接断点打在data身上。其中的d是滑块轨迹，p和ext分别是两个加密参数。 这里先分析d的值。 p函...
Android Apk加固（安全专项）
ShareUs的专栏
03-25 1500
Android中的Apk的加固(加壳)原理解析和实现：http://blog.csdn.net/jiangwei0910410003/article/details/48415225 Android安全专项-Apk加固：http://blog.csdn.net/itfootball/article/details/50962459 Android APK加壳技术方案【1】 ：http://bl
android逆向 网易,Android逆向——网易云音乐排行榜api(上)
weixin_35851515的博客
06-02 935
1. 抓包分析抓包可见，发送报文的body都是params=xxxxxxx这种格式的，于是可以判断params是个逆向的关键字2. JEB反编译原包，Java层静态分析反编译之后发现，几乎所有的字符串都被加密了但是，是通过了a.auu.a.c这个方法进行了解密操作，跟进去获得解密流程，先用base64解码字符串，然后遍历字符串与关键字进行异或用python写之，同时逆向能获取加密方式，from b...
网易大神app ios和android,网易大神app是干嘛的？网易大神有什么用？
weixin_30490729的博客
05-28 3502
网易大神app是网易最近刚推出的一个玩家社区软件，让小伙伴在这个软件中交流的一个软件，很多小伙伴不是很清楚的这个软件是干嘛的。今天小编就为大家详细的介绍下这个软件的具体情况！网易大神是什么？「网易大神」是网易游戏旗下的游戏玩家社区App，是一个网易游戏热爱者兴趣分享及好友互动的社交软件，支持iOS和Android平台。功能介绍网易大神——玩家首选游戏资讯、社交分享平台。网聚网易游戏玩家，云集游戏大...
openwrt高大全版本，esir大神汇编
05-17
openwrt高大全版本，esir大神汇编
酷派大神F1 8297 线刷经验总结
04-10
酷派大神F1的线刷包通常可以从官方网站获取，确保下载的是最新且适用于你设备的版本。同时，你需要准备相应的刷机工具和完整的文档，以便遵循正确的流程。 线刷环境的建立至关重要。在本例中，作者使用了Windows XP...
Y470/570 最新BIOS 外国大神制作
01-26
标题中的“Y470/570 最新BIOS 外国大神制作”指的是这款BIOS是由一位技术高手或社区成员为联想Y470和Y570笔记本电脑特别制作的最新版本。这种非官方的BIOS更新通常由爱好者或开发者提供，旨在增强或改进原厂BIOS的...
俄罗斯大神系统集合
03-12
### 1. Lopatkin简介 Lopatkin是一位来自俄罗斯的操作系统精简专家，以其精湛的技术和对Windows操作系统的深度优化闻名于世。他的工作主要是对微软官方发行的Windows版本进行精简和优化，去除不必要的组件和服务，...
esir大神编译的openwrt版本 以支持docker 科学
04-28
openwrt
如何改变Android应用的运行环境
hugh282003的专栏
01-28 1166
原文地址：http://blogs.360.cn/blog/proxydelegate-application/ 有的时候，为了实现一些特殊需求，如界面换肤、插件化等，我们希望改变应用的运行环境(surrounding)。例如，我们希望某个应用在运行时，所有Class（包括自定义Application，下面假设它叫MyApplication）都被一个自定义的ClassLoader加载。
bug积累： hadoop集群没有权限查看监控日志/proxy/application_1594195336447_10322228/User is unauthorized to
wangwangstone的博客
08-24 598
在cpu集群上跑了tensorflow代码，想去查看报错的具体信息。 对于 服务器集群报错，需要去查看日志，代码跑的logs日志，看里面的错误。里面会有个带着hadoop application的监控地址，http://yz70210.hadoop.data.sina.com.cn:9008/proxy/application_1594195336447_10322228/?ticket=ST-964608-dtQ38mpqrOPB0SozK9Un&ext= ，复制到浏览器中，如果提示没有权限，.
ApplicationProxy 代理类
u012482178的专栏
12-20 1372
使用方式： ApplicationProxy.getInstance().getApplication()； ApplicationProxy.getInstance().getApplicationContext()； 需要要在 public class BaseApplication extends Application{ ApplicationProxy.getIns...
Android源码之DeskClock (三) Proxy/Delegate Application 框架应用
热门推荐
Jesse的专栏
07-20 1万+
1.概述 当项目有加壳子的需求的时候,可以使用Proxy/Delegate Application框架的方式,在正常的模式中,一个程序一般只有一个Application入口,而Proxy/Delegate模式中需要有两个Application,原程序的Application改为Delegate Application,再新加一个Proxy Application
【Android 14源码分析】WMS-窗口显示-流程概览与应用端流程分析
最新发布
隔壁小王的博客
09-30 924
WMS 负责管理设备上所有的 Window ，所以应用想显示一个 Window 则要通过 WMS 来完成。而 WMS 毕竟还是上层，窗口的内容要显示到屏幕上，还需要 SurfaceFlinger 来处理。应用端: 控制其内部的窗口的添加及 UI 绘制逻辑WMS 模块: 作为系统窗口管理模块，处理应用端的窗口显示逻辑应用端与 WMS 通信通过匿名 Binder -> Session 完成。
【AndroidStudio】关于AndroidStudio的常见控件TextView和Button
PleaSure乐事的博客
09-26 443
AndroidStudio中TextView和Button控件的使用
Android build子系统（01）Ninja构建系统解读
wangdsh的博客
09-29 1027
说明：本文将解读Ninja构建系统，这是当前Android Framework中广泛使用的构建工具。我们将从Ninja的起源和背景信息开始，逐步解读Ninja的优势和核心原理，并探讨其一般使用场景。然后介绍其在Android Framework中的应用及相关工具：kati、soong、gn等，最后介绍下如何自行构建一个Ninja编译系统，以便于对Ninja有一个完整的了解。
PHP反序列化2（OC绕过.wakeup绕过）
2302_81328699的博客
09-26 588
PHP反序列化2（OC绕过.wakeup绕过）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

埋谷与麦谷

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值