Android 解析so文件

最新推荐文章于 2024-09-29 20:34:34 发布
最新推荐文章于 2024-09-29 20:34:34 发布
阅读量1k 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mazaiting/article/details/85002520
版权
1). so文件结构
3110861-ea7c82e78bec17f3.png
so文件结构.png
2). elf文件的数据结构类
public class ElfType32 {
    
    public elf32_rel rel;
    public elf32_rela rela;
    /**头部信息*/
    public elf32_hdr hdr;
    public List<elf32_sym> symList = new ArrayList<>();
    /**可能会有多个程序头*/
    public List<elf32_phdr> phdrList = new ArrayList<>();
    /**可能会有多个段头*/
    public List<elf32_shdr> shdrList = new ArrayList<>();
    /**可能会有多个字符串值*/
    public List<elf32_strtb> strtbList = new ArrayList<>();
    
    /**
     * typedef struct elf32_rel {
          Elf32_Addr    r_offset;
          Elf32_Word    r_info;
        } Elf32_Rel;
     */
    public class elf32_rel {
        public byte[] r_offset = new byte[4];
        public byte[] r_info = new byte[4];
        @Override
        public String toString(){
            return "r_offset: " + Util.bytesToHexString(r_offset) + ";r_info: " + Util.bytesToHexString(r_info);
        }
    }
    
    /**
     * typedef struct elf32_rela{
          Elf32_Addr    r_offset;
          Elf32_Word    r_info;
          Elf32_Sword   r_addend;
        } Elf32_Rela;
     */
    public class elf32_rela {
        public byte[] r_offset = new byte[4];
        public byte[] r_info = new byte[4];
        public byte[] r_addend = new byte[4];
        @Override
        public String toString(){
            return "r_offset: " + Util.bytesToHexString(r_offset) + ";r_info: " + Util.bytesToHexString(r_info)
            + ";r_addend: " + Util.bytesToHexString(r_info);
        }
    }
    
    /**
     * typedef struct elf32_sym{
          Elf32_Word    st_name;
          Elf32_Addr    st_value;
          Elf32_Word    st_size;
          unsigned char st_info;
          unsigned char st_other;
          Elf32_Half    st_shndx;
        } Elf32_Sym;
     */
    public static class elf32_sym {
        public byte[] st_name = new byte[4];
        public byte[] st_value = new byte[4];
        public byte[] st_size = new byte[4];
        public byte st_info;
        public byte st_other;
        public byte[] st_shndx = new byte[2];
        @Override
        public String toString(){
            return "st_name: " + Util.bytesToHexString(st_name) + "\nst_value: " + Util.bytesToHexString(st_value)
                    + "\nst_size: " + Util.bytesToHexString(st_size) + "\nst_info: " + (st_info/16)
                    + "\nst_other: " + (((short)st_other) & 0xF) + "\nst_shndx: " + Util.bytesToHexString(st_shndx);
        }
    }
    
    public void printSymList(){
        for(int i=0;i<symList.size();i++){
            System.out.println();
            System.out.println("The "+(i+1)+" Symbol Table:");
            System.out.println(symList.get(i).toString());
        }
    }
    
    // Bind字段--st_info
    public static final int STB_LOCAL = 0;
    public static final int STB_GLOBAL = 1;
    public static final int STB_WEAK = 2;
    // Type字段--st_other
    public static final int STB_NOTYPE = 0;
    public static final int STB_OBJECT = 1;
    public static final int STB_FUNC = 2;
    public static final int STB_SECTION = 3;
    public static final int STB_FILE = 4;
    /**
     * 这里需要注意的是还需要做一次转化
     *  #define ELF_ST_BIND(x)  ((x) >> 4)
     *  #define ELF_ST_TYPE(x)  (((unsigned int) x) & 0xf)
     */
    
    /**
     * typedef struct elf32_hdr{
          unsigned char e_ident[EI_NIDENT];
          Elf32_Half    e_type;
          Elf32_Half    e_machine;
          Elf32_Word    e_version;
          Elf32_Addr    e_entry;  // Entry point
          Elf32_Off e_phoff;
          Elf32_Off e_shoff;
          Elf32_Word    e_flags;
          Elf32_Half    e_ehsize;
          Elf32_Half    e_phentsize;
          Elf32_Half    e_phnum;
          Elf32_Half    e_shentsize;
          Elf32_Half    e_shnum;
          Elf32_Half    e_shstrndx;
        } Elf32_Ehdr;
     */
    public static class elf32_hdr {
        public byte[] e_ident = new byte[16];
        public byte[] e_type = new byte[2];
        public byte[] e_machine = new byte[2];
        public byte[] e_version = new byte[4];
        public byte[] e_entry = new byte[4];
        public byte[] e_phoff = new byte[4];
        public byte[] e_shoff = new byte[4];
        public byte[] e_flags = new byte[4];
        public byte[] e_ehsize = new byte[2];
        public byte[] e_phentsize = new byte[2];
        public byte[] e_phnum = new byte[2];
        public byte[] e_shentsize = new byte[2];
        public byte[] e_shnum = new byte[2];
        public byte[] e_shstrndx = new byte[2];
        @Override
        public String toString(){
            return  "magic: "+ Util.bytesToHexString(e_ident) + "\ne_type: "+ Util.bytesToHexString(e_type)
                    + "\ne_machine: " + Util.bytesToHexString(e_machine) + "\ne_version: "+ Util.bytesToHexString(e_version) 
                    + "\ne_entry: " + Util.bytesToHexString(e_entry) + "\ne_phoff: " + Util.bytesToHexString(e_phoff)
                    + "\ne_shoff: " + Util.bytesToHexString(e_shoff) + "\ne_flags: " + Util.bytesToHexString(e_flags)
                    + "\ne_ehsize: " + Util.bytesToHexString(e_ehsize) + "\ne_phentsize: " + Util.bytesToHexString(e_phentsize)
                    + "\ne_phnum: " + Util.bytesToHexString(e_phnum) + "\ne_shentsize: " + Util.bytesToHexString(e_shentsize)
                    + "\ne_shnum: " + Util.bytesToHexString(e_shnum) + "\ne_shstrndx: " + Util.bytesToHexString(e_shstrndx);
        }       
    }
    
    /**
     * typedef struct elf32_phdr{
          Elf32_Word    p_type;
          Elf32_Off p_offset;
          Elf32_Addr    p_vaddr;
          Elf32_Addr    p_paddr;
          Elf32_Word    p_filesz;
          Elf32_Word    p_memsz;
          Elf32_Word    p_flags;
          Elf32_Word    p_align;
        } Elf32_Phdr;
     */
    public static class elf32_phdr {
        public byte[] p_type = new byte[4];
        public byte[] p_offset = new byte[4];
        public byte[] p_vaddr = new byte[4];
        public byte[] p_paddr = new byte[4];
        public byte[] p_filesz = new byte[4];
        public byte[] p_memsz = new byte[4];
        public byte[] p_flags = new byte[4];
        public byte[] p_align = new byte[4];
        @Override
        public String toString(){
            return "p_type: " + Util.bytesToHexString(p_type) + "\np_offset: " + Util.bytesToHexString(p_offset)
                    + "\np_vaddr: " + Util.bytesToHexString(p_vaddr) + "\np_paddr: " + Util.bytesToHexString(p_paddr)
                    + "\np_filesz: " + Util.bytesToHexString(p_filesz) + "\np_memsz: " + Util.bytesToHexString(p_memsz)
                    + "\np_flags: " + Util.bytesToHexString(p_flags) + "\np_align: " + Util.bytesToHexString(p_align);
        }

    }
    
    public void printPhdrList(){
        for(int i=0;i<phdrList.size();i++){
            System.out.println();
            System.out.println("The "+(i+1)+" Program Header:");
            System.out.println(phdrList.get(i).toString());
        }
    }

    /**
     * typedef struct elf32_shdr {
          Elf32_Word    sh_name;
          Elf32_Word    sh_type;
          Elf32_Word    sh_flags;
          Elf32_Addr    sh_addr;
          Elf32_Off sh_offset;
          Elf32_Word    sh_size;
          Elf32_Word    sh_link;
          Elf32_Word    sh_info;
          Elf32_Word    sh_addralign;
          Elf32_Word    sh_entsize;
        } Elf32_Shdr;
     */
    public static class elf32_shdr {
        public byte[] sh_name = new byte[4];
        public byte[] sh_type = new byte[4];
        public byte[] sh_flags = new byte[4];
        public byte[] sh_addr = new byte[4];
        public byte[] sh_offset = new byte[4];
        public byte[] sh_size = new byte[4];
        public byte[] sh_link = new byte[4];
        public byte[] sh_info = new byte[4];
        public byte[] sh_addralign = new byte[4];
        public byte[] sh_entsize = new byte[4];
        @Override
        public String toString(){
            return "sh_name: " + Util.bytesToHexString(sh_name) + "\nsh_type: " + Util.bytesToHexString(sh_type)
                    + "\nsh_flags: " + Util.bytesToHexString(sh_flags) + "\nsh_add: " + Util.bytesToHexString(sh_addr)
                    + "\nsh_offset: " + Util.bytesToHexString(sh_offset) + "\nsh_size: " + Util.bytesToHexString(sh_size)
                    + "\nsh_link: " + Util.bytesToHexString(sh_link) + "\nsh_info: " + Util.bytesToHexString(sh_info)
                    + "\nsh_addralign: " + Util.bytesToHexString(sh_addralign) + "\nsh_entsize: " + Util.bytesToHexString(sh_entsize);
        }

    }
    
    /****************sh_type********************/
    public static final int SHT_NULL = 0;
    public static final int SHT_PROGBITS = 1;
    public static final int SHT_SYMTAB = 2;
    public static final int SHT_STRTAB = 3;
    public static final int SHT_RELA = 4;
    public static final int SHT_HASH = 5;
    public static final int SHT_DYNAMIC = 6;
    public static final int SHT_NOTE = 7;
    public static final int SHT_NOBITS = 8;
    public static final int SHT_REL = 9;
    public static final int SHT_SHLIB = 10;
    public static final int SHT_DYNSYM = 11;
    public static final int SHT_NUM = 12;
    public static final int SHT_LOPROC = 0x70000000;
    public static final int SHT_HIPROC = 0x7fffffff;
    public static final int SHT_LOUSER = 0x80000000;
    public static final int SHT_HIUSER = 0xffffffff;
    public static final int SHT_MIPS_LIST = 0x70000000;
    public static final int SHT_MIPS_CONFLICT = 0x70000002;
    public static final int SHT_MIPS_GPTAB = 0x70000003;
    public static final int SHT_MIPS_UCODE = 0x70000004;
    
    /*****************sh_flag***********************/
    public static final int SHF_WRITE = 0x1;
    public static final int SHF_ALLOC = 0x2;
    public static final int SHF_EXECINSTR = 0x4;
    public static final int SHF_MASKPROC = 0xf0000000;
    public static final int SHF_MIPS_GPREL = 0x10000000;
    
    public void printShdrList(){
        for(int i=0;i<shdrList.size();i++){
            System.out.println();
            System.out.println("The "+(i+1)+" Section Header:");
            System.out.println(shdrList.get(i));
        }
    }

    public static class elf32_strtb{
        public byte[] str_name;
        public int len;
        
        @Override
        public String toString(){
            return "str_name:"+str_name
                    +"len:"+len;
        }
    }   
}
3). 解析
public class ParseMain {
    public final static String FILE_PATH = "so/libhello-jni.so";
    public static void main(String[] args) {
        // 读取二进制数据
        byte[] soBytes = getBytesFromFile(FILE_PATH);
        
        System.out.println("parse elf header ... ");
        ParseSoUtil.parseHeader(soBytes);
        System.out.println("======================================");
        
        System.out.println("parse program header ... ");
        ParseSoUtil.parseProgramHeaderList(soBytes);
        System.out.println("======================================");
        
        System.out.println("parse Section header ... ");
        ParseSoUtil.parseSectionHeaderList(soBytes);
        System.out.println("======================================");
        
        System.out.println("parse Symbol Table ... ");
        ParseSoUtil.parseSymbolTable(soBytes);
        System.out.println("======================================");
        
        System.out.println("parse String Table ... ");
        ParseSoUtil.parseStringTable(soBytes);
        System.out.println("======================================");
    }
    
    /**
     * 读取二进制数据
     * @param filePath 文件路径
     * @return
     */
    private static byte[] getBytesFromFile(String filePath) {
        byte[] soBytes = null;
        InputStream is = null;
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
            is = new FileInputStream(filePath);
            byte[] bytes = new byte[1024];
            int len = 0;
            while((len = is.read(bytes)) != -1) {
                baos.write(bytes, 0, len);
            }
            soBytes =  baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                baos.close();
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return soBytes;
    }
}

#参考文章

Android逆向之旅---SO(ELF)文件格式详解

#代码下载

mazaiting
关注
breakpad-android多so文件解析
XavierWu的专栏
12-18 264
android支持如下7中CPU架构 目前android支持如下7中CPU架构： armeabi 第5代 ARM v5TE，使用软件浮点运算，兼容所有ARM设备，通用性强，速度慢（只支持armeabi） armeabi-v7a 第7代 ARM v7，使用硬件浮点运算，具有高级扩展功能（支持 armeabi 和 armeabi-v7a，目前大部分手机都是这个架构） arm64-v8a 第8代，64...
Android so(ELF) 文件解析
l0neman 的博客
11-21 3307
文章目录前言生成 so 文件相关工具objdumpreadelf整体结构图头部结构段表结构字符串表结构程序表结构符号表结构重定位表结构其他结构解析代码打开 ELF 文件检查 ELF 文件解析 ELF 头部结构解析段描述表结构解析字符串表打印段描述表结构解析符号字符串表解析程序头表解析段解析符号表解析重定位表测试解析源码参考 前言 ELF 是一种可执行文件的格式，全称是 Executable and Linkable Format，即可执行和链接格式，它是 Unix/Linux 系统下的二进制文件的标准格式，
解析so文件
10-22
解析so文件的工具类，很实用的一个工具类。
so文件解析
10-22
使用C++解析一个so文件，很是使用的一个工具类。
使用readelf分析so文件
最新发布
CYRUS STUDIO
09-29 363
虽然 readelf 工具本身是为 Unix-like 操作系统设计的，但你可以在 Windows 上通过 WSL 使用它。新一个 soinfo.sh，编写一个简单的Shell脚本，调用 readelf -a 命令并将输出保存到同名的 .txt 文件中。调用 readelf -a 一次性查看文件中的所有信息，包括文件头、程序头、节头、符号表、动态节等。在 wsl 中 /mnt/d 对应的就是 windows 下的 D 盘，其他同理。创建 scripts 目录，并把 soinfo.sh 放到该目录下。
Android逆向-Android逆向基础10（so文件分析大合集）
王嘟嘟的博客
02-15 5923
0x00 前言 导航 博客导航戳这里 练习资源戳这里 说明 在so文件的分析上，我们需要对一些ARM汇编的逻辑实现。 在代码逻辑上，只对if，switch，还有循环进行一个demo分析和创建。可能会篇幅比较大。 内容 1.if逻辑NDK编程 2.if逻辑ARM分析 3.switch逻辑NDK编程 4.switch逻辑ARM分析 5.循环逻辑NDK编程 6.循环...
Android SO文件保护加固——混淆篇（一）源代码
09-26
3. **数据混淆**：对于SO文件中的常量和数据结构，混淆可以通过加密、编码或者使用动态加载等方式，确保其在内存中的形式不被轻易解析。 4. **字符串混淆**：替换字符串变量为随机字符序列，或者在运行时动态解密...
Android 加载so文件失败,android studio 加载so文件的各种问题
weixin_32137855的博客
05-28 1145
android studio加载so文件的疑问记录，很多人遇到这个问题，自己各种尝试得出一片结论，乐于分享。在0.4.0版本时我总结了一篇文章，android studio V0.4.0调整。之前的理解有点不到位，把最近的理解记录下，，大家帮我纠正，谢谢。先上脚本代码：android {......task copyNativeLibs(type: Copy) {from fileTree(dir...
android ijkplayer完整so库0.8.8
02-18
在Android应用中，开发者通常需要将SO文件打包到APK中，以便运行时加载并使用ijkplayer的功能。 6. **使用步骤** 使用ijkplayer时，开发者需要先将ijkplayer库导入项目，配置项目的build.gradle文件，然后在Java或...
Java解析SO（ELF）文件
01-07
使用Java解析SO（ELF）文件，包含文件头部，程序头部表，节区头部表
android so文件解密器,【Android 原创】so文件动态加解密的CrackMe
weixin_29863361的博客
05-27 6365
作者论坛账号：genliese1. 前言一道so文件动态加解密的CrackMe，运行时解密要执行的函数，且在执行后立马加密CrackMe：dex文件加的数字壳，so文件无壳，因为反调试，所以so文件采用全静态分析分析环境：脱壳工具：FARTGDAIDAFridaPyCharmVSCode2. 分析过程2.1 脱壳拿到FART定制ROM下跑，得到想要的dex文件，数字壳抹去了前八个字节的dex文件魔...
so文件加密
09-29
加密libdemo.so成功。 加密native-lib.cpp生成的libnative-lib.so不成功；
[安卓开发] 通过so文件进行数据AES加密
11-26
调用JNI进行数据加密 , 加密刷法采用AES , 对一些敏感的数据进行加密 , 不用担心被破解
android中so文件格式详解,详解Android studio中正确引入so文件的方法
weixin_35948624的博客
05-25 336
相信很多朋友在使用Android studio开发中，遇到过如何引入第三方so文件的问题，然而第三方官方仅仅给出了ADT环境下的集成方式。Android studio中默认使用的是gradle编译方式，与ADT编辑方式不一样，那么so文件应当如何引入呢？其实很简单。这里以集成JPUSH为例，看一下so文件如何引入到编译环境，最终到JNI直接可以调用该so文件。首先，在我们的Module的根目录中建...
android动态加载so破解,[原创] 记一次so文件动态解密
weixin_39840733的博客
05-26 2011
写在前面整个程序基本上就是一个 动态注册 + so函数加密 的逻辑，中间加了一些parser的东西主要考察了elf文件结构的一些知识以及在攻防对抗中防止IDA静态分析的姿势题目描述找到flagWriteUp360加固,先脱壳，看入口函数MainActivity具体的逻辑写到so里了，使用IDA打开so文件,先看有没有.init和.init_array,发现只有.init_array节，跟进去一看又...
Android逆向之破解某应用加密算法(动态调试so和hook so代码)
Tomes.V.White
03-31 5049
转载自：http://www.520monkey.com/archives/1310 一、样本静态分析 最近有位同学发了一个样本给我，主要是有一个解密方法，把字符串加密了，加解密方法都放在so中，所以之前也没怎么去给大家介绍arm指令和解密算法等知识，正好借助这个样本给大家介绍一些so加密方法的破解，首先我们直接在Java层看到加密信息，这个是这位同学直接告诉我这个类，我没怎么去搜了： ...
一分钟搞明白Android的.so文件、ABI和CPU的关系
linxinfa的专栏
07-30 3037
文章目录一、前言二、Android的CPU架构三、CPU与API的对应关系四、典型的 ABI 包含的信息五、.so文件的命名规范六、.so文件存放位置 一、前言 不同的Android手机使用不同的CPU，而不同的 CPU支持不同的指令集，CPU与指令集的每种组合都有专属的应用二进制接口，即 ABI。 二、Android的CPU架构 Android系统目前支持以下七种不同的CPU架构 CPU架构 描述 时间 ARMv5 第5代 ARM v5TE，使用软件浮点运算，兼容所有ARM设备，通用性强，
Android 关于CPU类型的so文件兼容问题（ABI），hashmap扩容过程
m0_64603776的博客
12-19 816
compileSdkVersion 28 // 编译sdk版本 defaultConfig { applicationId “com.example.zhouwei.helloworld” minSdkVersion 15 targetSdkVersion 28 versionCode 1 versionName “1.0” testInstrumentationRunner “android.support.test.runner.AndroidJUnitRunner” // 适配指定CPU架构 ndk
android开发 加载so库的解析和出现的各种错误分析
2401_84104809的博客
04-11 857
Eclipse工程放在libs/ABI目录中（这也是ndk-build命令默认生成.so文件的目录）AAR压缩包中位于jni/ABI目录中（.so文件会自动包含到引用AAR压缩包的APK中）最终APK文件中的lib/ABI目录中通过PackageManager安装后，在小于Android 5.0的系统中，.so文件位于app的nativeLibraryPath目录中；在大于等于Android 5.0的系统中，.so文件位于app的nativeLibraryRootDir/CPU_ARCH目录中。
深入解析Android .so库：ELF文件格式详解
在Android平台上，.so文件是动态链接库，用于提供C/C++代码的功能给Java应用程序。这些文件通常包含了设备驱动、底层计算或高性能计算任务所需的原生代码。 文档首先概述了ELF文件格式的基本概念，强调了其在构件化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值