52pojie新年快乐2022flag破解

2022-02-17

前言

由于该apk的flag在java层并没有什么东西,只有一个输入长度为16，java就不用进行分析了，打开so之后发现并没有静态注册的内容，也就是说checkSn（该函数是我们要分析的函数），该函数是动态注册。

但是我们hook了RegisterNative之后得到该函数注册的偏移地址之后发现，so始终跳转不过去，很有可能是因为其通过内嵌汇编的方式进行了编码，在编译期是不会编译内嵌汇编的代码的，也就是说这部分静态分析不了，因为我们正常拿到的so都是编译好的so。
给出apk文件所能获得到的链接https://down.52pojie.cn/Challenge/Happy_New_Year_2022_Challenge.rar

原帖链接：https://www.52pojie.cn/thread-1582582-1-1.html

动态调试

使用KingTrace，通过KingTrace遍历整个so看看长度。
图 2

好家伙，3w+（其实还是比较好的情况）。

所谓逆向分析，一般从最终的结果或者从某个点开始进行切入，由于本次结果返回的是一个boolean类型，即返回false则表明结果有误，而该flag是否有误肯定会进行对比之后再进行判断，而如何对比？汇编里面主要用两条指令进行if判断，cmp和cmn,两者的区别主要在于例如：cmp x0, x1 => x0 - x1 是否大于等于0，而cmn x0, x1 => x0 + x1 是否大于等于0为判断是否为真，如是而已。

我们可以试着搜索一下这两个指令。
cmn:
图 3

cmp:
图 4
本程序没有cmn则我们重点分析cmp指令相关代码。

要找到什么样的cmp代码

cmp指令的位置在文件当中靠后，且比较之后，且比较后会在几个指令这样ret，且此时的某个寄存器的值应该为0x0。

图 5

图 6
看图2我框出来的位置，此时w0还不是0x0。

我们通过unidbg的unidbg的Patch Code来对opcode进行修改达到逻辑修改的目的。

public void unidbgPatchCode() {
    byte[] patchCode = {(byte) 0x1F, (byte) 0x00, (byte) 0x00, (byte) 0x6B};  // cmp w0, w0
    emulator.getBackend().mem_write(module.base + 0x7848, patchCode);
}

结果：
图 7

返回true了！

以0x7848为起始点，往上追溯最近的x0或w0.
图 8
打印x21的结果：d107a923fc131730c5abb640363c3df7bd5e181a9dcc8977a61d15c983800a1

我们看看既然这玩意跟结果有关，且其存放在X0寄存器上，我们知道一般传参范围为x0~x7，可以看到mov x0和x1和x2,一般这样的赋值就意味着要把这三个值传递给下一个函数，也就是刚才我们调用的函数。
图 1

也就证明，该程序对比输入参数和flag的部分就在0x780c这个子程序里。言下之意刚才找到的x21、x20一个是输入，一个是flag（x3刚才赋值的是0x20也就是32，也就是32字节，指的是hex的长度吧）。

那当前的思路已经很明确了：

先确认输入和flag是哪个。
沿着操作flag的地方向上追溯，寻找算法特征。

如何确定flag和输入

重放！修改输入的值然后再对比两个hex的值。

x20的值：
6e6649305baf80c49b1b063c0500c80346ccfd42b3063ae7312b52a21cd334d8
x21的值：
d107a923fc131730c5abb640363c3df7bd5e181a9dcc8977a61d15c983800a10
修改前：
图 2

修改后：
图 3

可以发现x21发生了变化，而x20没有发生变化，也就是说，只要我们解开了6e6649305baf80c49b1b063c0500c80346ccfd42b3063ae7312b52a21cd334d8就能拿到flag了。

老法子向上追溯找到0x40398018出现的地址
图 7

量不是很大，看来可以直接一个一个debugger看看，直到找到最初出现或者出现一部分值的地方。

我们可以看到第一处出现这个地址的地方实际上已经赋值好对应的值了。

往上推。
图 8

顺势找到这里
图 9

图 10

结果：
图 1

说明校验值是在内存里被写死了。

虽然0x40398018这个地址被写死了，但是其最终比较却不用来做比较，那我们看看其最终使用的地址0x40398058,通过unidbg的memory trace write来监控该地址。

图 2

效果很棒！

图 3

我们来到第一个发现其最开始的地方并没有被设置值，debugger之后按s来到这里。
图 4

看起来是循环赋值，看看跳到哪里。

图 6

此时的x0为我们关注的地址
图 8

x1:
图 7

可以看到x1里面包含了加密完成之后的值和原输入。既然如此还是从入参的加密入手，因为要对比的话两者的加密必然是同一种！

看看0xbffff450这个地址是如何被写入的。
图 1
看看后面这两位，拼接起来d107a923fc131730c5abb640363c3df7bd5e181a9dcc8977a61d15c983800a1输入的最终结果！

我们看看那串地址咋来的。
图 2
通过右移一定位数之后得到最终的结果，我们看看那一串长串咋来的。
图 3
通过一连串异或操作得来。

我们搜索这一串地址0x0acc4
图 8

图 9
第32行开始发现其x19的差别很大，就跟第1行

图 10

我们这里可以认为前16个字节和后16个字节是不一样的算法生成的。

那我们的分析主要分为从第一行开始和从第32行开始分析。

从第一行开始分析

图 11
第一轮ret后返回到0x8fec这个地址，那其跳转的位置就是0x8fec-0x4=0x8fe8

图 1
可以看到传递了5个参数

第一轮
入参：
[lib52pojie.so 0x08fd4] [e10315aa] 0x40008fd4: "mov x1, x21"-----x1=0x8d71d734	x21=0x3315191c		//x1=0x3315191c
[lib52pojie.so 0x08fd8] [e20316aa] 0x40008fd8: "mov x2, x22"-----x2=0x48	x22=0x7f47052d		//x2=0x7f47052d
[lib52pojie.so 0x08fdc] [e30317aa] 0x40008fdc: "mov x3, x23"-----x3=0x10	x23=0xc9d17d57		//x3=0xc9d17d57
[lib52pojie.so 0x08fe0] [e40318aa] 0x40008fe0: "mov x4, x24"-----x4=0x40	x24=0xd3f56ba2		//x4=0xd3f56ba2

x5=0x3c3b90e65e1f82

result:
x0=0xd1c65d38eb6b72
"eor x0, x0, x19"-----x0=0xd1c65d0bfe726e	x0=0xd1c65d0bfe726e	x19=0x3315191c		//x0=0xd1c65d38eb6b72

第二轮
入参：
x1=0x7f47052d
x2=0xc9d17d57
x3=0xd3f56ba2
x4=0xd1c65d38eb6b72
x5=0x72c025ec20d5a2

result:
x0=0x5befb8b03495c6
"eor x0, x0, x19"-----x0=0x5befb8cf7390eb	x0=0x5befb8cf7390eb	x19=0x7f47052d		//x0=0x5befb8b03495c6

第三轮:
入参：
x1=0xc9d17d57
x2=0xd3f56ba2
x3=0xd1c65d38eb6b72
x4=0x5befb8b03495c6
x5=0x4145992b8ee3ef

result:
x0=0xd7d37e36abae7f
"eor x0, x0, x19"-----x0=0xd7d37eff7ad328	x0=0xd7d37eff7ad328	x19=0xc9d17d57		//x0=0xd7d37e36abae7f

对应关系：

	上一轮入参	下一轮入参
x1	会参与与result的异或运算	上一轮x2
x2		上一轮x3
x3		上一轮x4
x4		上一轮result
x5

所以只要知道最初的x1，我们可以回溯到32轮之后的结果。我们全局搜索第一个x1 0x3315191c。
然后找到这个地方。
图 1
这个地方也就是最终的加密处啦~

接下来我们先看看入参怎么参与加密的或者是如何被同样的加密的。我们的输入是1234567890123455，把他转成hex.
图 1

31 32 33 34 35 36 37 38 39 30 31 32 33 34 35 35对应的话我们可以搜索0x31或0x32这样慢慢找到他们共同的疑似参与加密处。
图 2

图 3
看到这里我们有理由怀疑0x9b3c为入参调用加密函数的地方。
图 4
可以看到这里就是参与加密了（因为trace文件在更改入参的时候没有重新trace所有最后的地方是0x36）,再看看最后的结果。
图 5

对比第一轮加密的flag入参
图 6
完全是可以对得上的，但是由于我们是全局文本搜索，难免的会出现顺序问题，所以我们就可以知道我们的输入是如何参与加密的了。但是还要再看看w9 = 0x0以下的这部分
图 2
d1开头然后不按顺序来组装发现其可以拼成d107a923fc131730c5abb640363c3df7，即加密之后的前16个字节！

加密的流程

先对输入与“异或表”进行异或，对应的异或表为:0x2, 0x2b, 0x26, 0x28, 0x4a, 0x33, 0x70, 0x15, 0xf0, 0x4d, 0xe0, 0x65, 0xe0, 0x5f, 0xc0, 0x94。
根据刚才得出的对应关系进行异或。
当前32轮加密完成之后再分别对加密的结果与“结果异或表”：0x0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10进行异或操作,该结果很可能作为后32轮的入参，后续需要留意。

我们暂时先得出那么多，因为还需要对着arm进行代码还原看看他做了啥。

加密算法还原

找到有用到这5个参数的地方
图 1
然后一行一行的还原。。。。，这就是自研算法的还原方法了，无捷径纯手动还原。

需要注意的地方：

ldp指令的指令公式为：``LDP Xn, Xd, [Xt]`,意思是取Xt寄存器地址里的值的前8个字节给Xn,后8个字节分给Xd

分析一下这段，因为这个x12也有用到，那我们需要分析其具体在x29的偏移是多少。”ldp x9, x12, [x29, #-0x70]”
图 2
动态调试的时候发现了这个位置，跟刚才的结论是一致的也就是说，这里的x12的值为x29的地址-(0x70+0x8)也就是等价于ldr x12, [x29, #-0x68]

加密效果：
图 1

解密算法还原

flag加密之后的前半段为6e6649305baf80c49b1b063c0500c803,后半段为46ccfd42b3063ae7312b52a21cd334d8。
到这里我们需要重新梳理一遍加密流程：

先对输入与“异或表”进行异或，对应的异或表为:0x2, 0x2b, 0x26, 0x28, 0x4a, 0x33, 0x70, 0x15, 0xf0, 0x4d, 0xe0, 0x65, 0xe0, 0x5f, 0xc0, 0x94。
异或之后的结果为加密上半段密文的四个参数x1-x4。
当前32轮加密完成之后再分别对加密的结果与“结果异或表”：0x0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10进行异或操作，生成后半段密文加密前的4个参数。
这四个参数再走同样的加密函数最终生成密文。

通过对加密流程的梳理，梳理目前可用的情报。

输入：未知
输入异或表：[0x2, 0x2b, 0x26, 0x28, 0x4a, 0x33, 0x70, 0x15, 0xf0, 0x4d, 0xe0, 0x65, 0xe0, 0x5f, 0xc0, 0x94]
两者异或之后：生成加密算法入参未知
加密算法：已知
加密后生成的结果已知：6e6649305baf80c49b1b063c0500c803

结果异或表：[0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10]
两者异或之后：x1=0x6e597620, x2=0x4b90bfd4, x3=0x8b160b2c, x4=0x15d81013
加密算法：已知
加密后生成的结果：46ccfd42b3063ae7312b52a21cd334d8

图 1

我们知道结果是一长长串的16进制数，但是我们知道了最后32轮的入参（调用encrypt函数即可）
图 2

我们可以得到它的所有结果，首先x19在最初当中被赋值为x1的，且中途并没有进行操作，我们知道上图最后一个列表的最后一个数字是上一个列表的result,我们要怎么推出上一轮的入参x1（举例：也就是0x1664a7a7fe8744）？
图 3
我们复习一下这个规律，也就是我们已经有了最后一轮的结果，也就有了上一轮的x2, x3, x4, result，而x5在轮数当中是固定的，那我们要求的也就是上一轮的x1如是而已。

程序代码

本人在上面只提供了算法思路，到这里我提供整个代码供大家进行复现

input_xor_tab = [0x2, 0x2b, 0x26, 0x28, 0x4a, 0x33, 0x70, 0x15, 0xf0, 0x4d, 0xe0, 0x65, 0xe0, 0x5f, 0xc0, 0x94]
input_ = [0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35,
          0x36]  # 1234567890123456

eor_table = [0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10]

hex_table = [0xD6, 0x90, 0xE9, 0xFE, 0xCC, 0xE1, 0x3D, 0xB7, 0x16, 0xB6, 0x14, 0xC2, 0x28, 0xFB, 0x2C, 0x05,
             0x2B, 0x67, 0x9A, 0x76, 0x2A, 0xBE, 0x04, 0xC3, 0xAA, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,
             0x9C, 0x42, 0x50, 0xF4, 0x91, 0xEF, 0x98, 0x7A, 0x33, 0x54, 0x0B, 0x43, 0xED, 0xCF, 0xAC, 0x62,
             0xE4, 0xB3, 0x1C, 0xA9, 0xC9, 0x08, 0xE8, 0x95, 0x80, 0xDF, 0x94, 0xFA, 0x75, 0x8F, 0x3F, 0xA6,
             0x47, 0x07, 0xA7, 0xFC, 0xF3, 0x73, 0x17, 0xBA, 0x83, 0x59, 0x3C, 0x19, 0xE6, 0x85, 0x4F, 0xA8,
             0x68, 0x6B, 0x81, 0xB2, 0x71, 0x64, 0xDA, 0x8B, 0xF8, 0xEB, 0x0F, 0x4B, 0x70, 0x56, 0x9D, 0x35,
             0x1E, 0x24, 0x0E, 0x5E, 0x63, 0x58, 0xD1, 0xA2, 0x25, 0x22, 0x7C, 0x3B, 0x01, 0x21, 0x78, 0x87,
             0xD4, 0x00, 0x46, 0x57, 0x9F, 0xD3, 0x27, 0x52, 0x4C, 0x36, 0x02, 0xE7, 0xA0, 0xC4, 0xC8, 0x9E,
             0xEA, 0xBF, 0x8A, 0xD2, 0x40, 0xC7, 0x38, 0xB5, 0xA3, 0xF7, 0xF2, 0xCE, 0xF9, 0x61, 0x15, 0xA1,
             0xE0, 0xAE, 0x5D, 0xA4, 0x9B, 0x34, 0x1A, 0x55, 0xAD, 0x93, 0x32, 0x30, 0xF5, 0x8C, 0xB1, 0xE3,
             0x1D, 0xF6, 0xE2, 0x2E, 0x82, 0x66, 0xCA, 0x60, 0xC0, 0x29, 0x23, 0xAB, 0x0D, 0x53, 0x4E, 0x6F,
             0xD5, 0xDB, 0x37, 0x45, 0xDE, 0xFD, 0x8E, 0x2F, 0x03, 0xFF, 0x6A, 0x72, 0x6D, 0x6C, 0x5B, 0x51,
             0x8D, 0x1B, 0xAF, 0x92, 0xBB, 0xDD, 0xBC, 0x7F, 0x11, 0xD9, 0x5C, 0x41, 0x1F, 0x10, 0x5A, 0xD8,
             0x0A, 0xC1, 0x31, 0x88, 0xA5, 0xCD, 0x7B, 0xBD, 0x2D, 0x74, 0xD0, 0x12, 0xB8, 0xE5, 0xB4, 0xB0,
             0x89, 0x69, 0x97, 0x4A, 0x0C, 0x96, 0x77, 0x7E, 0x65, 0xB9, 0xF1, 0x09, 0xC5, 0x6E, 0xC6, 0x84,
             0x18, 0xF0, 0x7D, 0xEC, 0x3A, 0xDC, 0x4D, 0x20, 0x79, 0xEE, 0x5F, 0x3E, 0xD7, 0xCB, 0x39, 0x48]

params_x5 = [0x3c3b90e65e1f82, 0x72c025ec20d5a2, 0x4145992b8ee3ef, 0x69cff9c3113c5e, 0x73a0bdc7e35bb5,
             0x6587f6717f5417,
             0x33f15055cc7021, 0x54d89634fd983e, 0x7fb7780a7fadbb, 0x4f4f92ef4f948e, 0x5f72ac76224645,
             0x64fedb2ae2d1ac,
             0x5aa8969e2ac4bc, 0x680fea99ef2053, 0x6c1e634f07843e, 0x677673b06c935, 0x3d1b6be4557920, 0x1b04f5e1299f9c,
             0x326a513916a44c, 0x1ff10831d1d12e, 0x72fb7bdb5a88e, 0x6c3867e930366f, 0x4f884102f7796b, 0x7005c6149330c,
             0x284c586c9b290, 0x19ca128d08d882, 0x544b18a95a6bde, 0x6a14600a6179ed, 0x1d4be54074b82b, 0x7581763c59130d,
             0x4bb3c753b8931b, 0x668bd94d4abaa7]


all_encrypt_result_list = []
encrypt_result_list = [0] * 32
all_x_regs = []

def input2hex():
    """
    第一轮参数生成
    :return:
    """
    temp_list = []
    result_param = []
    for i in range(len(input_xor_tab)):
        temp_list.append(hex(input_[i] ^ input_xor_tab[i]))
    for i in range(0, len(temp_list), 4):
        result_param.append(hex((int(temp_list[i], 16) << (4 * 6)) + (int(temp_list[i + 2], 16) << (4 * 4))
                                + (int(temp_list[i + 1], 16) << 4 * 2) + int(temp_list[i + 3], 16)))
    return result_param


def bfi(dst, src, length, width):
    """
    格式：`BFI Xd, Xn, #lsb, #width`
    释义：用Xn中的Bit[0:width]替换Xd中的从lsb开始的width位，Xd其他位不变。


    bfxil:

    语法：`BFXIL Xd, Xn, #lsb, #width`
    释义：从Xn寄存器的第lsb位开始，提取width位，替换Xd寄存器的最低width位，剩余高位不改变。


    bfxil 等价于 lsb为0的时候，举例子 bfi(x8, x0, 0, 8)转为arm64指令为bfi x8, x9, #0x0, #0x8等价于bfxil x8, x0, #0, #0x8
    """
    ls = 0xFFFFFFFF >> (32 - width)
    lsb = length
    ls = ~((ls << lsb) & 0xff)
    if ls < -1:
        # 针对特例
        ls = -1
    dst = dst & ls
    dst = dst | (src & ls) << lsb
    return dst


def decrypt(args):
    x2, x3, x4, result, x5 = args
    x29 = [0] * 1024

    x9 = hex(int(x3, 16) ^ int(x2, 16))  # 0x0ac14
    x9 = int(x9, 16) ^ int(x4, 16)  # 0x0ac2c
    x21 = x9 ^ x5

    x1 = x21
    x29[-0x60] = x1  # 0x0ad0c
    x8 = x21  # 0x0ad7c
    x21 = x8 >> 0x8
    x22 = x8 >> 0x10
    x9 = x8  # 0x0ad88
    x25 = x9 >> 0x18  # 0x0ad98
    x1 = x25
    x10 = x1 & 0xff
    x0 = hex_table[x10]

    x29[-0x68] = x0  # 0x0addc
    # x1 = x21 & 0xffffffff  # 0x0ade8
    x1 = x21  # 0x0ade8
    x10 = x1 & 0xff
    x0 = hex_table[x10]
    x29[-0x70] = x0
    # x1 = x22 & 0xffffffff # 0x0ae08
    x1 = x22  # 0x0ae08
    x10 = x1 & 0xff  # 0x0ab8c
    x0 = hex_table[x10]

    x27 = x0
    x1 = x29[-0x60]
    x10 = x1 & 0xff
    x0 = hex_table[x10]

    x9 = x29[-0x70]  # 0x0afb0
    x9 = x9 & 0xff
    x12 = x29[-0x68]
    x10 = x27 & 0xff
    x8 = x12 & 0xff
    x8 = x8 << 0x18
    x8 = bfi(x8, x9, 0x8, 0x8)
    x8 = bfi(x8, x10, 0x10, 0x8)
    x9 = x8 >> 0xe
    x10 = x8 >> 0x16
    x11 = x8 >> 8
    x8 = bfi(x8, x0, 0, 8)
    # x8 = x8 + x0
    x12 = x12 >> 6
    x10 = bfi(x10, x8, 0xa, 0x20)
    x12 = bfi(x12, x8, 0x2, 0x20)
    x9 = bfi(x9, x8, 0x12, 0x20)
    x11 = bfi(x11, x8, 0x18, 0x20)
    x8 = x10 ^ x8
    x8 = x8 ^ x9
    x8 = x8 ^ x11
    x0 = x8 ^ x12
    x19 = int(result, 16) ^ x0

    return hex(x19)


def encrypt(args):
    x1, x2, x3, x4, x5 = args
    x29 = [0] * 1024
    x19 = int(x1, 16)  # 0x0abd4
    x9 = hex(int(x3, 16) ^ int(x2, 16))  # 0x0ac14
    x9 = int(x9, 16) ^ int(x4, 16)  # 0x0ac2c
    x21 = x9 ^ x5  # 0x0ac30
    x1 = x21
    x29[-60] = x1  # 0x0ad0c
    x8 = x21  # 0x0ad7c
    x21 = x8 >> 0x8
    x22 = x8 >> 0x10
    x9 = x8  # 0x0ad88
    x25 = x9 >> 0x18  # 0x0ad98
    x1 = x25
    x10 = x1 & 0xff
    x0 = hex_table[x10]

    x29[-68] = x0  # 0x0addc
    # x1 = x21 & 0xffffffff  # 0x0ade8
    x1 = x21  # 0x0ade8
    x10 = x1 & 0xff
    x0 = hex_table[x10]
    x29[-70] = x0
    # x1 = x22 & 0xffffffff # 0x0ae08
    x1 = x22  # 0x0ae08
    x10 = x1 & 0xff  # 0x0ab8c
    x0 = hex_table[x10]

    x27 = x0
    x1 = x29[-60]
    x10 = x1 & 0xff
    x0 = hex_table[x10]

    x9 = x29[-70]  # 0x0afb0
    x9 = x9 & 0xff
    x12 = x29[-68]
    x10 = x27 & 0xff
    x8 = x12 & 0xff
    x8 = x8 << 0x18
    x8 = bfi(x8, x9, 0x8, 0x8)
    x8 = bfi(x8, x10, 0x10, 0x8)
    x9 = x8 >> 0xe
    x10 = x8 >> 0x16
    x11 = x8 >> 8
    x8 = bfi(x8, x0, 0, 8)
    # x8 = x8 + x0
    x12 = x12 >> 6
    x10 = bfi(x10, x8, 0xa, 0x20)
    x12 = bfi(x12, x8, 0x2, 0x20)
    x9 = bfi(x9, x8, 0x12, 0x20)
    x11 = bfi(x11, x8, 0x18, 0x20)
    x8 = x10 ^ x8
    x8 = x8 ^ x9
    x8 = x8 ^ x11
    x0 = x8 ^ x12
    result = x0 ^ x19  # 0x0acc4
    all_encrypt_result_list.append(result)
    x1 = x2
    x2 = x3
    x3 = x4
    x4 = result
    all_x_regs.append([x1, x2, x3, hex(x4)])
    return [x1, x2, x3, hex(x4)]


def get_encrypt32_before():
    param_list = input2hex()
    for i in range(32):
        param_list.append(params_x5[i])
        param_list = encrypt(param_list)
    x8 = all_encrypt_result_list[-1]
    x9 = x8 >> 0x18
    encrypt_result_list[0] = x9 & 0xff
    encrypt_result_list[3] = x8 & 0xff
    x9 = x8 >> 0x8
    encrypt_result_list[1] = x9 & 0xff
    x8 = x8 >> 0x10
    encrypt_result_list[2] = x8 & 0xff
    x8 = all_encrypt_result_list[-2]
    x9 = x8 >> 0x18
    encrypt_result_list[4] = x9 & 0xff
    x9 = all_encrypt_result_list[-3]
    x11 = x8 >> 0x10
    x12 = x8 >> 0x8
    x13 = x9 >> 0x18
    encrypt_result_list[5] = x12 & 0xff
    encrypt_result_list[6] = x11 & 0xff
    encrypt_result_list[7] = x8 & 0xff
    encrypt_result_list[8] = x13 & 0xff
    x8 = x9 >> 0x8
    encrypt_result_list[11] = x9 & 0xff
    x9 = x9 >> 0x10
    encrypt_result_list[9] = x8 & 0xff
    encrypt_result_list[10] = x9 & 0xff
    x8 = all_encrypt_result_list[-4]
    x9 = x8 >> 0x18
    encrypt_result_list[12] = x9 & 0xff
    x9 = x8 >> 0x8
    encrypt_result_list[15] = x8 & 0xff
    x8 = x8 >> 0x10
    encrypt_result_list[13] = x9 & 0xff
    encrypt_result_list[14] = x8 & 0xff
    result = ""
    for i in encrypt_result_list[:16]:
        if len(hex(i)) == 3:
            result += '0' + hex(i).replace('0x', '')
            continue
        result += hex(i).replace('0x', '')
    print("前半段16字节: " + result)


def get_encrypt32_after():
    # 结果与异或表异或
    result_to_eor = [0] * 16
    for _, i in enumerate(encrypt_result_list[:16]):
        result_to_eor[_] = i ^ eor_table[_]

    # 开始构造第二轮参数
    args = []
    for i in range(0, len(result_to_eor), 4):
        args.append(hex((result_to_eor[i] << (4 * 6)) + (result_to_eor[i + 2] << (4 * 4))
                        + (result_to_eor[i + 1] << 4 * 2) + result_to_eor[i + 3]))

    for i in range(32):
        args.append(params_x5[i])
        args = encrypt(args)
    # bd5e181a9dcc8977a61d15c983800a1
    x8 = all_encrypt_result_list[-1]
    x9 = x8 >> 0x18
    encrypt_result_list[16] = x9 & 0xff
    x9 = x8 >> 0x8
    encrypt_result_list[19] = x8 & 0xff
    x8 = x8 >> 0x10
    encrypt_result_list[17] = x9 & 0xff
    encrypt_result_list[18] = x8 & 0xff

    x8 = all_encrypt_result_list[-2]
    x9 = x8 >> 0x18
    encrypt_result_list[20] = x9 & 0xff
    x9 = all_encrypt_result_list[-3]
    x11 = x8 >> 0x10
    x12 = x8 >> 0x8
    x13 = x9 >> 0x18
    encrypt_result_list[16+7] = x8 & 0xff
    encrypt_result_list[16+5] = x12 & 0xff
    encrypt_result_list[16+6] = x11 & 0xff
    encrypt_result_list[16+8] = x13 & 0xff

    x8 = x9 >> 0x8  # 0x0918c
    encrypt_result_list[16+11] = x9 & 0xff
    x9 = x9 >> 0x10
    encrypt_result_list[16+9] = x8 & 0xff
    encrypt_result_list[16+10] = x9 & 0xff

    x8 = all_encrypt_result_list[-4]
    x9 = x8 >> 0x18
    encrypt_result_list[16+12] = x9 & 0xff
    x9 = x8 >> 0x8
    encrypt_result_list[16+15] = x8 & 0xff
    x8 = x8 >> 0x10
    encrypt_result_list[16+13] = x9 & 0xff
    encrypt_result_list[16+14] = x8 & 0xff
    result = ""
    for i in encrypt_result_list[16:]:
        if len(hex(i)) == 3:
            result += '0' + hex(i).replace('0x', '')
            continue
        result += hex(i).replace('0x', '')
    print("后半段16字节: " + result)


def main():
    # 检查流程还原是否准确
    # encrypt_result_list_ = [0x6e, 0x66, 0x49, 0x30, 0x5b, 0xaf, 0x80, 0xc4, 0x9b, 0x1b, 0x06, 0x3c, 0x05, 0x00, 0xc8,
    #                        0x03]
    # result_to_eor_ = [0] * 16
    # for _, i in enumerate(encrypt_result_list_[:16]):
    #     result_to_eor_[_] = i ^ eor_table[_]
    #
    # args = []
    # for i in range(0, len(result_to_eor_), 4):
    #     args.append(hex((result_to_eor_[i] << (4 * 6)) + (result_to_eor_[i + 2] << (4 * 4))
    #                     + (result_to_eor_[i + 1] << 4 * 2) + result_to_eor_[i + 3]))
    # # print(args)
    # for _ in range(32):
    #     args.append(params_x5[_])
    #     args = encrypt(args)
    #     print(args)
    # args.append(params_x5[-1])
    # args_dict = {
    #     'x2': args[0],
    #     'x3': args[1],
    #     'x4': args[2],
    #     'result': args[3],
    #     'x5': params_x5[-1]
    # }
    # for _ in range(31, -1, -1):
    #     args_dict['x5'] = params_x5[_]
    #     print(args_dict)
    #     args = [args_dict['x2'], args_dict['x3'], args_dict['x4'], args_dict['result'], args_dict['x5']]
    #     args_dict['x2'] = decrypt(args)
    #     args_dict['x3'] = args[0]
    #     args_dict['x4'] = args[1]
    #     args_dict['result'] = args[2]
    # print(args_dict)

    # 我们知道前半段密文当前32轮加密完成之后再分别对加密的结果与“结果异或表”：
    # `0x0, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10`
    # 进行异或操作，生成后半段密文加密前的4个参数[0x6e597620, 0x4b90bfd4, 0x8b160b2c, 0x15d81013], 然后我们对这4个已知的参数与”结果异或表“进行异或
    # 0x6e ^ 0x6e = 0x00
    # 0x59 ^ 0x49 = 0x10
    # ...
    # 0x13 ^ 0x03 = 0x10
    # 然后得出真正的前半段生成的真正入参x1, x2, x3, x4;0x6e496630，0x05c80003，0x9b061b3c，0x5b80afc4

    final_result = hex(0x6e496630)
    final_list1 = hex(0x05c80003)
    final_list2 = hex(0x9b061b3c)
    final_list3 = hex(0x5b80afc4)
    args_dict = {
        'x2': final_list1,
        'x3': final_list2,
        'x4': final_list3,
        'result': final_result,
        'x5': params_x5[-1]
    }
    for _ in range(31, -1, -1):
        args_dict['x5'] = params_x5[_]
        # print(args_dict)
        args = [args_dict['x2'], args_dict['x3'], args_dict['x4'], args_dict['result'], args_dict['x5']]
        args_dict['x2'] = decrypt(args)
        args_dict['x3'] = args[0]
        args_dict['x4'] = args[1]
        args_dict['result'] = args[2]
    result = [hex(int(args_dict['x2'], 16) & 0xffffffff), hex(int(args_dict['x3'], 16) & 0xffffffff), hex(int(args_dict['x4'], 16) & 0xffffffff), hex(int(args_dict['result'], 16) & 0xffffffff)]
    print(result)

    # 后面按下面这个公式算即可
    # 0x59 ^ 0x2 = [
    # 0x7c ^ 0x2b = W
    # 0x51 ^ 0x26 = w
    # 0x7f ^ 0x28 = W
    # 59517c7f
    #
    # 0x64 ^ 0x4a = .
    # 0x06 ^ 0x33 = 5
    # 0x42 ^ 0x70 = 2
    # 0x45 ^ 0x15 = P
    # 64420645
    #
    # 0xc0 ^ 0xf0 = 0
    # 0x07 ^ 0x4d = J
    # 0x89 ^ 0xe0 = i
    # 0x56 ^ 0x65 = 3
    # c0890756
    #
    # 0xce ^ 0xe0 = .
    # 0x3c ^ 0x5f = c
    # 0x8e ^ 0xc0 = N
    # 0xc9 ^ 0x94 = ]
    # ce8e3cc9
    #
    # flag: [WwW.52P0Ji3.cN]


if __name__ == '__main__':
    """
    52破解新春题加密还原
    """
    # get_encrypt32_before()
    # get_encrypt32_after()
    # result = ''
    # for i in encrypt_result_list:
    #     if len(hex(i)) == 3:
    #         result += '0' + hex(i).replace('0x', '')
    #         continue
    #     result += hex(i).replace('0x', '')
    # print('最终结果: ' + result)

    main()

展开全文 >>

rust系列2-rust基础概念

2022-01-28

Rust变量与可变性

Rust变量默认是不可变的！

图 2
会报错的！

声明一个变量

跟js(es6)一样可采用let声明一个变量。但是如果想让一个变量可变，则需要在let后面在加上一个mut关键字使得变量可变。
总结:
声明不可变变量：let x;
声明可变变量: let mut x;

声明一个常量

常量和变量还是有着些许不同的。let声明的实际上还是一个变量，那要声明一个常量怎么做呢?
const x: 类型 = y;即可声明一个常量x，常量在声明阶段就需要确定常量的类型！

注意：

常量只能绑定在常量表达式，而不能将函数返回的返回值或者其他运行时计算出的结果绑定到常量上。
常量可以声明在任何作用域上。
常量命名为全大写（规范），且以_分隔单词，数值也可以用_分隔！如100_000提高可读性。

隐藏变量

新声明的变量可以覆盖掉旧的同名变量，即第一个变量被第二个变量隐藏（shadow）了。如：
图 3

隐藏机制与mut的区别

隐藏机制不同于将一个变量声明为mut，因为如果不是使用let关键字的情况下重新为这个变量赋值，则会导致编译错误。通过使用let，我们可以对这个值执行一系列的变换操作，并运行这个变量在操作完成后保持自己的不可变性。
由于重复使用let关键字会创建出新的变量，所以我们可以在复用变量名称的同时改变它的类型。

数据类型

Rust存在两种数据类型的子集：标量类型(scalar)和复合类型(compound)。Rust是静态语言，即要求它在编译程序的过程中需要知道所有变量的具体类型。有些时候编译器无法推导出变量的类型，这时候就需要显示添加类型标注。

标量类型

标量类型是单个值类型的统称。Rust中内建了4种基础的标量类型：

整数
浮点数
布尔值
字符

整数类型

整数类型通过前缀i和u分别来区分有符号和无符号。整数的长度范围为 - (2^n-1) ~ 2^n-1

长度	有符号	无符号
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
arch	isize	usize

有符号和无符号的选择

对于有符号的数值来说，需要有个数值来判断是否是正数，而无符号数则不需要，因此其表达正数的范围会比有符号更加大。

整数溢出

rust面对整数溢出发生时，分为两种情况：

当在debug环境下编译时，整数溢出会触发程序的panic，panic是rust用来描述因为错误而退出的情形。
当在release环境下编译时，panic不会被触发出来，作为替代，Rust会在溢出发生时执行二进制补码环绕。比如u8,256会变为0，257变为1。

浮点数类型

该类型分为f32和f64，分别占用32位和64位空间。默认的浮点数字面量的类型推导为f64。

布尔型

布尔类型值为：true, false两个。只占据单个字节的空间大小。

字符类型

char，用单引号（’’）指定。双引号(“”)是字符串。char占据4字节，是一个unicode标量值。

复合类型

该类型存在着两种内置类型：

元组（tuple）

可以将其他不同类型的多个值组合进一个复合类型中。元组还拥有一个固定的长度：你无法在声明结束后增加或减少其中的元素数量。

例：

let tup: (i32, f64, u8) = (500, 6.4, 1);

元组里的每一个元素其实并不强制要求类型注解！

元组元素提取

解构

1 2	let tup = (500, 6.4, 1); let (x, y, z) = tup;

通过索引并使用点号(.)来访问元组中的值

let x: (i32, f64, u8) = (500, 6.4, 1); 
    
let five_hundred = x.0; 
    
let six_point_four = x.1; 
    
let one = x.2;

索引从0开始。

数组

数组是一种可以存储多个相同元素类型的集合。但是和别的语言如：java、c/cpp相比，rust的数组一旦声明将不能随意更改大小，但是值是可以改的。

例：

let a = [1, 2, 3, 4, 5];

或者

let a: [i32; 5] = [1, 2, 3, 4, 5];

两者的差别在于第二种既写了元素类型又写了数组长度。

实际上数组还能写出一种特殊的写法

let a = [3; 5]

这一写法等价于let a = [3, 3, 3, 3, 3];

数组的访问

跟大部分别的语言一样array[index]即可访问到数组的某一个元素，index是从0开始。

动态数组(vector)类型

动态数组是一个类似于数组的集合结构，但它允许用户自由地调整数组长度。

函数

函数的定义

1
2
3

fn temp(param: type) -> type {
    ...
}

函数的返回值

函数倘若要返回则最后一条表达式不需要加;即可返回对应的值,倘若返回加上了;则会默认返回一个空元组。但是倘若声明了返回值的类型，则会发生报错。

如：

fn main() {
    let x = plus_one(5); 
 
    println!("The value of x is: {}", x); // The value of x is: 6
}

fn temp(x: i32) -> i32 {
    x + 1
}

特殊的赋值写法

rust有几种特别秀的赋值写法:

fn main() {
    let y = {
        let x = 3;
        x + 1
    };
}

以上这种写法y最终会变成4;注意结尾x+1后面没有加;假设我们加了;则该语句不会返回任何值。

循环

rust提供三种循环：

loop

示例：

fn main() { 
    let mut counter = 0; 
 
    let result = loop { 
        counter += 1;
        if counter == 10 { 
            break counter * 2;  // 返回counter * 2
        } 
    }; 
 
    println!("The result is {}", result); 
}

while

示例：

fn main() { 
    let a = [10, 20, 30, 40, 50]; 
    let mut index = 0; 
 
    while index < 5 { 
        println!("the value is: {}", a[index]);
        index = index + 1; 
    } 
}

for

示例1,遍历可迭代类型：

fn main() { 
    let a = [10, 20, 30, 40, 50]; 
 
    for element in a.iter() { 
        println!("the value is: {}", element); 
    } 
}

示例2,遍历指定范围:

fn main() { 
    for number in (1..4).rev() {
        println!("{}!", number); 
    } 
    println!("LIFTOFF!!!"); 
}

展开全文 >>

rust系列1-hello_world

2022-01-28

为什么要学习rust

我个人的观点，rust将要被加进到aosp的内核里，意味着以后想要更好的进行逆向工作你需要学习rust,万一哪天native也支持rust可玩性将大大增加了，当然倒霉的就是逆向人员了\捂脸

Hello World

1
2
3

fn main() {
    println!("Hello World!");
}

我们看看这段代码结构。
fn用于定义一个函数，println!是不是可以理解为函数调用呢？错！println加上!实际上是说调用了一个宏，宏的名字叫做println，;是否是必要的呢？*;并不是必要的，加不加都可以，但是加上可以更好的表达，当前的表达式已经结束了。*与C/Cpp一样，main函数是必须存在的，用于让系统在运行程序时在main函数里执行具体的程序逻辑。

如何运行一个rust程序

rustc xx.rc编译好代码后生成可执行文件，在windows生成.exe，而linux生成.sh可执行文件，按各个系统的启动方式启动编译好的文件即可。

rust cargo

Cargo 是rust工具链中内置的构建系统及包管理器。它可以处理众多诸如构建代码、下载编译依赖库等琐碎但重要的任务，所以绝大部分用户都采取Cargo来管理rust项目。

cargo创建项目

cargo new project_name即可创建一个cargo项目。

项目结构

图 1

Cargo采用TOML作为标准配置格式。package是一个区域标签，表明接下来的语句会被用于配置当前的程序包。dependencies同样是一个区域标签，它表明随后的区域会被用来声明项目的依赖。在Rust中，代码的集合被称作create。

src目录用于保存项目的源代码，而根目录用于存放诸如README、许可声明、配置文件等与源代码无关的文件。

使用Cargo构建和运行项目

cargo build命令用来编译整个项目.会在/target/debug目录下生成一个可执行文件
cargo run命令用于运行上一步生成的可执行文件。

cargo check命令用于快速检查当前代码是否可以通过编译，而不需要花费额外时间去真正生成可执行程序。

当正式发版时可通过cargo build --release生成优化模式下的可执行程序,其生成的可执行文件在/target/release目录下，这种优化模式会以更长的编译时间来优化代码，使得代码能拥有更好的运行时性能。

展开全文 >>

rust系列1

2022-01-28

展开全文 >>

frida-dumps原理

通过文件格式来进行校验

Process.enumerateRanges('r--').forEach(function (range) {
    if (
      range.size >= 0x60
      && range.base.readCString(4) != "dex\n"
      && range.base.add(0x20).readInt() <= range.size //file_size
      && range.base.add(0x34).readInt() < range.size //map_off
      && range.base.add(0x3C).readInt() == 112 //string_id_off
    ) {
      result.push({"addr": range.base,"size": range.base.add(0x20).readInt()});
}

这里总共有5个条件：

该段内存长度大于等于0x60,因为Dex文件头的大小是0x70
从这段内存中开始的地方读4个字节的字符串，当不等于”dex\n”时再匹配下一个条件。
读Dex文件头+0x20偏移位置，该位置是file_size。
读Dex文件头+0x34偏移位置，该位置是map_off,一般情况下map段都是在Dex文件的最末尾。
读取Dex文件头+0x3C偏移位置，该位置是string_ids_off该段一般紧随于Dex文件头后面，而Dex文件头的大小是0x70即112。

后续葫芦娃对frida-dumps进行的迭代

由于Dex Header除了magic即dex\n可以抹掉外，还有file_size也就是文件大小也可以抹掉。

其改进的方案：
通过map_off找到Dex的map_list，通过解析它得到类型为TYPE_MAP_LIST的条目，该条目里的索引值与map_off一致，通过校验这两个地方实现更加精确的验证方案。

校验map_off段

function verify_by_maps(dexptr, mapsptr) {
    var maps_offset = dexptr.add(0x34).readUInt();
    var maps_size = mapsptr.readUInt();
    for (var i = 0; i < maps_size; i++) {
        var item_type = mapsptr.add(4 + i * 0xC).readU16();
        if (item_type === 4096) { //4096 == TYPE_MAP_LIST
            var item_offset = mapsptr.add(4 + i * 0xC + 8).readUInt();
            if (maps_offset === item_offset) {
                return true;
            }
        }
    }
    return false;
}

计算map_list结束的位置：

function get_maps_end(maps, range_base, range_end) {
    var maps_size = maps.readUInt();
    if (maps_size < 2 || maps_size > 50) {
        return null;
    }
    var maps_end = maps.add(maps_size * 0xC + 4);
    if (maps_end < range_base || maps_end > range_end) {
        return null;
    }

    return maps_end;
}

最后通过减掉起始地址，就可以得到真正的文件大小了:

function get_dex_real_size(dexptr, range_base, range_end) {
    var dex_size = dexptr.add(0x20).readUInt();

    var maps_address = get_maps_address(dexptr, range_base, range_end);
    if (!maps_address) {
        return dex_size;
    }

    var maps_end = get_maps_end(maps_address, range_base, range_end);
    if (!maps_end) {
        return dex_size;
    }

    return maps_end - dexptr
}

展开全文 >>

Arm64学习笔记

本文并不会对啥指令都一一记录，只是会记录一些关键点，仅供参考。

加载指令

LDR和STR

ldr和str指令分别对应着
从内存地址当中加载数据到寄存器当中。从寄存器中捞出数据存放到内存当中。

指令变种

LDR寻址模式

地址偏移模式

地址偏移模式常常使用寄存器的值来表示一个地址，或者基于寄存器的值做一些偏移来计算出内存地址，并且把这个内存地址的值加载到通用寄存器中。偏移量可以是正数也可以是负数。

格式:LDR Xd, [Xn, #offset]

变基模式

存在两种形式：

前变基模式
例如：

1	LDR X1, [X2, #8]! // X2的地址先+8然后再取到X2此时的内存地址所保存的数据加载到X1，注意X2的地址先变成为X2=X2+8

后变基模式
例如
LDR X1, [X2], #8 // 取X2的地址对应的数据加载到X1寄存器，然后X2再+8

LDR伪指令

指令：每一条指令对应一种CPU操作。

伪指令：对编译器发出的命令，它是在对源程序汇编期间由汇编程序处理的操作，它们可以完成如处理器的选择、定义程序模式、定义数据、分配存储区、指示程序结束等功能，可以理解成几条指令的集合。（LDR伪指令没有立即数范围限制）
例如：LDR X0, =0x11111111111111111111111111

MOV和MOVZ

MOV指令是最简单和原始的加载指令
只能加载两种类型

16位立即数
16位立即数左移16、32、48位

MOVZ指令实际上等同于MOV指令
MOV , # 等于 MOVZ , #, LSL #

多字节的加载和存储LDP和STP指令

在A32指令集中提供LDM和STM指令来实现多字节内存加载和存储，而A64指令集不再提供LDM和STM指令，而采用LDP和STP指令。LDP和STP可以一条指令加载和存储16个字节，效率提高一倍。
示例：
LDP X3, X7, [X0] // 以X0的值为地址，加载此地址的值到X3寄存器，以X0+8为地址，加载此地址的值到X7寄存器。
STP X1, X2, [X4] // 存储X1的值到地址为X4的内存中，然后存储X2的值到地址为X4+8的内存中。

移位和算术

条件状态码

条件状态码：在pstate处理器状态中4个条件操作码NCZV
条件标志域：
条件标志位|描述
–|:–:|
N|负数标志（上一次运算结果为负数）
Z|零结果标志（上一次运算结果为0）
C|无符号溢出|
V|有符号溢出|

ADD加法指令

普通的加法指令
1. 使用寄存器的加法
2. 使用立即数的加法
3. 使用移位操作的加法
adds指令，该指令会影响条件标志位，主要影响C标志位（无符号数溢出）

SUB减法指令

普通的减法指令SUB
SUBS指令——影响条件标志位（C标志位）

带进位的加法指令

格式：ADC <Xd>, <Xn>, <Xm>

adc指令，在做加法运算的时候，结果还会加上C标志位上的值（0或1）即Rd = Rn + Rm + C

带进位的减法指令

格式： SBC <Xd>, <Xn>, <Xm>

sbc指令, Rd = Rn - Rm - 1 + C

CMP比较指令

XZR寄存器、wzr寄存器

两者都是零寄存器，xzr和wzr值总是为零；XZR、wzr寄存器是访问零值操作数而无需加载和占用实际寄存器

比较两个数的大小，内部使用subs指令来实现，影响标志位C。该指令等同于SUBZ XZR, <Xn>, #<imm>。
例子：

1	CMP X1, X2

当X1 >= X2 时， C = 1
当X1 < X2 时， C = 0

比如3 >= 1,实际上就为3 + (-1),即3 + 0xfffffffffffffff,再加哪怕是1都溢出了所以c=1

所以我就想到了如何来判断条件是否符合可以如下：

1 2	CMP X1, X2 ADC X0, XZR, XZR // XZR恒为0,而ADC的值实际上为Rd = Rn + Rm + C,则此时可以判断X0的值是否为0，为0则X2 > X1,否则X1 >= X2

移位操作

LSL: 逻辑左移指令
LSR: 逻辑右移指令
ASR: 算术右移
ROR: 循环右移

注意：

逻辑左移 = 算术左移， arm64没有单独设置一个算术左移的指令。
逻辑右移和算术右移需要考虑符号问题。

例子：
1010101010，右移：

逻辑右移一位： 0101010101 （最高位永远补0）
算术右移一位： 1101010101 （算术右移，左边添加的数和符号相关，这里的符号看最高位，1则补1）

按位与操作

AND: 与操作
ANDS: 带条件标志位的与操作，影响Z标志位

AND Xd, Xn
结果为Xd = Xd & Xn

按位或操作

ORR: 或操作
EOR: 异或操作

按位或操作
ORR Xd, Xn
指令结果: Xd = Xd | Xn

按位异或操作
EOR Xd, Xn

指令结果: Xd = Xd ^ Xn

异或操作规律

0异或任何数都为任何数,如:0 ^ 0 = 0; 0 ^ 1 = 1;
1异或任何数都为任何数取反,如:1 ^ 0 = 1; 1 ^ 1 = 0;
任何数异或自己相当于把自己置0。

异或操作的几个小妙用

使得某些特定位翻转。
如：
想把10101010的【第1(即0)和第2位（即1），因为是小端序】翻转，则可以将其与10101011进行按位异或运算。
10101010 ^ 10101011 = 10101001
交换两个数
在汇编里让变量设置为0
EOR X0, X0
判断两个是否相等
(a ^ b) == 0

位段操作

插入操作

bfi: 位段（bitfield）插入操作

格式：BFI Xd, Xn, #lsb, #width
释义：用Xn中的Bit[0:width]替换Xd中的从lsb开始的width位，Xd其他位不变。

提取操作

UBFX:无符号数的位段提取指令
SBFX:有符号数的位段提取指令

格式两者相同：
SBFX Xd, Xn, #lsb, #width
释义：
从Xn寄存器提取位段，位段从第lsb位开始，位宽为width，然后结果写入到Xd寄存器最低比特位中。

位域提取指令ubfx的妙用

直接提取寄存器的某些域

bfxil:

语法：BFXIL Xd, Xn, #lsb, #width
释义：从Xn寄存器的第lsb位开始，提取width位，替换Xd寄存器的最低width位，剩余高位不改变。

零计数指令CLZ

计算最高位为1的比特位前面有几个0

格式：CLZ, Xd, Xn

例子
X1 = 0xffffffffffffffff
CLZ X2, X1
结果为4

注意：

UBFX:其他比特位是填充0
SBFX:其他比特位全是填充f

比较与跳转指令

CMP: 比较两个数
CMN: 负向比较（把一个数跟另外一个数的二进制补码相比较）

CMP X1, X2 => x1 - x2
CMN X1, X2 => x1 + x2

条件操作后缀

图 1

条件选择指令

CSEL: 条件选择指令
CSET: 条件置位指令
CSINC: 条件选择并增加指令

条件选择指令常搭配CMP指令使用

CSEL Xd, Xn, Xm, COND
指令结果：
Xd = 如果cond为真，返回Xn, 否则返回Xm

CSET Xd, cond
指令结果：
Xd = 如果cond为真，返回1否则返回0

CSINC Xd, Xn, Xm, cond

指令结果：
Xd = 如果cond为真，返回Xn,否则返回(Xm + 1)

例子
图 1
上图的意思，先比较X0是不是等于0，等于0则返回X1+2, 否则返回X1-1

基本跳转指令

无条件的跳转指令

b:跳转指令，无条件的跳转指令，不返回。
跳转范围：PC +/- 128MB

一般用于arm跳转到c/cpp代码

有条件的跳转指令

b.cnd:有条件的跳转指令，不返回。
cnd为条件操作后缀
跳转范围：PC+/-1MB

这个指令实际上是b.cc这类代码的抽象指令，b.条件的意思
跳转范围较小，一般在同一个函数范围内进行使用。

bx指令

bx:跳转到寄存器指定的地址处，不返回。
跳转范围手册没写，估计能跳转的范围很大。

带返回地址的跳转指令

bl中的l代表的是link,也就是链接的地址，也就是arm32当中的lr寄存器里的地址，arm64中的x30里的地址

bl:带返回地址（PC+4=>X30,即返回的地址保存在X30里），适用于call子函数
返回地址:保存到X30中，=>保存的是父函数的PC+4，PC+4实际上就是父函数调用子函数之后并返回之后的下一条指令的地址。
跳转范围:PC+/-128MB

存在的陷阱：bl指令：用于call子函数。它把返回地址写入到x30寄存器，返回地址为PC+4。在一个函数里调用bl来call子函数，有可能会把父函数的lr寄存器给冲走，然后父函数的ret返回就跑飞了。

解决方法：

在遇到嵌套调用bl的时候，需要在父函数里，先把x30寄存器保存到一个临时寄存器里（x30等价为arm32里的lr寄存器）。
在父函数ret返回时，先从临时寄存器中恢复x30寄存器的值，再ret返回。

blx指令：

blx:跳转到寄存器指定的地址处，可以返回。
返回地址：保存到X30中，=>保存的是父函数的PC+4

比较并跳转指令

cbz:比较xt寄存器是否为0，为0则跳转到label标签处，跳转范围为+/-1MB
cbnz:比较xt寄存器是否为0，不为0则跳转到label标签处，跳转范围为+/-1MB
tbz:测试寄存器中某个比特位是否为0，为0则跳转，跳转范围为+/-32KB
tbnz:测试寄存器中某个比特位是否为0，不为0则跳转，跳转范围为+/-32KB

不返回的意思

不返回的意思是跳转到子函数之后不会再跳转回原调用处。

PC相对地址加载指令

adr指令：加载PC相对地址的label的地址，范围为+/-1MB
adrp指令：加载PC相对地址的label的地址，它只加载label所属的4kb对齐的地址，范围为+/-4GB

例子

adr x0, label // 读取label的地址，相对PC的

adrp x0, lable // 读取label所在的4kb的地址，相对pc的

陷阱与坑：adrp和ldr究竟有什么不同

adrp读取的是物理地址，ldr读取的是虚拟地址（链接地址），ldr读取的是虚拟空间全局的，而adrp只能读取最大4GB

返回指令

ret指令

ret指令: 从子函数返回。通常X30寄存器保存了返回地址。

eret指令

eret: 从当前的异常模式返回。
通常可以实现模式的切换，例如EL1切换到EL0。它会从SPSR中恢复PSTATE,从ELR中获取跳转地址，并返回到该地址。如果SPSR保存的是EL1则会切回到EL1

特殊的寄存器

XZR零寄存器

XZR寄存器的值恒为0

NZCV寄存器

图 1
保存条件标志，该寄存器可读可写。

内存独占加载和存储指令

往内存地址标记独占，别的寄存器将不能访问，跟加锁线程的意思相仿。Linux内核常常用来实现atomic的访问，例如atomic_write和atomic_set_bit。spinlock机制可以简单地使用ldxr和stxr指令来实现。
ldxr: 内存独占加载指令。从内存中以独占exclusive方式加载内存的地址到通用寄存器。

stxr: 内存独占存储指令。

ldxr是在加载内存的时候通过独占监视器来监视这个内存的访问，监视器会把这个内存地址标记为独占访问，保证其独占的方式来访问。

stxr是与ldxr是一般是成对出现的。是有条件地存储内存,刚才ldxr标记的内存地址被独占的方式存储了。stxr存储只有当独占监视器还处于独占状态才会成功。stxr存储成功后，状态编程open状态。

ldxr和stxr的指令格式

ldxr xd, [xn | sp], 独占的读取xn或者sp地址的内容到xd寄存器
stxr wd, xt, [xn | sp], 独占地方式把xt的内容写入到xn或者sp地址。Wd为0表示成功，Wd为1表示失败。

Arm的独占监视器

Arm里有两个独占监视器。

本地监视器：用来监视non-sharable的地址访问。
全局监视器:用来监视sharable的地址访问。
对于sharable的地址，本地监视器和全局监视器都会检测。

异常处理指令

SVC: 系统调用指令；允许应用程序通过SVC指令来自陷到操作系统里，通常会进入到EL1（内核）异常等级。
格式：SVC #imm

HVC: 虚拟化系统调用指令；允许主机操作系统通过HVC指令自陷到虚拟机管理程序（Hypervisor）中，通常会进入到EL2异常等级。
格式：HVC #imm

SMC: 安全监控系统调用指令；允许主机操作系统或虚拟机管理程序通过SMC指令自陷到安全监管（Secure Monitor）中，通常会进入到EL3异常等级。
格式: SMC #imm

系统寄存器访问指令

MRS: 读取系统寄存器到通用寄存器
MSR: 更新系统寄存器

内存屏障指令

数据存储屏障（Data Memory Barrier, DMV）指令

保证的是内存屏障前后的内存访问指令的执行顺序，不会保证内存访问指令在内存屏障指令之前必须完成。

数据同步屏障（Data synchronization Barrier, DSB）指令

任何指令都要等待DSB前面的存储访问完成

指令同步屏障（Instruction synchronization Barrier, ISB）指令

冲洗流水线（Flush Pipeline）和预取buffers后，才会从高速缓存或者内存中预期ISB指令之后的指令，该指令用于保证上下文切换、更改msid等。

对齐伪指令

.align对齐，填充数据来实现对齐。可填充0或者nop指令。

告诉汇编程序，align后面的汇编必须能被2^n整除的地址开始分配
Arm64系统中，第一个参数表示2^n大小。

数据定义伪指令

.byte: 把8位数当成数据插入到汇编中
.hword:把16位数当成数据插入到汇编中
.long和.int: 把32位数当成数据插入到汇编中
.quad:把64位数当成数据插入到汇编中
.float:把浮点数当成数据插入到汇编中
.ascii “string” -> 把string当做数据插入到汇编中，ascii伪操作定义的字符串需要自行添加到结尾字符’\0’。
.asciz “string” -> 类似ascii,在string后面插入一个结尾字符’\0’。

.rept: 重复定义
例如:
.rept 3 .long 0
.long 0 => .long 0
.endr .long 0

.equ：赋值操作
.set：赋值操作

上面两条指令是相等的。
例子:
.equ abcd, 0x45 // 让abcd等于0x45

函数相关伪操作

.global: 定义一个全局的符号
.include: 引用头文件
.if , .else , .endif 控制语句

.if语句

.ifdef symbol: 判断symbol是否定义
.ifndef symbol: 判断symbol是否没有定义
.ifc string1, string2: 字符串string1和string2是否相等
.ifeq expression: 判断expression的值是否为0
.ifeqs string1, string2: 等同于.ifc
.ifge expression: 判断expression的值是否大于等于0
.ifle expression: 判断expression的值是否小于等于0
.ifne expression: 判断expression的值是否不为0

与段相关的伪操作

.section:

表示接下来的汇编会链接到哪个段里，例如代码段，数据段等
每一个段以段名开始，以下一个段名或文件结尾为结束

.section name, “flags”
后面可以添加flags, 表示段的属性。

.pushsection: 把下面的代码push到指定的section中
.popsection: 结束push

上面两者是成对使用，仅仅是把pushsection和popsection的圈出来的代码加入到指定section中，其他代码还是在原来的section

宏（难点）

.macro和.endm组成一个宏
.macro后面跟着的是宏的名称，在后面是宏的参数
在宏里使用参数，需要添加前缀”",例如：
.macro plus1 p, p1
定义了一个名为plus1的宏，有两个参数p和p1。在宏里使用参数需要前缀，”\p”表示第一个参数，”\p1”表示第二个参数
宏参数定义的时候可以设置一个初始化值,例如：
.macro reserve_str p1=0 p2
第一个参数p1有一个初始化值0,这时候可以使用reserve_str a,b或者reserve_str, b来调用这个宏

示例：

生成一个以参数l为名称的符号

1
2
3

.macro labal l
\l :
.endm

或

.altmacro
.macro label l
l&:
.endm

把两个参数以及”.”连接在一起

1
2
3

.macro opcode base length
    \base\().\length
.endm

链接器

基本概念

输入段(input section)

gcc编译之后产生的.o文件，这些.o文件包含了代码段(.text)、数据段(.data)、.bss段以及一些自定义数据段，这些段统称输入段。

输出段(output section)

通过链接程序把编译生成的.o文件进行链接成最终成一个可执行文件，这个可执行文件也包含了代码段、数据段、.bss段等段，这些段统称为输出段

每个段包括name和链接大小。

段的属性：

loadable: 运行时会加载这些段的内容到内存中。

allocatable: 运行时不会加载段的内容。

段的地址：

VMA (virtual memory address): 虚拟地址，就是运行时的运行地址。
LMA (load memory address): 加载地址

通常ROM的地址为加载地址，而RAM的地址为VMA

ld命令（链接器知识）

linux中采用gnu的aarch64-linux-gnu-ld这个程序进行链接器程序的调用，搭配参数使用

常用参数

-T 指定链接脚本
-Map 输出一个符号表文件
-o 输出最终可执行二进制文件

链接脚本命令

ENTRY(symbol): 设置程序的入口函数。

链接程序有如下几种方式来确定入口点：
- 使用-e参数
- 使用ENTRY(symbol)
- 在.text的最开始的地方
- 0地址

例如：ENTRY(_text)指定本链接脚本的入口函数为”_text”

INCLUDE filename

引入filename的链接脚本

OUTPUT filename

输出二进制文件，类似在命令行里使用”-o filename”

OUTPUT_FORMAT(bfd)

输出BFD格式

OUTPUT_ARCH(bfdarch)

输出处理器体系结构格式，例如:OUTPUT_ARCH(aarch64),用于指定本链接脚本针对arm64来进行链接

符号赋值

符号也可以像c语言一样赋值

例如：

symbol = expression;

symbol += expression;

symbol -= expression;

symbol *= expression;

symbol /= expression;

symbol <<= expression;

symbol >>= expression;

symbol &= expression;

symbol |= expression;

“.” 表示location counter, 表示当前位置

例子：

floating_point = 0;  // 给符号floating_point赋值为0
SECTIONS
{
    .text:
    {
        *(.text)
        _etext = .;     // _etext赋值为当前位置（当前位置为代码段结束的地方）
    }

    _bdata = (. + 3) & ~ 3;     // 设置bdata的起始地址，当前位置的下一个与4字节对齐地方
    .data : { *(.data) }
}

符号的引用

高级语言（C语言）常常需要引用链接脚本定义的符号
在C语言里，定义一个变量并初始化变量。例如： int foo = 100;
- 编译器会在符号表中定义了一个符号foo
- 编译器会在内存中为符号foo存储100
链接脚本与C语言定义符号存在差异。在链接脚本中定义一个变量：
- 链接器仅仅在符号表里定义这个符号，没有分配内存来存储变量的值。
- 访问链接脚本定义的变量访问的是变量的地址，不能访问变量的值。

示例：

链接脚本：                                     C语言：
start_of_ROM = .ROM                           extern char start_of_ROM[], end_of_ROM[], start_of_FLASH[];   // 引用链接脚本的符号
end_of_ROM = .ROM + sizeof(.ROM);   ==>       memcpy(start_of_FLASH, start_of_ROM, end_of_ROM, end_of_ROM - start_of_ROM);  // 只能通过memcpy方式来获取地址里的内容
start_of_FLASH = .FLASH;

可以在每个段中设置一些符号，以方便C语言访问每个段的起始地址和结束地址。示例：

SECTIONS
{
    start_of_text = . ;
    .text: { *(.text) } 
    end_of_text = . ;
    ....
}

上面这一段链接脚本通过设置start_of_text和end_of_text两个符号就可以通过这两个符号简单算出.text段的大小，以及很简单的获取.text段的起始地址和结束地址

SECTIONS命令

SECTIONS命令：告诉链接器如何把输入段（input sections）映射到输出段(output sections)，以及如何在内存中摆放这些输出段。

格式：

SECTIONS
{
    sections-command
}

输出section的描述符

section [address] [(type)]: // section段的名字 address（VMA，运行地址） type输出段的属性
    [AT(lma)]   // AT(lma)，加载地址
    [ALIGN(section_align) | ALIGN_WITH_INPUT]   // 
    [SUBALIGN(subsection_align)]                // 这两行注释主要是笔记作者告诉读者，这两行为对齐要求
    [constraint]
    {
        output-section-command  // 描述输入段如何映射到输出段的
    } [>region] [AT>lma_region] [:phdr :phdr ...] [=fileexp] [,]
        // 指定到特定的内存区域（前提是已经使用memory命令来申请了这些内存区域）； phdr这一部分是指定到特定的program segment

LMA加载地址

每个段有VMA（虚拟地址，运行地址）以及LMA(加载地址)
在输出段描述符中使用”AT”来指定LMA
如果没有通过”AT”来指定LMA,通常LMA=VMA
构建一个基于ROM的映像文件常常会设置输出段的虚拟地址和加载地址不一致

示例：

SECTIONS
{
    .text 0x1000:{*(.text) _etext=.;}
    .mdata 0x2000:
        AT(ADDR(.text) + SIZEOF(.text))
        {
            _data = .;
            *(.data);
            _edata=.;
        }
    .bss 0x3000:
    {
        _bstart=.;
        *(.bss)*(COMMON);
        _bend = .;
    }
}

text段的虚拟地址和加载地址为0x1000（即.text段的VMA=LMA）,mdata段的虚拟地址设置为0x2000，但是通过AT符号指定了加载地址是在text段的结束地址(即.mdata段的VMA!=LMA)，_data指定了data段的虚拟地址为0x2000。bss段的虚拟地址是在0x3000.

常见的内建函数(builtin functions)

ADDR(section): 返回前面已经定义过的段的VMA地址
ALIGN(n): 返回下一个与n字节对齐的地址，它是基于当前的位置（location counter）来计算对齐地址的。（n是n个字节，不是2^n个字节）
示例：

SECTIONS {
    .data   ALIGN(0x2000): {    // data段会在下一个与0x2000对齐的地址上
        *(.data)
        variable = ALIGN(0x8000);   // 定义一个variable的变量，这个变量是在下一个与0x8000对齐的地址上
    }
}

SIZEOF(section): 返回一个段的大小
MAX(exp1, exp2) / MIN(exp1, exp2): 返回两个表达式的最大值回最小值

内嵌汇编

基础内嵌汇编 asm asm-qualifiers(AssemblerInstructions)

格式

asm关键字：表明这是一个GNU扩展
修饰词（qualifiers）
- volatile: 在基础内嵌汇编中通常不需要这个修饰词。用来关闭gcc指令优化
- inline: 内联，asm汇编的代码会尽可能小
- goto: 在内嵌汇编里会跳转到C语言的标签里

asm volatile(
    指令部
    : 输出部
    : 输入部
    : 损坏部);

指令部：
在内嵌汇编代码中，使用%0对应输出部和输入部的第一个参数，使用%1表示第二个参数。

输出部：用于描述在指令部中可以被修改的C语言变量以及约束条件

- 每个输出约束(constraint)通常以"="号开头，接着的字母表示对操作数类型的说明，然后是关于变量结合的约束。
"=/+" + 约束修饰符 + 变量

- 输出部通常使用"="或者"+"作为输出约束，其中"="表示被**修饰的操作数只具有可写属性**，"+"表示被修饰的操作数**只具有可读可写属性**

- 输出部可以是空的

输入部：用来描述在指令部只能被读取访问的C语言变量以及约束条件

- 输入部描述的参数是只有只读属性，不要试图去修改输入部的参数的内容，因为GCC编译器假定，输入部的参数的内容在内嵌汇编之前和之后都是一致的。

- 在输入部中不能使用"="或者"+"约束条件，否则编译器会报错。

- 输入部可以是空的。

损坏部(Clobbers)：

“memory”告诉GCC编译器内联汇编指令改变了内存中的值，强迫编译器在执行该汇编代码前存储所有缓存的值，在执行完汇编代码之后重新加载该值，目的是防止编译乱序。
“cc”表示内嵌汇编代码修改了状态寄存器相关的标志位。

汇编代码块

GCC汇编器把内嵌汇编当成一个字符串
GCC编译器不会去解析和分析内嵌汇编。
多条汇编指令，需要使用”\n\t”来换行
GCC的优化器，可以移动汇编指令的前后位置。如果你需要保持汇编指令的顺序，最后使用多个内嵌汇编的方式。

GCC内联操作符和修饰符

= : 被修饰的操作数只写

+ : 被修饰的操作数具有可读可写的属性

& : 被修饰的操作数只能作为输出

输出部和输入部的约束修饰符 - 通用

m: 内存变量
o: 操作数为内存变量，但是其寻址方式是偏移量类型
V: 操作数为内存变量，但寻址方式不是偏移量类型
r: 通用寄存器
i: 立即数
n: 立即数
p: 操作数是一个合法的内存地址（指针）

gcc内联汇编示例：

static inline unsigned long array_index_mask_nospec(unsigned long idex, unsigned long sz) 
{
    unsigned long mask;

    asm volatile (
        "cmp %1, %2\n"
        "sbc %0, xzr, xzr\n"
        : "=r" (mask)  
        : "r" (idx), "Ir" (sz)
        : "cc"
    );
    csdb();
    return mask; 
}

上图中r表示寄存器，%n是从输出部开始从0开始算起， I是约束修饰符的一种，下面有介绍

通过汇编符号名字来替代以前前缀%

static void my_memcpy_asm_test(unsigned long src, unsigned long dst, unsigned long counter)
{
	unsigned long temp;
	unsigned long end = src + counter;
	asm volatile(
			"1:\n"
			"ldr %[temp], [%[src]], #8\n"
			"str %[temp], [%[dst]], #8\n"
			"cmp %[src], %[end]\n"
			"b.cc 1b"
			: [src] "+r" (src), [dst] "+r" (dst), [temp] "+r" (temp)
			: [end] "r" (end)
			: "memory"
	);
}

输出部和输入部的约束修饰符 - ARM64

k: 栈指针寄存器（SP）

w: 浮点寄存器、SIMD、SVE寄存器

Up1: 使用p0~p7其中一个SVE寄存器

Upa: 使用p0~p15当中任意一个SVE寄存器

I: 整数常量，常常用于add指令

J: 整数常量，常常用于sub指令

K: 整数常量，常常用于32位逻辑指令

L: 整数常量，常常用于64位逻辑指令

M: 整数常量，常常用于32位的mov指令

N: 整数常量，常常用于64位的mov指令

S：绝对符号地址或标签引用

Y: 浮点常数，其值为0

Z：整数常数，其值为0

Ush: 在4GB内的PC相对地址的符号中的高地址部分

Q: 表示没有使用偏移量的单一寄存器的内存地址

Ump: 一个试用于SI、DI、SF和DF模式下的加载存储指令的内存地址

异常处理

arm64的异常等级

EL0: 非特权模式，例如应用程序
EL1: 特权模式，例如OS内核
EL2: 虚拟化监控程序，例如hypervisor、kvm
EL3: 安全模式, 例如secure monitor

图 1

arm64异常处理的一些基本概念

Talking an exception: 正在处理一个异常
Returning from an exception: 从一个异常中返回
Exception levels: 异常等级
Pricise exception: 精准异常
Synchronous and asynchronous exception: 同步异常与异步异常

当异常发生时需要从低的EL切换到高的EL,例如EL0切EL1;当El1处理完成之后通过eret返回到el0。

同步异常与异步异常

同步异常

处理器需要等待异常处理的结果然后在继续处理下一条指令的异常处理方式就是同步异常。比如要访问一个数据，但是数据还没有准备好，此时会发生数据中止异常，此时处理器会返回发生异常的地址在哪里，此时操作系统里的异常处理的函数就要对其进行修复，比如mmu没有映射，触发异常，然后嵌入到操作系统的确认异常里面把地址进行修复，重新进行映射，然后application就可以访问该地址继而继续运行。

同步异常大致分为：

系统调用： svc、hvc、smc等
MMU引发的异常
SP和PC对齐检查
未分配的指令

异步异常

操作系统是无法感知接下来将要发生异常，所以异常处理对于异步异常返回的地址是不能说明是因为哪一条指令导致异常的发生。通常，异步异常指的是中断
中断发生时，处理器正在执行的指令和中断并没有关系，它们直接不存在依赖关系。

异步异常大致分为：

IRQ中断
FIQ中断
SError

异常的入口

当异常发生时，CPU硬件做了什么事：

PSTATE保持到SPSR_ELx。当异常发生在EL0则“x”就为1,因为异常会在el1里进行处理。
返回地址保持ELR_ELx,x同上
PSTATE寄存器里的DAIF域都设置为1，相当于把调试异常、系统错误（SError）、IRQ中断以及FIQ中断都关闭了。
更新了ESR_ELx寄存器（该寄存器会告诉操作系统软件捕获到什么异常，包含同步异常的原因），里面包含了同步异常发生的原因
SP执行SP_ELx
切换到对应的EL,然后跳转到异常向量表里执行。

当异常发生后，操作系统需要做哪些事情？
根据异常发生的类型，跳转到合适的异常向量表。异常向量表的每个表项会保存一个异常处理的跳转函数，然后跳转到恰当的异常处理函数并处理异常。

异常的返回

操作系统执行一条eret语句

从ELR_ELx寄存器中恢复PC指针
从SPSR_ELx寄存器恢复处理器的状态

异常返回地址

返回地址两个寄存器
- X30: 子函数的返回地址。使用ret指令来返回
- ELR_ELx: 异常返回地址。使用eret指令来返回
ELR_ELx寄存器保存了异常返回地址：
1. 对于异步异常，它的返回地址是中断发生时的下一条指令，或者没有执行的第一条指令。
2. 对于不是system call的同步异常，返回的是触发同步异常的那一条指令。
3. 对于system call,它是返回svc指令的下一条指令。

异常处理的路由

异常发生的时候，异常处理可以在当前EL也可以在更高的EL。
EL0不能用来处理异常
同步异常是可以在当前的EL里处理的，比如在EL1里发生了同步异常
对于异步异常，可以路由到EL1，EL2,EL3处理，需要配置HCR以及SCR相关寄存器。

栈的选择

每个异常等级EL都有对应栈指针寄存器SP
- SP_EL0, SP_EL1, SP_EL2, SP_EL3
栈必须16字节对齐。硬件可以检测栈指针是否对齐。
当异常发生时，并跳转到目标异常等级时，硬件会自动选择SP_ELx。
操作系统负责分配和保证每个异常等级EL对应的栈，是可用的。

异常处理的执行模式

当异常发生时，切换到高级别的EL，这个EL运行在哪个模式？Aarch64 or Aarch32?
- HCR_EL2.RW记录了EL1要运行在哪个模式？
  - 1：表示aarch64
  - 0：表示aarch32
当异常发生后，执行模式可以发生改变。
一个aarch32位的应用程序正在运行，这时候来了一个中断，它可能会跑到aarch64执行状态下的EL1里处理这个中断。

异常返回的执行模式

从一个异常返回时，SPSR寄存器记录了：
- 返回到哪个EL?SPSR.M[3:0]
- 返回目标EL的执行模式？SPSR.M[4]
- M[4] = 0, 表示aarch64; M[4] = 1, 表示aarch32;

M4记录了异常现场时的执行模式，保存了PSTATE.nRW的值
图 1

练习——从EL2切换到EL1

步骤如下：

设置HCR_EL2寄存器，最重要的是Bit 31的RW域，表示EL1要运行在哪个执行环境里？
设置SCTLR_EL1寄存器，需要设置大小端和关闭MMU。
设置SPSR_EL2寄存器，设置模式M域为EL1h,另外需要关闭所有的DAIF。
设置异常返回寄存器elr_el2，让其返回到el1_entry汇编函数里
执行eret
第三步-第四步实际上是一个异常返回的经典步骤，从EL2返回到EL1

展开全文 >>

如何过maps检测

IO重定向，当发现__openat打开的是*/proc/self/maps或者/proc/{pid}/maps*这样的文件时，可以选择替换路径或者替换文件描述符fd，稳定的做法是fd替换，以下描述的也是fd替换。
创建一个临时的maps文件，把原fd的内容经过过滤后写入到这个临时maps文件当中，过滤一般像frida这些so之类的，然后删掉这个文件（Linux内核不会立即删掉该文件，而是在释放文件（close掉）描述符fd之后再进行删除），此时把这个临时的fd返回,这样就替换掉了原fd，且内容为我们想让app读取到的maps。

具体代码参考珍惜的68课如何过maps检测，这节课讲的很详细，但具体思路如上

展开全文 >>

unix_domain_socket(UDS)学习

2021-07-28

前言

由于本人考虑在aosp沙箱的native层代码当中建立进程间的通信，然后观看源码发现其采用的是一种用于本地进程间通信的套接字——Unix Domain Socket，UDS与原来的网络Socket相比，仅仅只需要在进程间复制数据，无需处理协议、计算校验和、维护序号、添加和删除网络爆头、发送确认报文，因此更高效，速度更快。

UDS的创建与网络Socket的创建类似：

创建一个Socket，指定family为AF_UNIX，type支持SOCK_STRAEM和SOCK_DGRAM两种；
bind地址，与网络Socket不同，UDS所绑定的对象是一个文件；
开始监听accept；
接收请求accept，为每个连接建立新的套接字，并从监听队列队列中移除。

编写实例

#include <sys/socket.h>
#include <sys/un.h>

unix_socket = socket(AF_UNIX, type, 0);
error = socketpair(AF_UNIX, type, 0, int *sv);

展开全文 >>

动态更改系统设备属性

2021-07-24

通过property_set可以轻松设置系统属性,但是并不是所有的进程都可以对系统属性进行修改，Android将属性的设置统一交由init进程管理，言下之意即使是root进程也无法进行系统属性的更改，若想实现动态修改系统属性，我们必须在init进程下进行。

展开全文 >>

集成frida-server到系统源码当中

2021-07-22

准备阶段

在Android中，当执行adb命令时，实际上是和adbd进行交互，所以当我们进行adb root权限实际上是配置手机中的adbd运行在root权限的情况下。

adbd中涉及判断adb root权限开启判断源文件文件路径
system/core/adb/daemon/main.cpp
图 1
看到aosp10的源码这里，当我们执行adb root时，实际上就是跑了这个函数。

通过判断ro.secure是否为0来判断是否该进行降权处理，如果确定需要降权则adbd的权限将会降为现有用户进行运行，为0则表示不需要降权。
通过修改ro.adb.secure=0表示adb默认授权打开，不用弹出adb授权弹框

adb root用户权限配置

有两种方式

修改main.mk属性
路径build/make/core/main.mk
在源码编译时会通过该文件进行一些属性的设置。

比如说此处，会判断当前要编译的是user/userdebug类型，如果是user则把ADDITIONAL_DEFAULT_PROPERTIES += ro.adb.secure=1以及ADDITIONAL_DEFAULT_PROPERTIES += ro.secure=1需要进行降权处理和adb授权弹框打开。

所以如果要编译user版本，可以把ro.secure=1改为ro.secure=0不进项降权处理以root用户运行。ro.adb.secure=1改为0不进行adb授权弹框。

但是这种方式容易被检测出来：通过获取ro.secure/ro.adb.secure是否为0来判断手机是否为root。

修改adbd源码
文件路径system/core/adb/daemon/main.cpp

通过修改auth_required值为false把授权框关闭。接着点击进入这个地方。

图 5
看注释的意思判断系统是否处于secure模式，如果存在就不要以root用户的身份运行。
图 6
来到该函数发现，这就是刚才我们分析的第一个函数我们直接看到，这个位置

1
2
3

if (ro_debuggable && adb_root) {
        drop = false;
    }

ro_debuggable和adb_root都为1时则返回false,行，那我们都不去走上面的流程，在该函数的开头直接返回false即可。

该方式不难看出有一大优点——不用修改ro.adb.secure和ro.secure为1，则root检测如果检测这两个点，则我们是不是就把root给过了呢？

通过上面简述两种方式，我们不难做出选择，第二种最为合适，即使我们把系统编译成userdebug那么root检测这两个点对我们是无效的，因为我们根本就没改这两个点为0。

整合frida-server到系统当中

在/frameworks/base/cmds目录下（ps: 如果编译过xposed源码，会对/frameworks/base/cmds目录感到熟悉，因为xposed的一部分关键native逻辑（即Xposed的github项目下的Xposed项目）也是需要放到该目录下的。）创建一个用于存放fridaserver的目录，给出我创建的路径/frameworks/base/cmds/juziss/fs_server(此处只是文件夹路径)，然后把下载好的fridaserver解压放到该目录里,然后修改fridaserver的名字，自行修改，比如我就改成juzissFs,改好之后创建Android.mk(该模块用于添加一些编译模块的规则)
以下给出mk的内容

LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)



LOCAL_MODULE := juzissFs // 指定模块名称
LOCAL_MODULE_CLASS := EXECUTABLES // 指定模块为可执行程序
LOCAL_SRC_FILES := juzissFs // 指定编译文件
include $(BUILD_PREBUILT) // 指定预编译模式

此时我们就把frida的模块给建立好了，但是！此时我们还没有把该模块加入到源码编译的编译链当中。 如果现在编译，则该模块是不会被编译进系统当中的。

把源码加入到编译链当中

增加模块到源码编译链的路径为
build/make/target/product/base_system.mk

图 7
随意在这堆模块当中插入我们的编译模块名即可。（模块名为Android.mk里的LOCAL_MODULE := juzissFs,即我这插入的就是juzissFs）

随后直接编译即可

验证

adb shell ps -Z |grep "adbd"
查看当前adbd是否运行在su下
juzissFs --version查看当前内置的版本是否为我们下载好的frida-server版本

完成以上两步即可验证成功。

设置frida-server为后台进程

在selinux开启的情况下启动frida-server方法

介绍两种

init.xx.rc文件中的配置

在安卓系统当中配置native后台服务，主要是在init.xx.rc文件中添加服务配置信息。
比如adbd的后台服务配置文件
/system/core/rootdir/init.usb.rc
图 8

这种方法配置主要是通过init进程进行解析init.xx.rc文件来进行启动的。该方法启动有一条限制如果配置的后台服务需要用到root权限，如frida-server启动之后需要ptrace来attach进程，这种情况最好把selinux关闭。这样在init.xx.rc进行配置才能达到预期效果。

以下给出参考配置

service juzissFs /system/bin/juzissFs -D
    class main
    user root
    seclabel u:r:init:s0

juzissFs为进程名，/system/bin/juzissFs -D为启动命令（实际上就是执行juzissFs -D这个命令），class main指定进程分到的类， user root以root用户运行（即使不写该命令也会默认走root用户，也就是说该命令可有可无），seclabel u:r:init:s0 指定进程所运行的安全域。

进程中启动服务配置
选择合适的后台进程，调用system函数（syscall）进行服务启动。可选root的adbd或者root的init进程。

测试后台服务是否运行

针对上面两种分别给出测试方式

init.xx.rc中配置
在selinux开启的情况下，由于init进程被限制了很多功能，比如禁止ptrace其他进程，所以frida-server的好多功能会失效。虽然init进程运行的是root用户，但是selinux的域为init,所以很多特权功能被限制，所以如果不是很在乎selinux的情况下，关闭selinux之后在进行配置。
进程中启动服务

进程中启动服务主要是需要找到权限高的进程作为母体。如init、adbd进程。由于init进程所运行的域为init而selinux的运行也在init域当中，这就会导致init域下的特权服务被限制，所以init进程不适合启动frida-server。如果在adbd以root权限运行，并且把运行的标签改成u:r:su:s0，则adbd作为母体启动服务之后，服务就存在超级权限，则运行frida-server自然也就可以使用特权功能，运行自然也没有问题，所以比较适合frida-server。

查看init进程和adbd进程运行的selinux域

adb shell ps -Z |grep adbd
adb shell ps -Z |grep init

adbd启动fridaserver

查找合适的启动入口

在adbd启动过程中，会根据传入的参数如果存在root_seclabel会将adbd进程的域由u:r:adbd:s0修改为u:r:su:s0域。该逻辑位于system/core/adb/daemon/main.cpp中。
图 9
也就是前面提到adbd如何走root权限的地方，通过selinux_android_setcon函数设置，从变量名也可以看的出来root_seclabelroot标签，修改当前进程的域为u:r:su:s0从而使得adbd获得root权限。

所以我们可以考虑在执行完selinux_android_setcon函数之后启动我们的fridaserver逻辑。

展开全文 >>

前言

动态调试

要找到什么样的cmp代码

如何确定flag和输入

从第一行开始分析

加密的流程

加密算法还原

解密算法还原

程序代码

Rust变量与可变性

声明一个变量

声明一个常量

隐藏变量

隐藏机制与mut的区别

数据类型

标量类型

整数类型

有符号和无符号的选择

整数溢出

浮点数类型

布尔型

字符类型

复合类型

元组 （tuple）

元组元素提取

数组

数组的访问

动态数组(vector)类型

函数

函数的返回值

特殊的赋值写法

循环

loop

示例：

while

for

为什么要学习rust

Hello World

如何运行一个rust程序

rust cargo

cargo创建项目

项目结构

使用Cargo构建和运行项目

frida-dumps原理

通过文件格式来进行校验

后续葫芦娃对frida-dumps进行的迭代

Arm64学习笔记

加载指令

LDR和STR

指令变种

LDR寻址模式

地址偏移模式

变基模式

LDR伪指令

MOV和MOVZ

多字节的加载和存储LDP和STP指令

移位和算术

条件状态码

ADD加法指令

SUB减法指令

带进位的加法指令

带进位的减法指令

CMP比较指令

XZR寄存器、wzr寄存器

移位操作

按位与操作

按位或操作

异或操作规律

异或操作的几个小妙用

位段操作

插入操作

提取操作

零计数指令CLZ

比较与跳转指令

条件操作后缀

条件选择指令

基本跳转指令

无条件的跳转指令

有条件的跳转指令

bx指令

元组（tuple）