本文最后更新于：2021年8月3日下午

baby_maze

没有迷宫数据，一堆函数调用，得写脚本跑了，使用idapython。

1
2

我们可以找到最后提示成功的函数，然后通过交叉引用获取上层调用的函数，一直追溯到开始，跑出函数调用流程。
对于获取WASD方向，分析函数时发现在调用方向函数时有switch case xx 的注释，直接去获取注释，即可得到路径。

import hashlib

start_addr = 0x54de35  #提示成功的函数地址
end_addr = 0x40187c    #迷宫开始的函数地址
call_path = []
md5 = hashlib.md5()
def search(call_addr, call_list, maze_path="S"): #因为0x40187前边还有一个S，所以这里先给个S
    if call_addr == end_addr:   #追溯到最初的函数时，进行提取WASD方向，并且计算flag
        print("search success")
        for i in range(len(call_path)-1, -1, -1):
            switch = GetCommentEx(int(call_path[i], 16)-5, True)  #通过注释获取switch case
            case_num = int(switch[-2:], 10)
            maze_path += chr(case_num)
        md5.update(maze_path.encode("utf-8"))
        print("flag{" + md5.hexdigest() + "}")
        return

    for refs in CodeRefsTo(call_addr, 0): #获取交叉引用的地址
        fun_name = GetFunctionName(refs)
        fun_addr = LocByName(fun_name)   #获取交叉引用的地址所在的函数，并且得到地址，进行下一次交叉引用
        if hex(fun_addr) in call_list:   #判断此路径可否继续
            continue
        call_list.append(hex(fun_addr))
        call_path.append(hex(refs))
        search(fun_addr, call_list)
        call_list.remove(hex(fun_addr))
        call_path.remove(hex(refs))
cl = []
search(start_addr, cl)

medical_APP

反编译，java没什么东西，直接看native层。

dump比较的数据，进行xxtea解密。

#include <stdio.h>
#include <stdint.h>
#define DELTA 0x9F5776B6
#define MX (((z >> 5 ^ y << 2) + (y >> 3 ^ z << 4)) ^ ((sum ^ y) + (key[(p & 3) ^ e] ^ z)))

void btea(uint32_t *v, int n, uint32_t const key[4])
{
    uint32_t y, z, sum;
    unsigned p, rounds, e;
    if (n > 1) /* Coding Part */
    {
        rounds = 6 + 52 / n;
        sum = DELTA;
        z = v[n - 1];
        do
        {
            e = (sum >> 2) & 3;
            for (p = 0; p < n - 1; p++)
            {
                y = v[p + 1];
                z = v[p] += MX;
            }
            y = v[0];
            z = v[n - 1] += MX;
            //printf("%x\n", y);
            sum -= 0x60A8894A;
        } while (--rounds);
    }
    else if (n < -1) /* Decoding Part */
    {
        n = -n;
        rounds = 6 + 52 / n;
        sum = rounds * DELTA;
        y = v[0];
        do
        {
            e = (sum >> 2) & 3;
            for (p = n - 1; p > 0; p--)
            {
                z = v[p - 1];
                y = v[p] -= MX;
            }
            z = v[n - 1];
            y = v[0] -= MX;
            sum += 0x60A8894A;
        } while (--rounds);
    }
}

int main()
{
    // uint32_t v[9] = {0x87e25a01, 0x3c4364d2, 0x0ec3cc97, 0xd06cbb92, 0xb8411653, 0x43e7378d, 0x52947a3b, 0x1e5abac4, 0xd75382e7};
    uint32_t v[9] = {0xc5268710, 0x6d7b0e5e, 0xc5d265c7, 0xda3a935f, 0xa0c5a950, 0x2daeb502, 0x228e3628, 0x1db6ceb5, 0xd5386a5};
    uint32_t ss[9] = {
        0x68E5973E, 0xC20C7367, 0x98AFD41B, 0xFE4B9DE2, 0x01A5B60B, 0x3D36D646, 0xDBCC7BAF, 0xA0414F00,
        0x762CE71A};
    uint32_t const k[4] = {1, 0x10, 0x100, 0x1000};
    int n = 9; //n的绝对值表示v的长度，取正表示加密，取负表示解密
    // v为要加密的数据是两个32位无符号整数
    // k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位
    // printf("加密前原始数据：%x %x %x %x %x %x %x %x\n", v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
    //btea(v, n, k);
    // printf("加密后的数据：%x %x %x %x %x %x %x %x\n", v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7]);
    btea(ss, -n, k);
    printf("解密后的数据：%x %x %x %x %x %x %x %x %x\n", ss[0], ss[1], ss[2], ss[3], ss[4], ss[5], ss[6], ss[7], ss[8]);
    //printf("加密前原始数据：%x %x %x %x %x %x %x %x %x\n", v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8]);
    return 0;
}