android so文件攻防实战-百度加固免费版libbaiduprotect.so反混淆

最新推荐文章于 2025-05-09 16:06:41 发布
转载 最新推荐文章于 2025-05-09 16:06:41 发布 · 1.6k 阅读 · 7 ·
CC 4.0 BY-SA版权
原文链接：https://bbs.pediy.com/thread-271388.htm
文章标签：

#android

本文详细介绍了如何对Android的SO文件进行反混淆处理，以百度加固免费版的libbaiduprotect.so为例，包括去除垃圾代码、解密字符串和处理动态获取的libc函数。通过使用IDA Pro和Frida等工具，成功还原了混淆后的代码，使得分析过程更为清晰。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转：[原创]android so文件攻防实战-百度加固免费版libbaiduprotect.so反混淆-Android安全-看雪论坛-安全社区|安全招聘|bbs.pediy.com

计划是写一个android中so文件反混淆的系列文章，目前只写了这一篇。
样本libbaiduprotect_dump.so来自看雪上的帖子：百度加固免费版分析及VMP修复

原文把整个流程已经分析很清楚了，这里就不分析了，只说怎么处理libbaiduprotect_dump.so里面的混淆。

第一种混淆：加入垃圾代码

很多函数里面都插了垃圾代码，比如JNI_OnLoad：


两个相邻的数相乘肯定是偶数，while条件永远false，if条件永远true。这里我的方法就是直接把ADRP X8, #dword_C0144@PAGE(ADRP X8, 0xC0000)这样的指令改成ADRP X8, 0xA0000，因为0xC0124在bss段没有初始化，0xA0124在eh_frame段已经初始化，所以这样改了以后IDA F5的时候就会把这些垃圾代码自动优化掉。
注意：需要自己去装一个keystone，因为脚本用到了kstool.exe生成机器码。

from idautils import *
from idaapi import *
from idc import *
 
import subprocess
 
for segea in Segments():
    for funcea in Functions(segea, get_segm_end(segea)):
        for (startea, endea) in Chunks(funcea):
            for line in Heads(startea, endea):
 
                if idc.GetDisasm(line) in ["ADRP            X8, #dword_C0144@PAGE", \
                                        "ADRP            X8, #dword_C0140@PAGE", \
                                        "ADRP            X8, #dword_C013C@PAGE", \
                                        "ADRP            X8, #dword_C0138@PAGE", \
                                        "ADRP            X8, #dword_C0134@PAGE", \
                                        "ADRP            X8, #dword_C0130@PAGE", \
                                        "ADRP            X8, #dword_C012C@PAGE", \
                                        "ADRP            X8, #dword_C0128@PAGE", \
                                        "ADRP            X8, #dword_C0124@PAGE", \
                                        "ADRP            X8, #dword_C0120@PAGE", \
                                        "ADRP            X8, #dword_C011C@PAGE", \
                                        "ADRP            X8, #dword_C0118@PAGE"]:
                    pi = subprocess.Popen(['D:\\keystone-0.9.2-win64\\kstool.exe', 'arm64', 'ADRP X8, 0xA0000', hex(line)], shell=True, stdout=subprocess.PIPE)
                    output = pi.stdout.read()
                    asmcode = str(output[20:33])[:-1]
                    asmcode = asmcode.split(" ")
                    asmcode = "0x" + asmcode[4] + asmcode[3] + asmcode[2] + asmcode[1]
                    print(asmcode)
                    patch_dword(line, int(asmcode, 16))
                elif idc.GetDisasm(line) in ["ADRP            X9, #dword_C0140@PAGE", \
                                            "ADRP            X9, #dword_C013C@PAGE", \
                                            "ADRP            X9, #dword_C0138@PAGE", \
                                            "ADRP            X9, #dword_C0134@PAGE", \
                                            "ADRP            X9, #dword_C0130@PAGE", \
                                            "ADRP            X9, #dword_C012C@PAGE", \
                                            "ADRP            X9, #dword_C0128@PAGE", \
                                            "ADRP            X9, #dword_C0124@PAGE", \
                                            "ADRP            X9, #dword_C0120@PAGE", \
                                            "ADRP            X9, #dword_C011C@PAGE", \
                                            "ADRP            X9, #dword_C0118@PAGE"]:
                    pi = subprocess.Popen(['D:\\keystone-0.9.2-win64\\kstool.exe', 'arm64', 'ADRP X9, 0xA0000', hex(line)], shell=True, stdout=subprocess.PIPE)
                    output = pi.stdout.read()
                    asmcode = str(output[20:33])[:-1]
                    asmcode = asmcode.split(" ")
                    asmcode = "0x" + asmcode[4] + asmcode[3] + asmcode[2] + asmcode[1]
                    print(asmcode)
                    patch_dword(line, int(asmcode, 16))
                elif idc.GetDisasm(line) in ["ADRP            X10, #dword_C0140@PAGE", \
                                            "ADRP            X10, #dword_C013C@PAGE", \
                                            "ADRP            X10, #dword_C0138@PAGE", \
                                            "ADRP            X10, #dword_C0134@PAGE", \
                                            "ADRP            X10, #dword_C0130@PAGE", \
                                            "ADRP            X10, #dword_C012C@PAGE", \
                                            "ADRP            X10, #dword_C0128@PAGE", \
                                            "ADRP            X10, #dword_C0124@PAGE", \
                                            "ADRP            X10, #dword_C0120@PAGE", \
                                            "ADRP            X10, #dword_C011C@PAGE", \
                                            "ADRP            X10, #dword_C0118@PAGE"]:
                    pi = subprocess.Popen(['D:\\keystone-0.9.2-win64\\kstool.exe', 'arm64', 'ADRP X10, 0xA0000', hex(line)], shell=True, stdout=subprocess.PIPE)
                    output = pi.stdout.read()
                    asmcode = str(output[20:33])[:-1]
                    asmcode = asmcode.split(" ")
                    asmcode = "0x" + asmcode[4] + asmcode[3] + asmcode[2] + asmcode[1]
                    print(asmcode)
                    patch_dword(line, int(asmcode, 16))

处理以后：


第二种混淆：字符串加密

加密后的字符串基本都长这个样子：


每个字符串的解密函数虽然都不一样，但是逻辑都差不多。处理字符串加密可以用的工具有很多，我习惯用frida。
第一步是通过交叉引用拿到加密后的字符串和它对应的解密函数的表：

from idautils import *
from idaapi import *
from idc import *
 
import string
 
rodata_start = 0x959B0
rodata_end = 0x9AF68
 
def get_string(addr):
    out = ""
    while True:
        if get_byte(addr) != 0:
            out += chr(get_byte(addr))
        else:
            break
        addr += 1
    return out
 
addr = rodata_start
index = 0
 
while addr < rodata_end:
    str = get_string(addr)
    str_len = len(str) + 1
    if all(c in string.hexdigits for c in str) and str_len > 8:
 
        xrefaddrs = XrefsTo(addr, flags=0)
        for xrefaddr in xrefaddrs:
            call_addr = xrefaddr.frm
            while print_insn_mnem(call_addr) != "BL":
                call_addr = next_head(call_addr)
        decode_func_addr = print_operand(call_addr, 0)
        print("\"" + decode_func_addr + '***' + str + "\"" + ",")
 
    addr += str_len

结果：


第二步是把这个表丢给frida，让frida去调一遍，拿到解密后的字符串。为了代码简洁这个表就没有列完，只有两项：

import frida
import sys
 
device = frida.get_usb_device(1)
session = device.attach("Test")
 
scr = """
var str_name_so = "libbaiduprotect.so";
var n_addr_so = Module.findBaseAddress(str_name_so);
// console.log("libbaiduprotect.so base address:");
// console.log(n_addr_so.toString(16));
 
var decode_func2str_list = [
"sub_25FD0***09598DD611D1543C",
"sub_2607C***8CA86FFB66BD1DAFC58A62B543A840AACA833ED67ABD44A28B8864F477F361B7D68D6BFD2B9058A2D2852AF671B255ECF79077F37EBB098FCE8573FB3FB053ADC3CB56EE62B55CA49FAD5FB346",
......
]
 
for (let i in decode_func2str_list)
{
    var str = decode_func2str_list[i].substring(12)
    var funcaddr = parseInt(decode_func2str_list[i].substring(4, 9), 16)
 
    var n_funcaddr = funcaddr + parseInt(n_addr_so, 16);
    //console.log("n_funcaddr address:");
    //console.log(n_funcaddr.toString(16));
 
    var call_func = new NativeFunction(ptr(n_funcaddr), 'pointer', ['pointer']);
    var str_arg = Memory.allocUtf8String(str);
    var p_str_ret = call_func(str_arg);
    var str_ret = Memory.readCString(p_str_ret);
 
    console.log("\\"" + str_ret + "\\"" + ",");
}
"""
 
def on_message(message, data):
    print(message)
    #print(message['payload'].encode("utf-8"))
 
script = session.create_script(scr)
script.on("message", on_message)
script.load()

结果：


第三步就是把加密后的字符串直接patch成加密前的字符串，因为如果用set_cmt(也就是IDA7.4以前的MakeComm)把加密前的字符串当成注释加上的话F5的窗口是没有的，这样直接patch看起来更清晰直观。加密后的字符串总是比加密前的字符串长，多出来的就patch成0。同样为了代码简洁加密前的字符串没有列完，只有两项：

from idautils import *
from idaapi import *
from idc import *
 
import string
 
rodata_start = 0x959B0
rodata_end = 0x9AF68
 
def get_string(addr):
    out = ""
    while True:
        if get_byte(addr) != 0:
            out += chr(get_byte(addr))
        else:
            break
        addr += 1
    return out
 
addr = rodata_start
index = 0
 
decrypted_str = [
"n001",
"(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IZ)V",
......
]
 
while addr < rodata_end:
    str = get_string(addr)
    str_len = len(str) + 1
    if all(c in string.hexdigits for c in str) and str_len > 8:
 
        i = 0
        tmp_addr = addr
        decrypted_strlen = len(decrypted_str[index])
 
        while i < str_len:
            if i >= decrypted_strlen:
                patch_byte(tmp_addr, 0x00)
            else:
                patch_byte(tmp_addr, ord(decrypted_str[index][i]))
            i = i + 1
            tmp_addr = tmp_addr + 1
        index = index + 1
 
    addr += str_len

还是前面的sub_12274，来看处理完以后的效果：

第三种混淆：libc函数动态获取

sub_B3B4动态获取libc中的函数并保存，我们这里做一下符号重命名即可。
首先把F5中的sub_B3B4保存下来，然后写个脚本把qword_BE238命名为_exit_libc，qword_BE240命名为exit_libc，qword_BE248命名为pthread_create_libc，依次类推即可。

from idautils import *
from idaapi import *
from idc import *
 
flag = 0
for line in open("D:\\libc.cpp"):
    if flag == 0:
        strs = line.split("\"")
        funcname = strs[-2]
        funcname += "_libc"
        flag = 1
        continue
    if flag == 1:
        addrname = line[8:13]
        addrname = int(addrname, 16)
        flag = 0
        set_name(addrname, funcname, SN_CHECK)

结果：

用这些函数的地方也看的比较清楚。


总结

百度加固免费版libbaiduprotect.so里面基本上就是这些花样，还是比较好搞定的。

Android SO文件保护加固——混淆篇（一）源代码
09-26
Android SO文件保护加固——混淆篇
Android安全攻防实战(带书签目录版).pdf
06-27
《Android安全攻防实战》是一本深入探讨Android平台安全性的技术书籍，主要针对开发者、安全研究人员以及对Android系统安全有兴趣的读者。这本书详尽地介绍了Android系统的安全机制、漏洞分析、攻击手段以及防御策略...
使用百度加固服务给app应用加固
海的那边的专栏
08-27 1万+
先上一段百度加固的上线公告： 尊敬的开发者： 为防止您的在百度开发者平台提交的移动应用利益受损，现百度开发者平台为您提供移动应用加固服务，使用加固服务，能有效防止应用被反编译、篡改，保护开发者知识产权。 但近日频繁发现有恶意应用使用“第三方加固”规避百度审核，严重损害了用户权益。 自2015年8月24日起，百度开发者平台将不再上线使用第三方加固服务的应用（联
深入理解Android应用中的so文件加固技术.zip
最新发布
weixin_36364707的博客
05-09 1227
在Android应用中，加固是一个重要的过程，其中，Section加密是一个核心环节。Section加密的主要目的是增加应用的安全性，防止恶意攻击者通过逆向工程等方式窃取应用中敏感的代码和数据。通过对关键代码段实施加密，可以在很大程度上减慢甚至阻止逆向工程的进程。具体来说，Section加密的意义表现在以下几个方面：安全加固：加密技术使得未授权用户很难理解和修改应用的行为，提高了代码的保密性。恶意行为防御。
Android So简单加固
omnispace的博客
10-05 5782
Android下的dex加固技术从最初爱加密实现的dex整体内存加载，到目前各大厂商都在研究的代码虚拟化技术，整体技术已经很成熟了。但是因为Android系统开源的特性，这种加固方法的安全性并不高，只要修改源码中dex加载的部分，就可以dump出隐藏的dex，根据这一原理目前也已经有多个Android通用脱壳机。既然dex保不住，那么就可以将安全要求较高的代码写到native层，现在加固厂商已基本
抖音so反混淆
signature=的博客
06-30 2441
arm架构下ollvm平坦化的反混淆app样本
Android应用安全：实现apk加固:代码、资源、so全加密隐藏。防标记,防报毒,防篡改,防破解,防逆向。批量自动改包，自动打包。附免费加固工具。
这个我知道诶的博客
10-14 6541
Android应用安全：实现apk加固，apk套壳，apk加密，apk隐藏，so加密，资源隐藏。防报毒，防标记，防篡改，防破解，防逆向。自动打包，自动改包，批量改包，批量打包。附免费加固工具。
内网安全攻防-渗透测试指南 读书笔记.pdf
09-09
### 内网安全攻防-渗透测试指南 读书笔记 #### 一、内网渗透测试基础 在进行内网渗透测试之前，理解Powershell执行策略及其如何影响脚本运行至关重要。 - **Powershell执行策略**：Powershell的安全执行策略通过...
网络靶场：从专业赋能到实战攻防-赛博空间的对抗与演进.pdf
08-08
打通从实战仿真到实战的壁垒，依托网络靶场开展实网攻防，从源头上完成“学、练、打”三位一体，面向实战，面向未来。 网络靶场的理想模型与发展趋势 在网络对抗、Testbed的专业赋能 实战型靶场演进方向
WAF攻防实战笔记v1.0--Bypass.pdf
03-30
以下是从文件中提取的关键知识点： ### 服务器特性 在服务器层面，攻击者会利用特定服务器软件的特性或漏洞来绕过WAF防护。例如： 1. **ASP和IIS的特殊符号%**：在ASP结合IIS的环境中，特殊符号%可能在WAF层和IIS...
Android安全攻防实战-高清-完整目录-2015年7月
04-16
Android安全攻防实战-高清-完整目录-2015年7月,分享给所有需要的人!
百度安全组件1.0
01-09
BaiduProtect_Setup.exe　百度安全组件1.0
so加固例子--加密函数
11-21
so加固例子--加密函数
Android Proguard 不混淆所有第三方jar（忽略配置设置）
王能的小屋
12-12 2万+
今天给大家分享一个只混淆自己的项目代码而不混淆所有第三方jar的方法（没错，是所有的第三方都不进行混淆，无论来什么第三方，都不需要动混淆配置） 一、为app添加混淆 在app的buildTypes里开启对指定包进行混淆，这里我混淆了release和debug的，并且增加了一个不混淆的类型（注①） buildTypes { release { mini...
基于对so中的函数加密技术实现so加固
xiziyunqi的博客
09-12 884
一、技术原理这篇和之前的那篇文章唯一的不同点就是如何找到指定的函数的偏移地址和大小在so文件中，每个函数的结构描述是存放在.dynsym段中的。每个函数的名称保存在.dynstr段中的，类似于之前说过的每个section的名称都保存在.shstrtab段中，所以在前面的文章中我们找到指定段的时候，就是通过每个段的sh_name字段到.shstrtab中寻找名字即可，而且我们知道.shstrtab这个
Android中对Apk加固(加壳)续篇之---对Native层(so文件)进行加固
weixin_30721077的博客
11-21 340
有人说Android程序用Java代码写的，再怎么弄都是不安全的，很容易破解的，现在晚上关于应用加固的技术也很多了，当然这些也可以用于商业发展的，梆梆加密和爱加密就是很好的例子，当然这两家加固的Apk也是被很多geeker拿来练手和研究的主要对象，没有绝对的安全，只有相对的攻防。那么今天就来介绍一下关于Android中的加壳原理，当然这些技术是指大体上的原理介绍，和那些商业加固差距还是很大的，...
逆向libbaiduprotect（三）- 移植python操作dalvik虚拟机c++函数，配合gdb控制程序运行流程...
weixin_30446197的博客
06-09 146
python编译移植到测试机，并且移植ctypes模块。利用ctypes代替c程序，利用dalvik内部c++函数，在运行过程中手动命令操控dalvik虚拟机，并结合gdb进行调试。绕过zygote和ASM去启动进程。 由于我使用手动创建虚拟机，而不是通过zygote去启动虚拟机，zygote会通过androidruntime::startVM去加载和初始化所有运行app的环境。所以我必须自...
根据”so劫持”过360加固详细分析
雪一梦的博客
01-06 3652
参考：https://bbs.pediy.com/thread-223699.htm http://blog.csdn.net/luoshengyang/article/details/8923483 一：思路分析：     一个经过360加固的APK的运行过程应该为图中左边所示，在以上这种so劫持的思路为:第一步通过hook loadlibrary方法先加载自己的so，即：libh
Android SO文件保护加固——混淆篇（一）
热门推荐
雪一梦的博客
09-26 2万+
继上次基于源码级别和二进制级别的SO文件的核心函数保护后，没看的网友可以点击：点击打开链接；这篇是针对我们在JNI开发过程中利用javah生成本地层对应的函数名类似于java_com_XX这种形式，很容易被逆向者在逆向so的时候在IDA的Exports列表中找到这样一个问题，我们的目的就是让IDA在反汇编过程显示不出来，以及就算找到函数实现也是乱码的形式接下来开始搞；有问题欢迎大家批评指正和讨论。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值